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
2058 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled)
2059 {
2060   Dali::Actor c_result;
2061   void* jresult = 0;
2062
2063   if(!swig_callbackGetNextKeyboardFocusableActor)
2064   {
2065     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2066   }
2067   else
2068   {
2069     jresult = (void*)swig_callbackGetNextKeyboardFocusableActor((void*)(&currentFocusedActor), (int)direction, loopEnabled);
2070
2071     if(!jresult)
2072     {
2073       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2074       return c_result;
2075     }
2076     c_result = *(Dali::Actor*)jresult;
2077   }
2078   return c_result;
2079 }
2080
2081 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor)
2082 {
2083   if(!swig_callbackOnKeyboardFocusChangeCommitted)
2084   {
2085     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2086     return;
2087   }
2088   else
2089   {
2090     swig_callbackOnKeyboardFocusChangeCommitted((void*)(&commitedFocusableActor));
2091   }
2092 }
2093
2094 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2095   bool c_result = SwigValueInit< bool >() ;
2096   unsigned int jresult = 0 ;
2097
2098   if (!swig_callbackOnKeyboardEnter) {
2099     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2100   } else {
2101     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2102     c_result = jresult ? true : false;
2103   }
2104   return c_result;
2105 }
2106
2107 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2108   void * jpinch = 0 ;
2109
2110   if (!swig_callbackOnPinch) {
2111     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2112     return;
2113   } else {
2114     jpinch = (Dali::PinchGesture *) &pinch;
2115     swig_callbackOnPinch(jpinch);
2116   }
2117 }
2118
2119 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2120   void * jpan = 0 ;
2121
2122   if (!swig_callbackOnPan) {
2123     Dali::Toolkit::Internal::Control::OnPan(pan);
2124     return;
2125   } else {
2126     jpan = (Dali::PanGesture *) &pan;
2127     swig_callbackOnPan(jpan);
2128   }
2129 }
2130
2131 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2132   void * jtap = 0 ;
2133
2134   if (!swig_callbackOnTap) {
2135     Dali::Toolkit::Internal::Control::OnTap(tap);
2136     return;
2137   } else {
2138     jtap = (Dali::TapGesture *) &tap;
2139     swig_callbackOnTap(jtap);
2140   }
2141 }
2142
2143 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2144   void * jlongPress = 0 ;
2145
2146   if (!swig_callbackOnLongPress) {
2147     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2148     return;
2149   } else {
2150     jlongPress = (Dali::LongPressGesture *) &longPress;
2151     swig_callbackOnLongPress(jlongPress);
2152   }
2153 }
2154
2155 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2156   void * jslotObserver = 0 ;
2157   void * jcallback = 0 ;
2158
2159   if (!swig_callbackSignalConnected) {
2160     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2161     return;
2162   } else {
2163     jslotObserver = (void *) slotObserver;
2164     jcallback = (void *) callback;
2165     swig_callbackSignalConnected(jslotObserver, jcallback);
2166   }
2167 }
2168
2169 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2170   void * jslotObserver = 0 ;
2171   void * jcallback = 0 ;
2172
2173   if (!swig_callbackSignalDisconnected) {
2174     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2175     return;
2176   } else {
2177     jslotObserver = (void *) slotObserver;
2178     jcallback = (void *) callback;
2179     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2180   }
2181 }
2182
2183 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2184   return Dali::Toolkit::Internal::Control::GetControlExtension();
2185 }
2186
2187 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) {
2188   swig_callbackOnSceneConnection = callbackOnSceneConnection;
2189   swig_callbackOnSceneDisconnection = callbackOnSceneDisconnection;
2190   swig_callbackOnChildAdd = callbackOnChildAdd;
2191   swig_callbackOnChildRemove = callbackOnChildRemove;
2192   swig_callbackOnPropertySet = callbackOnPropertySet;
2193   swig_callbackOnSizeSet = callbackOnSizeSet;
2194   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2195   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2196   swig_callbackOnRelayout = callbackOnRelayout;
2197   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2198   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2199   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2200   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2201   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2202   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2203   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2204   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2205   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2206   swig_callbackOnInitialize = callbackOnInitialize;
2207   swig_callbackOnStyleChange = callbackOnStyleChange;
2208   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2209   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2210   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2211   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2212   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2213   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2214   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2215   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2216   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2217   swig_callbackOnPinch = callbackOnPinch;
2218   swig_callbackOnPan = callbackOnPan;
2219   swig_callbackOnTap = callbackOnTap;
2220   swig_callbackOnLongPress = callbackOnLongPress;
2221   swig_callbackSignalConnected = callbackSignalConnected;
2222   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2223 }
2224
2225 void SwigDirector_ViewImpl::swig_init_callbacks() {
2226   swig_callbackOnSceneConnection = 0;
2227   swig_callbackOnSceneDisconnection = 0;
2228   swig_callbackOnChildAdd = 0;
2229   swig_callbackOnChildRemove = 0;
2230   swig_callbackOnPropertySet = 0;
2231   swig_callbackOnSizeSet = 0;
2232   swig_callbackOnSizeAnimation = 0;
2233   swig_callbackOnKeyEvent = 0;
2234   swig_callbackOnRelayout = 0;
2235   swig_callbackOnSetResizePolicy = 0;
2236   swig_callbackGetNaturalSize = 0;
2237   swig_callbackCalculateChildSize = 0;
2238   swig_callbackGetHeightForWidth = 0;
2239   swig_callbackGetWidthForHeight = 0;
2240   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2241   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2242   swig_callbackOnCalculateRelayoutSize = 0;
2243   swig_callbackOnLayoutNegotiated = 0;
2244   swig_callbackOnInitialize = 0;
2245   swig_callbackOnStyleChange = 0;
2246   swig_callbackOnAccessibilityActivated = 0;
2247   swig_callbackOnAccessibilityPan = 0;
2248   swig_callbackOnAccessibilityValueChange = 0;
2249   swig_callbackOnAccessibilityZoom = 0;
2250   swig_callbackOnKeyInputFocusGained = 0;
2251   swig_callbackOnKeyInputFocusLost = 0;
2252   swig_callbackGetNextKeyboardFocusableActor = 0;
2253   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2254   swig_callbackOnKeyboardEnter = 0;
2255   swig_callbackOnPinch = 0;
2256   swig_callbackOnPan = 0;
2257   swig_callbackOnTap = 0;
2258   swig_callbackOnLongPress = 0;
2259   swig_callbackSignalConnected = 0;
2260   swig_callbackSignalDisconnected = 0;
2261 }
2262
2263 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2264   swig_init_callbacks();
2265 }
2266
2267 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2268
2269 }
2270
2271
2272 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2273   unsigned int c_result = SwigValueInit< unsigned int >() ;
2274   unsigned int jresult = 0 ;
2275
2276   if (!swig_callbackGetNumberOfItems) {
2277     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2278   } else {
2279     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2280     c_result = (unsigned int)jresult;
2281   }
2282   return c_result;
2283 }
2284
2285 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2286   Dali::Actor c_result ;
2287   void * jresult = 0 ;
2288   unsigned int jitemId  ;
2289
2290   if (!swig_callbackNewItem) {
2291     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2292   } else {
2293     jitemId = itemId;
2294     jresult = (void *) swig_callbackNewItem(jitemId);
2295     if (!jresult) {
2296       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2297       return c_result;
2298     }
2299     c_result = *(Dali::Actor *)jresult;
2300   }
2301   return c_result;
2302 }
2303
2304 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor)
2305 {
2306   if(!swig_callbackItemReleased)
2307   {
2308     Dali::Toolkit::ItemFactory::ItemReleased(itemId, actor);
2309     return;
2310   }
2311   else
2312   {
2313     swig_callbackItemReleased(itemId, (void*)(&actor));
2314   }
2315 }
2316
2317 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2318   return Dali::Toolkit::ItemFactory::GetExtension();
2319 }
2320
2321 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2322   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2323   swig_callbackNewItem = callbackNewItem;
2324   swig_callbackItemReleased = callbackItemReleased;
2325 }
2326
2327 void SwigDirector_ItemFactory::swig_init_callbacks() {
2328   swig_callbackGetNumberOfItems = 0;
2329   swig_callbackNewItem = 0;
2330   swig_callbackItemReleased = 0;
2331 }
2332
2333 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2334   swig_init_callbacks();
2335 }
2336
2337 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2338
2339 }
2340
2341
2342 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction, const std::string& deviceName)
2343 {
2344   Dali::Actor c_result;
2345   void* jresult = 0;
2346
2347   if(!swig_callbackGetNextFocusableActor)
2348   {
2349     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2350   }
2351   else
2352   {
2353     jresult = (void*)swig_callbackGetNextFocusableActor((void*)(&current), (void*)(&proposed), direction, deviceName.c_str());
2354     if(!jresult)
2355     {
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   if (!jarg1) {
22338     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22339     return 0;
22340   }
22341
22342   if (!jarg2) {
22343     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg2 is null!");
22344     return 0;
22345   }
22346
22347   arg1 = (Dali::Actor *)jarg1;
22348   arg2 = (Dali::Actor *)jarg2;
22349   {
22350     try {
22351       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
22352     } CALL_CATCH_EXCEPTION(0);
22353   }
22354
22355   jresult = (void *)result;
22356   return jresult;
22357 }
22358
22359
22360 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
22361   char * jresult ;
22362   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22363   std::string *result = 0 ;
22364   std::string name = "";
22365
22366   if (!jarg1) {
22367     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22368     return 0;
22369   }
22370
22371   arg1 = (Dali::Actor *)jarg1;
22372   {
22373     try {
22374       name = ((Dali::Actor const *)arg1)->GetProperty< std::string >( Dali::Actor::Property::NAME );
22375       result = (std::string *) &name;
22376       jresult = SWIG_csharp_string_callback(result->c_str());
22377     } CALL_CATCH_EXCEPTION(0);
22378   }
22379   return jresult;
22380 }
22381
22382
22383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
22384   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22385   std::string *arg2 = 0 ;
22386
22387   if (!jarg1) {
22388     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22389     return ;
22390   }
22391
22392   arg1 = (Dali::Actor *)jarg1;
22393   if (!jarg2) {
22394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22395     return ;
22396   }
22397   std::string arg2_str(jarg2);
22398   arg2 = &arg2_str;
22399   {
22400     try {
22401       (arg1)->SetProperty( Dali::Actor::Property::NAME, (std::string const &)*arg2);
22402     } CALL_CATCH_EXCEPTION();
22403   }
22404
22405
22406   //argout typemap for const std::string&
22407
22408 }
22409
22410
22411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
22412   unsigned int jresult ;
22413   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22414   unsigned int result;
22415
22416   arg1 = (Dali::Actor *)jarg1;
22417
22418   if(!arg1) {
22419     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
22420     return -1;
22421   }
22422
22423   {
22424     try {
22425       result = (unsigned int)((Dali::Actor const *)arg1)->GetProperty< int >( Actor::Property::ID );
22426     } CALL_CATCH_EXCEPTION(0);
22427   }
22428
22429   jresult = result;
22430   return jresult;
22431 }
22432
22433
22434 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
22435   bool jresult ;
22436   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22437   bool result;
22438
22439   if (!jarg1) {
22440     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22441     return 0;
22442   }
22443
22444   arg1 = (Dali::Actor *)jarg1;
22445   {
22446     try {
22447       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_ROOT );
22448     } CALL_CATCH_EXCEPTION(0);
22449   }
22450
22451   jresult = result;
22452   return jresult;
22453 }
22454
22455
22456 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
22457   bool jresult ;
22458   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22459   bool result;
22460
22461   if (!jarg1) {
22462     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22463     return 0;
22464   }
22465
22466   arg1 = (Dali::Actor *)jarg1;
22467   {
22468     try {
22469       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE );
22470     } CALL_CATCH_EXCEPTION(0);
22471   }
22472
22473   jresult = result;
22474   return jresult;
22475 }
22476
22477
22478 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
22479   bool jresult ;
22480   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22481   bool result;
22482
22483   if (!jarg1) {
22484     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22485     return 0;
22486   }
22487
22488   arg1 = (Dali::Actor *)jarg1;
22489   {
22490     try {
22491       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_LAYER );
22492     } CALL_CATCH_EXCEPTION(0);
22493   }
22494
22495   jresult = result;
22496   return jresult;
22497 }
22498
22499
22500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
22501   void * jresult ;
22502   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22503   Dali::Layer result;
22504
22505   if (!jarg1) {
22506     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22507     return 0;
22508   }
22509
22510   arg1 = (Dali::Actor *)jarg1;
22511   {
22512     try {
22513       result = (arg1)->GetLayer();
22514     } CALL_CATCH_EXCEPTION(0);
22515   }
22516
22517   jresult = new Dali::Layer((const Dali::Layer &)result);
22518   return jresult;
22519 }
22520
22521
22522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
22523   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22524   Dali::Actor arg2 ;
22525
22526   if (!jarg1) {
22527     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22528     return ;
22529   }
22530   if (!jarg2) {
22531     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg2 is null!");
22532     return ;
22533   }
22534
22535   arg1 = (Dali::Actor *)jarg1;
22536   arg2 = *((Dali::Actor *)jarg2);
22537   {
22538     try {
22539       (arg1)->Add(arg2);
22540     } CALL_CATCH_EXCEPTION();
22541   }
22542
22543 }
22544
22545
22546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
22547   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22548   Dali::Actor arg2 ;
22549
22550   if (!jarg1) {
22551     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22552     return ;
22553   }
22554   if (!jarg2) {
22555     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg2 is null!");
22556     return ;
22557   }
22558
22559   arg1 = (Dali::Actor *)jarg1;
22560   arg2 = *((Dali::Actor *)jarg2);
22561   {
22562     try {
22563       (arg1)->Remove(arg2);
22564     } CALL_CATCH_EXCEPTION();
22565   }
22566
22567 }
22568
22569
22570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
22571   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22572
22573   if (!jarg1) {
22574     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22575     return ;
22576   }
22577
22578   arg1 = (Dali::Actor *)jarg1;
22579   {
22580     try {
22581       (arg1)->Unparent();
22582     } CALL_CATCH_EXCEPTION();
22583   }
22584
22585 }
22586
22587
22588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
22589   unsigned int jresult ;
22590   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22591   unsigned int result;
22592
22593   if (!jarg1) {
22594     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22595     return 0;
22596   }
22597
22598   arg1 = (Dali::Actor *)jarg1;
22599   {
22600     try {
22601       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
22602     } CALL_CATCH_EXCEPTION(0);
22603   }
22604
22605   jresult = result;
22606   return jresult;
22607 }
22608
22609
22610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
22611   void * jresult ;
22612   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22613   unsigned int arg2 ;
22614   Dali::Actor result;
22615
22616   if (!jarg1) {
22617     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22618     return 0;
22619   }
22620
22621   arg1 = (Dali::Actor *)jarg1;
22622   arg2 = (unsigned int)jarg2;
22623   {
22624     try {
22625       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
22626     } CALL_CATCH_EXCEPTION(0);
22627   }
22628
22629   jresult = new Dali::Actor((const Dali::Actor &)result);
22630   return jresult;
22631 }
22632
22633
22634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
22635   void * jresult ;
22636   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22637   std::string *arg2 = 0 ;
22638   Dali::Actor result;
22639
22640   if (!jarg1) {
22641     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22642     return 0;
22643   }
22644
22645   arg1 = (Dali::Actor *)jarg1;
22646   if (!jarg2) {
22647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22648     return 0;
22649   }
22650   std::string arg2_str(jarg2);
22651   arg2 = &arg2_str;
22652   {
22653     try {
22654       result = (arg1)->FindChildByName((std::string const &)*arg2);
22655     } CALL_CATCH_EXCEPTION(0);
22656   }
22657
22658   jresult = new Dali::Actor((const Dali::Actor &)result);
22659
22660   //argout typemap for const std::string&
22661
22662   return jresult;
22663 }
22664
22665
22666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
22667   void * jresult ;
22668   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22669   unsigned int arg2 ;
22670   Dali::Actor result;
22671
22672   if (!jarg1) {
22673     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22674     return 0;
22675   }
22676
22677   arg1 = (Dali::Actor *)jarg1;
22678   arg2 = (unsigned int)jarg2;
22679   {
22680     try {
22681       result = (arg1)->FindChildById(arg2);
22682     } CALL_CATCH_EXCEPTION(0);
22683   }
22684
22685   jresult = new Dali::Actor((const Dali::Actor &)result);
22686   return jresult;
22687 }
22688
22689
22690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
22691   void * jresult ;
22692   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22693   Dali::Actor result;
22694
22695   if (!jarg1) {
22696     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22697     return 0;
22698   }
22699
22700   arg1 = (Dali::Actor *)jarg1;
22701   {
22702     try {
22703       result = ((Dali::Actor const *)arg1)->GetParent();
22704     } CALL_CATCH_EXCEPTION(0);
22705   }
22706
22707   jresult = new Dali::Actor((const Dali::Actor &)result);
22708   return jresult;
22709 }
22710
22711
22712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
22713   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22714   Dali::Vector3 *arg2 = 0 ;
22715
22716   if (!jarg1) {
22717     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22718     return ;
22719   }
22720
22721   arg1 = (Dali::Actor *)jarg1;
22722   arg2 = (Dali::Vector3 *)jarg2;
22723   if (!arg2) {
22724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22725     return ;
22726   }
22727   {
22728     try {
22729       (arg1)->SetProperty( Actor::Property::PARENT_ORIGIN,(Dali::Vector3 const &)*arg2);
22730     } CALL_CATCH_EXCEPTION();
22731   }
22732
22733 }
22734
22735
22736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
22737   void * jresult ;
22738   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22739   Dali::Vector3 result;
22740
22741   if (!jarg1) {
22742     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22743     return 0;
22744   }
22745
22746   arg1 = (Dali::Actor *)jarg1;
22747   {
22748     try {
22749       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN );
22750     } CALL_CATCH_EXCEPTION(0);
22751   }
22752
22753   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22754   return jresult;
22755 }
22756
22757
22758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
22759   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22760   Dali::Vector3 *arg2 = 0 ;
22761
22762   if (!jarg1) {
22763     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22764     return ;
22765   }
22766
22767   arg1 = (Dali::Actor *)jarg1;
22768   arg2 = (Dali::Vector3 *)jarg2;
22769   if (!arg2) {
22770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22771     return ;
22772   }
22773   {
22774     try {
22775       (arg1)->SetProperty( Actor::Property::ANCHOR_POINT,(Dali::Vector3 const &)*arg2);
22776     } CALL_CATCH_EXCEPTION();
22777   }
22778
22779 }
22780
22781
22782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
22783   void * jresult ;
22784   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22785   Dali::Vector3 result;
22786
22787   if (!jarg1) {
22788     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22789     return 0;
22790   }
22791
22792   arg1 = (Dali::Actor *)jarg1;
22793   {
22794     try {
22795       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
22796     } CALL_CATCH_EXCEPTION(0);
22797   }
22798
22799   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22800   return jresult;
22801 }
22802
22803
22804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
22805   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22806   float arg2 ;
22807   float arg3 ;
22808
22809   if (!jarg1) {
22810     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22811     return ;
22812   }
22813
22814   arg1 = (Dali::Actor *)jarg1;
22815   arg2 = (float)jarg2;
22816   arg3 = (float)jarg3;
22817   {
22818     try {
22819       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector2(arg2,arg3) );
22820     } CALL_CATCH_EXCEPTION();
22821   }
22822
22823 }
22824
22825
22826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
22827   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22828   float arg2 ;
22829   float arg3 ;
22830   float arg4 ;
22831
22832   if (!jarg1) {
22833     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22834     return ;
22835   }
22836
22837   arg1 = (Dali::Actor *)jarg1;
22838   arg2 = (float)jarg2;
22839   arg3 = (float)jarg3;
22840   arg4 = (float)jarg4;
22841   {
22842     try {
22843       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector3(arg2,arg3,arg4) );
22844     } CALL_CATCH_EXCEPTION();
22845   }
22846
22847 }
22848
22849
22850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
22851   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22852   Dali::Vector2 *arg2 = 0 ;
22853
22854   if (!jarg1) {
22855     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22856     return ;
22857   }
22858
22859   arg1 = (Dali::Actor *)jarg1;
22860   arg2 = (Dali::Vector2 *)jarg2;
22861   if (!arg2) {
22862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
22863     return ;
22864   }
22865   {
22866     try {
22867       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector2 const &)*arg2);
22868     } CALL_CATCH_EXCEPTION();
22869   }
22870
22871 }
22872
22873
22874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
22875   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22876   Dali::Vector3 *arg2 = 0 ;
22877
22878   if (!jarg1) {
22879     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22880     return ;
22881   }
22882
22883   arg1 = (Dali::Actor *)jarg1;
22884   arg2 = (Dali::Vector3 *)jarg2;
22885   if (!arg2) {
22886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22887     return ;
22888   }
22889   {
22890     try {
22891       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector3 const &)*arg2);
22892     } CALL_CATCH_EXCEPTION();
22893   }
22894
22895 }
22896
22897
22898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
22899   void * jresult ;
22900   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22901   Dali::Vector3 result;
22902
22903   if (!jarg1) {
22904     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22905     return 0;
22906   }
22907
22908   arg1 = (Dali::Actor *)jarg1;
22909   {
22910     try {
22911       result = ((Dali::Actor const *)arg1)->GetTargetSize();
22912     } CALL_CATCH_EXCEPTION(0);
22913   }
22914
22915   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22916   return jresult;
22917 }
22918
22919
22920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
22921   void * jresult ;
22922   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22923   Dali::Vector3 result;
22924
22925   if (!jarg1) {
22926     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22927     return 0;
22928   }
22929
22930   arg1 = (Dali::Actor *)jarg1;
22931   {
22932     try {
22933       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
22934     } CALL_CATCH_EXCEPTION(0);
22935   }
22936
22937   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22938   return jresult;
22939 }
22940
22941
22942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
22943   void * jresult ;
22944   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22945   Dali::Vector3 result;
22946
22947   if (!jarg1) {
22948     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22949     return 0;
22950   }
22951
22952   arg1 = (Dali::Actor *)jarg1;
22953   {
22954     try {
22955       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
22956     } CALL_CATCH_EXCEPTION(0);
22957   }
22958
22959   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22960   return jresult;
22961 }
22962
22963
22964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
22965   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22966   float arg2 ;
22967   float arg3 ;
22968
22969   if (!jarg1) {
22970     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22971     return ;
22972   }
22973
22974   arg1 = (Dali::Actor *)jarg1;
22975   arg2 = (float)jarg2;
22976   arg3 = (float)jarg3;
22977   {
22978     try {
22979       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector2( arg2, arg3 ) );
22980     } CALL_CATCH_EXCEPTION();
22981   }
22982
22983 }
22984
22985
22986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
22987   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22988   float arg2 ;
22989   float arg3 ;
22990   float arg4 ;
22991
22992   if (!jarg1) {
22993     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22994     return ;
22995   }
22996
22997   arg1 = (Dali::Actor *)jarg1;
22998   arg2 = (float)jarg2;
22999   arg3 = (float)jarg3;
23000   arg4 = (float)jarg4;
23001   {
23002     try {
23003       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector3( arg2, arg3, arg4 ) );
23004     } CALL_CATCH_EXCEPTION();
23005   }
23006
23007 }
23008
23009
23010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
23011   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23012   Dali::Vector3 *arg2 = 0 ;
23013
23014   if (!jarg1) {
23015     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23016     return ;
23017   }
23018
23019   arg1 = (Dali::Actor *)jarg1;
23020   arg2 = (Dali::Vector3 *)jarg2;
23021   if (!arg2) {
23022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23023     return ;
23024   }
23025   {
23026     try {
23027       (arg1)->SetProperty( Actor::Property::POSITION, (Dali::Vector3 const &)*arg2 );
23028     } CALL_CATCH_EXCEPTION();
23029   }
23030
23031 }
23032
23033
23034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
23035   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23036   float arg2 ;
23037
23038   if (!jarg1) {
23039     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23040     return ;
23041   }
23042
23043   arg1 = (Dali::Actor *)jarg1;
23044   arg2 = (float)jarg2;
23045   {
23046     try {
23047       (arg1)->SetProperty( Actor::Property::POSITION_X, (arg2) );
23048     } CALL_CATCH_EXCEPTION();
23049   }
23050
23051 }
23052
23053
23054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
23055   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23056   float arg2 ;
23057
23058   if (!jarg1) {
23059     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23060     return ;
23061   }
23062
23063   arg1 = (Dali::Actor *)jarg1;
23064   arg2 = (float)jarg2;
23065   {
23066     try {
23067       (arg1)->SetProperty( Actor::Property::POSITION_Y, arg2 );
23068     } CALL_CATCH_EXCEPTION();
23069   }
23070
23071 }
23072
23073
23074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
23075   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23076   float arg2 ;
23077
23078   if (!jarg1) {
23079     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23080     return ;
23081   }
23082
23083   arg1 = (Dali::Actor *)jarg1;
23084   arg2 = (float)jarg2;
23085   {
23086     try {
23087       (arg1)->SetProperty( Actor::Property::POSITION_Z, arg2 );
23088     } CALL_CATCH_EXCEPTION();
23089   }
23090
23091 }
23092
23093
23094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
23095   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23096   Dali::Vector3 *arg2 = 0 ;
23097
23098   if (!jarg1) {
23099     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23100     return ;
23101   }
23102
23103   arg1 = (Dali::Actor *)jarg1;
23104   arg2 = (Dali::Vector3 *)jarg2;
23105   if (!arg2) {
23106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23107     return ;
23108   }
23109   {
23110     try {
23111       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
23112     } CALL_CATCH_EXCEPTION();
23113   }
23114
23115 }
23116
23117
23118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
23119   void * jresult ;
23120   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23121   Dali::Vector3 result;
23122
23123   if (!jarg1) {
23124     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23125     return 0;
23126   }
23127
23128   arg1 = (Dali::Actor *)jarg1;
23129   {
23130     try {
23131       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
23132     } CALL_CATCH_EXCEPTION(0);
23133   }
23134
23135   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23136   return jresult;
23137 }
23138
23139
23140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
23141   void * jresult ;
23142   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23143   Dali::Vector3 result;
23144
23145   if (!jarg1) {
23146     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23147     return 0;
23148   }
23149
23150   arg1 = (Dali::Actor *)jarg1;
23151   {
23152     try {
23153       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION );
23154     } CALL_CATCH_EXCEPTION(0);
23155   }
23156
23157   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23158   return jresult;
23159 }
23160
23161
23162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, bool jarg2) {
23163   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23164   bool arg2 ;
23165
23166   if (!jarg1) {
23167     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23168     return ;
23169   }
23170
23171   arg1 = (Dali::Actor *)jarg1;
23172   arg2 = jarg2 ? true : false;
23173   {
23174     try {
23175       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
23176     } CALL_CATCH_EXCEPTION();
23177   }
23178
23179 }
23180
23181
23182 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
23183   bool jresult ;
23184   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23185   bool result;
23186
23187   if (!jarg1) {
23188     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23189     return 0;
23190   }
23191
23192   arg1 = (Dali::Actor *)jarg1;
23193   {
23194     try {
23195       result = (bool)((Dali::Actor const *)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
23196     } CALL_CATCH_EXCEPTION(0);
23197   }
23198
23199   jresult = result;
23200   return jresult;
23201 }
23202
23203
23204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
23205   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23206   Dali::Degree *arg2 = 0 ;
23207   Dali::Vector3 *arg3 = 0 ;
23208
23209   if (!jarg1) {
23210     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23211     return ;
23212   }
23213
23214   arg1 = (Dali::Actor *)jarg1;
23215   arg2 = (Dali::Degree *)jarg2;
23216   if (!arg2) {
23217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
23218     return ;
23219   }
23220   arg3 = (Dali::Vector3 *)jarg3;
23221   if (!arg3) {
23222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23223     return ;
23224   }
23225   {
23226     try {
23227       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
23228     } CALL_CATCH_EXCEPTION();
23229   }
23230
23231 }
23232
23233
23234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
23235   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23236   Dali::Radian *arg2 = 0 ;
23237   Dali::Vector3 *arg3 = 0 ;
23238
23239   if (!jarg1) {
23240     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23241     return ;
23242   }
23243
23244   arg1 = (Dali::Actor *)jarg1;
23245   arg2 = (Dali::Radian *)jarg2;
23246   if (!arg2) {
23247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
23248     return ;
23249   }
23250   arg3 = (Dali::Vector3 *)jarg3;
23251   if (!arg3) {
23252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23253     return ;
23254   }
23255   {
23256     try {
23257       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
23258     } CALL_CATCH_EXCEPTION();
23259   }
23260
23261 }
23262
23263
23264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
23265   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23266   Dali::Quaternion *arg2 = 0 ;
23267
23268   if (!jarg1) {
23269     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23270     return ;
23271   }
23272
23273   arg1 = (Dali::Actor *)jarg1;
23274   arg2 = (Dali::Quaternion *)jarg2;
23275   if (!arg2) {
23276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
23277     return ;
23278   }
23279   {
23280     try {
23281       (arg1)->SetProperty( Actor::Property::ORIENTATION, (Dali::Quaternion const &)*arg2 );
23282     } CALL_CATCH_EXCEPTION();
23283   }
23284
23285 }
23286
23287
23288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
23289   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23290   Dali::Degree *arg2 = 0 ;
23291   Dali::Vector3 *arg3 = 0 ;
23292
23293   if (!jarg1) {
23294     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23295     return ;
23296   }
23297
23298   arg1 = (Dali::Actor *)jarg1;
23299   arg2 = (Dali::Degree *)jarg2;
23300   if (!arg2) {
23301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
23302     return ;
23303   }
23304   arg3 = (Dali::Vector3 *)jarg3;
23305   if (!arg3) {
23306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23307     return ;
23308   }
23309   {
23310     try {
23311       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
23312     } CALL_CATCH_EXCEPTION();
23313   }
23314
23315 }
23316
23317
23318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
23319   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23320   Dali::Radian *arg2 = 0 ;
23321   Dali::Vector3 *arg3 = 0 ;
23322
23323   if (!jarg1) {
23324     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23325     return ;
23326   }
23327
23328   arg1 = (Dali::Actor *)jarg1;
23329   arg2 = (Dali::Radian *)jarg2;
23330   if (!arg2) {
23331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
23332     return ;
23333   }
23334   arg3 = (Dali::Vector3 *)jarg3;
23335   if (!arg3) {
23336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23337     return ;
23338   }
23339   {
23340     try {
23341       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
23342     } CALL_CATCH_EXCEPTION();
23343   }
23344
23345 }
23346
23347
23348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
23349   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23350   Dali::Quaternion *arg2 = 0 ;
23351
23352   if (!jarg1) {
23353     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23354     return ;
23355   }
23356
23357   arg1 = (Dali::Actor *)jarg1;
23358   arg2 = (Dali::Quaternion *)jarg2;
23359   if (!arg2) {
23360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
23361     return ;
23362   }
23363   {
23364     try {
23365       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
23366     } CALL_CATCH_EXCEPTION();
23367   }
23368
23369 }
23370
23371
23372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
23373   void * jresult ;
23374   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23375   Dali::Quaternion result;
23376
23377   if (!jarg1) {
23378     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23379     return 0;
23380   }
23381
23382   arg1 = (Dali::Actor *)jarg1;
23383   {
23384     try {
23385       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION );
23386     } CALL_CATCH_EXCEPTION(0);
23387   }
23388
23389   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
23390   return jresult;
23391 }
23392
23393
23394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, bool jarg2) {
23395   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23396   bool arg2 ;
23397
23398   if (!jarg1) {
23399     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23400     return ;
23401   }
23402
23403   arg1 = (Dali::Actor *)jarg1;
23404   arg2 = jarg2 ? true : false;
23405   {
23406     try {
23407       (arg1)->SetProperty( Actor::Property::INHERIT_ORIENTATION,arg2);
23408     } CALL_CATCH_EXCEPTION();
23409   }
23410
23411 }
23412
23413
23414 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
23415   bool jresult ;
23416   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23417   bool result;
23418
23419   if (!jarg1) {
23420     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23421     return 0;
23422   }
23423
23424   arg1 = (Dali::Actor *)jarg1;
23425   {
23426     try {
23427       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION );
23428     } CALL_CATCH_EXCEPTION(0);
23429   }
23430
23431   jresult = result;
23432   return jresult;
23433 }
23434
23435
23436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
23437   void * jresult ;
23438   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23439   Dali::Quaternion result;
23440
23441   if (!jarg1) {
23442     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23443     return 0;
23444   }
23445
23446   arg1 = (Dali::Actor *)jarg1;
23447   {
23448     try {
23449       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION );
23450     } CALL_CATCH_EXCEPTION(0);
23451   }
23452
23453   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
23454   return jresult;
23455 }
23456
23457
23458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
23459   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23460   float arg2 ;
23461
23462   if (!jarg1) {
23463     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23464     return ;
23465   }
23466
23467   arg1 = (Dali::Actor *)jarg1;
23468   arg2 = (float)jarg2;
23469   {
23470     try {
23471       (arg1)->SetProperty( Actor::Property::SCALE, arg2);
23472     } CALL_CATCH_EXCEPTION();
23473   }
23474
23475 }
23476
23477
23478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
23479   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23480   float arg2 ;
23481   float arg3 ;
23482   float arg4 ;
23483
23484   if (!jarg1) {
23485     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23486     return ;
23487   }
23488
23489   arg1 = (Dali::Actor *)jarg1;
23490   arg2 = (float)jarg2;
23491   arg3 = (float)jarg3;
23492   arg4 = (float)jarg4;
23493   {
23494     try {
23495       (arg1)->SetProperty( Actor::Property::SCALE, Vector3( arg2, arg3, arg4 ) );
23496     } CALL_CATCH_EXCEPTION();
23497   }
23498
23499 }
23500
23501
23502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
23503   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23504   Dali::Vector3 *arg2 = 0 ;
23505
23506   if (!jarg1) {
23507     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23508     return ;
23509   }
23510
23511   arg1 = (Dali::Actor *)jarg1;
23512   arg2 = (Dali::Vector3 *)jarg2;
23513   if (!arg2) {
23514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23515     return ;
23516   }
23517   {
23518     try {
23519       (arg1)->SetProperty( Actor::Property::SCALE, (Dali::Vector3 const &)*arg2 );
23520     } CALL_CATCH_EXCEPTION();
23521   }
23522
23523 }
23524
23525
23526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
23527   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23528   Dali::Vector3 *arg2 = 0 ;
23529
23530   if (!jarg1) {
23531     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23532     return ;
23533   }
23534
23535   arg1 = (Dali::Actor *)jarg1;
23536   arg2 = (Dali::Vector3 *)jarg2;
23537   if (!arg2) {
23538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23539     return ;
23540   }
23541   {
23542     try {
23543       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
23544     } CALL_CATCH_EXCEPTION();
23545   }
23546
23547 }
23548
23549
23550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
23551   void * jresult ;
23552   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23553   Dali::Vector3 result;
23554
23555   if (!jarg1) {
23556     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23557     return 0;
23558   }
23559
23560   arg1 = (Dali::Actor *)jarg1;
23561   {
23562     try {
23563       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
23564     } CALL_CATCH_EXCEPTION(0);
23565   }
23566
23567   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23568   return jresult;
23569 }
23570
23571
23572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
23573   void * jresult ;
23574   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23575   Dali::Vector3 result;
23576
23577   if (!jarg1) {
23578     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23579     return 0;
23580   }
23581
23582   arg1 = (Dali::Actor *)jarg1;
23583   {
23584     try {
23585       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE );
23586     } CALL_CATCH_EXCEPTION(0);
23587   }
23588
23589   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23590   return jresult;
23591 }
23592
23593
23594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, bool jarg2) {
23595   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23596   bool arg2 ;
23597
23598   if (!jarg1) {
23599     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23600     return ;
23601   }
23602
23603   arg1 = (Dali::Actor *)jarg1;
23604   arg2 = jarg2 ? true : false;
23605   {
23606     try {
23607       (arg1)->SetProperty( Actor::Property::INHERIT_SCALE,arg2);
23608     } CALL_CATCH_EXCEPTION();
23609   }
23610
23611 }
23612
23613
23614 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
23615   bool jresult ;
23616   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23617   bool result;
23618
23619   if (!jarg1) {
23620     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23621     return 0;
23622   }
23623
23624   arg1 = (Dali::Actor *)jarg1;
23625   {
23626     try {
23627       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_SCALE );
23628     } CALL_CATCH_EXCEPTION(0);
23629   }
23630
23631   jresult = result;
23632   return jresult;
23633 }
23634
23635
23636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
23637   void * jresult ;
23638   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23639   Dali::Matrix result;
23640
23641   if (!jarg1) {
23642     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23643     return 0;
23644   }
23645
23646   arg1 = (Dali::Actor *)jarg1;
23647   {
23648     try {
23649       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
23650     } CALL_CATCH_EXCEPTION(0);
23651   }
23652
23653   jresult = new Dali::Matrix((const Dali::Matrix &)result);
23654   return jresult;
23655 }
23656
23657
23658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, bool jarg2) {
23659   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23660   bool arg2 ;
23661
23662   if (!jarg1) {
23663     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23664     return ;
23665   }
23666
23667   arg1 = (Dali::Actor *)jarg1;
23668   arg2 = jarg2 ? true : false;
23669   {
23670     try {
23671       (arg1)->SetProperty( Actor::Property::VISIBLE,arg2);
23672     } CALL_CATCH_EXCEPTION();
23673   }
23674
23675 }
23676
23677
23678 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
23679   bool jresult ;
23680   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23681   bool result;
23682
23683   if (!jarg1) {
23684     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23685     return 0;
23686   }
23687
23688   arg1 = (Dali::Actor *)jarg1;
23689   {
23690     try {
23691       result = (bool)((Dali::Actor const *)arg1)->GetCurrentProperty< bool >( Actor::Property::VISIBLE );
23692     } CALL_CATCH_EXCEPTION(0);
23693   }
23694
23695   jresult = result;
23696   return jresult;
23697 }
23698
23699
23700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
23701   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23702   float arg2 ;
23703
23704   if (!jarg1) {
23705     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23706     return ;
23707   }
23708
23709   arg1 = (Dali::Actor *)jarg1;
23710   arg2 = (float)jarg2;
23711   {
23712     try {
23713       (arg1)->SetProperty( Actor::Property::OPACITY,arg2);
23714     } CALL_CATCH_EXCEPTION();
23715   }
23716
23717 }
23718
23719
23720 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
23721   float jresult ;
23722   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23723   float result;
23724
23725   if (!jarg1) {
23726     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23727     return 0;
23728   }
23729
23730   arg1 = (Dali::Actor *)jarg1;
23731   {
23732     try {
23733       result = (float)((Dali::Actor const *)arg1)->GetCurrentProperty< float >( Actor::Property::OPACITY );
23734     } CALL_CATCH_EXCEPTION(0);
23735   }
23736
23737   jresult = result;
23738   return jresult;
23739 }
23740
23741
23742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
23743   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23744   Dali::Vector4 *arg2 = 0 ;
23745
23746   if (!jarg1) {
23747     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23748     return ;
23749   }
23750
23751   arg1 = (Dali::Actor *)jarg1;
23752   arg2 = (Dali::Vector4 *)jarg2;
23753   if (!arg2) {
23754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
23755     return ;
23756   }
23757   {
23758     try {
23759       (arg1)->SetProperty( Actor::Property::COLOR,(Dali::Vector4 const &)*arg2);
23760     } CALL_CATCH_EXCEPTION();
23761   }
23762
23763 }
23764
23765
23766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
23767   void * jresult ;
23768   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23769   Dali::Vector4 result;
23770
23771   if (!jarg1) {
23772     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23773     return 0;
23774   }
23775
23776   arg1 = (Dali::Actor *)jarg1;
23777   {
23778     try {
23779       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::COLOR );
23780     } CALL_CATCH_EXCEPTION(0);
23781   }
23782
23783   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
23784   return jresult;
23785 }
23786
23787
23788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
23789   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23790   Dali::ColorMode arg2 ;
23791
23792   if (!jarg1) {
23793     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23794     return ;
23795   }
23796
23797   arg1 = (Dali::Actor *)jarg1;
23798   arg2 = (Dali::ColorMode)jarg2;
23799   {
23800     try {
23801       (arg1)->SetProperty( Actor::Property::COLOR_MODE,arg2);
23802     } CALL_CATCH_EXCEPTION();
23803   }
23804
23805 }
23806
23807
23808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
23809   int jresult ;
23810   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23811   Dali::ColorMode result;
23812
23813   if (!jarg1) {
23814     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23815     return 0;
23816   }
23817
23818   arg1 = (Dali::Actor *)jarg1;
23819   {
23820     try {
23821       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetProperty< ColorMode >( Actor::Property::COLOR_MODE );
23822     } CALL_CATCH_EXCEPTION(0);
23823   }
23824
23825   jresult = (int)result;
23826   return jresult;
23827 }
23828
23829
23830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
23831   void * jresult ;
23832   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23833   Dali::Vector4 result;
23834
23835   if (!jarg1) {
23836     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23837     return 0;
23838   }
23839
23840   arg1 = (Dali::Actor *)jarg1;
23841   {
23842     try {
23843       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR );
23844     } CALL_CATCH_EXCEPTION(0);
23845   }
23846
23847   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
23848   return jresult;
23849 }
23850
23851
23852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
23853   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23854   Dali::DrawMode::Type arg2 ;
23855
23856   if (!jarg1) {
23857     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23858     return ;
23859   }
23860
23861   arg1 = (Dali::Actor *)jarg1;
23862   arg2 = (Dali::DrawMode::Type)jarg2;
23863   {
23864     try {
23865       (arg1)->SetProperty( Actor::Property::DRAW_MODE,arg2);
23866     } CALL_CATCH_EXCEPTION();
23867   }
23868
23869 }
23870
23871
23872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
23873   int jresult ;
23874   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23875   Dali::DrawMode::Type result;
23876
23877   if (!jarg1) {
23878     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23879     return 0;
23880   }
23881
23882   arg1 = (Dali::Actor *)jarg1;
23883   {
23884     try {
23885       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE );
23886     } CALL_CATCH_EXCEPTION(0);
23887   }
23888
23889   jresult = (int)result;
23890   return jresult;
23891 }
23892
23893
23894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, bool jarg2) {
23895   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23896   bool arg2 ;
23897
23898   if (!jarg1) {
23899     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23900     return ;
23901   }
23902
23903   arg1 = (Dali::Actor *)jarg1;
23904   arg2 = jarg2 ? true : false;
23905   {
23906     try {
23907       (arg1)->SetProperty( Actor::Property::SENSITIVE,arg2);
23908     } CALL_CATCH_EXCEPTION();
23909   }
23910
23911 }
23912
23913
23914 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
23915   bool jresult ;
23916   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23917   bool result;
23918
23919   if (!jarg1) {
23920     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23921     return 0;
23922   }
23923
23924   arg1 = (Dali::Actor *)jarg1;
23925   {
23926     try {
23927       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::SENSITIVE );
23928     } CALL_CATCH_EXCEPTION(0);
23929   }
23930
23931   jresult = result;
23932   return jresult;
23933 }
23934
23935
23936 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
23937   bool jresult ;
23938   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23939   float *arg2 = 0 ;
23940   float *arg3 = 0 ;
23941   float arg4 ;
23942   float arg5 ;
23943   bool result;
23944
23945   if (!jarg1) {
23946     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23947     return 0;
23948   }
23949
23950   arg1 = (Dali::Actor *)jarg1;
23951   arg2 = (float *)jarg2;
23952   arg3 = (float *)jarg3;
23953   arg4 = (float)jarg4;
23954   arg5 = (float)jarg5;
23955   {
23956     try {
23957       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
23958     } CALL_CATCH_EXCEPTION(0);
23959   }
23960
23961   jresult = result;
23962   return jresult;
23963 }
23964
23965
23966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, bool jarg2) {
23967   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23968   bool arg2 ;
23969
23970   if (!jarg1) {
23971     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23972     return ;
23973   }
23974
23975   arg1 = (Dali::Actor *)jarg1;
23976   arg2 = jarg2 ? true : false;
23977   {
23978     try {
23979       (arg1)->SetProperty( Actor::Property::LEAVE_REQUIRED,arg2);
23980     } CALL_CATCH_EXCEPTION();
23981   }
23982
23983 }
23984
23985
23986 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
23987   bool jresult ;
23988   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23989   bool result;
23990
23991   if (!jarg1) {
23992     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23993     return 0;
23994   }
23995
23996   arg1 = (Dali::Actor *)jarg1;
23997   {
23998     try {
23999       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::LEAVE_REQUIRED );
24000     } CALL_CATCH_EXCEPTION(0);
24001   }
24002
24003   jresult = result;
24004   return jresult;
24005 }
24006
24007
24008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, bool jarg2) {
24009   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24010   bool arg2 ;
24011
24012   if (!jarg1) {
24013     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24014     return ;
24015   }
24016
24017   arg1 = (Dali::Actor *)jarg1;
24018   arg2 = jarg2 ? true : false;
24019   {
24020     try {
24021       (arg1)->SetProperty( Actor::Property::KEYBOARD_FOCUSABLE, arg2 );
24022     } CALL_CATCH_EXCEPTION();
24023   }
24024
24025 }
24026
24027
24028 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
24029   bool jresult ;
24030   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24031   bool result;
24032
24033   if (!jarg1) {
24034     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24035     return 0;
24036   }
24037
24038   arg1 = (Dali::Actor *)jarg1;
24039   {
24040     try {
24041       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE );
24042     } CALL_CATCH_EXCEPTION(0);
24043   }
24044
24045   jresult = result;
24046   return jresult;
24047 }
24048
24049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusableChildren(void * actor, bool keyboardFocusableChildren) {
24050   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24051
24052   if (!actor) {
24053     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!");
24054     return ;
24055   }
24056
24057   arg1 = (Dali::Actor *)actor;
24058   {
24059     try {
24060       (arg1)->SetProperty( DevelActor::Property::KEYBOARD_FOCUSABLE_CHILDREN, keyboardFocusableChildren );
24061     } CALL_CATCH_EXCEPTION();
24062   }
24063 }
24064
24065
24066 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_AreChildrenKeyBoardFocusable(void * actor) {
24067   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24068   bool result;
24069
24070   if (!actor) {
24071     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!");
24072     return 0;
24073   }
24074
24075   arg1 = (Dali::Actor *)actor;
24076   {
24077     try {
24078       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( DevelActor::Property::KEYBOARD_FOCUSABLE_CHILDREN );
24079     } CALL_CATCH_EXCEPTION(0);
24080   }
24081   return result;
24082 }
24083
24084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetTouchFocusable(void * jarg1, bool jarg2) {
24085   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24086   bool arg2 ;
24087
24088   if (!jarg1) {
24089     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24090     return ;
24091   }
24092
24093   arg1 = (Dali::Actor *)jarg1;
24094   arg2 = jarg2 ? true : false;
24095   {
24096     try {
24097       (arg1)->SetProperty( DevelActor::Property::TOUCH_FOCUSABLE, arg2 );
24098     } CALL_CATCH_EXCEPTION();
24099   }
24100
24101 }
24102
24103
24104 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsTouchFocusable(void * jarg1) {
24105   bool jresult ;
24106   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24107   bool result;
24108
24109   if (!jarg1) {
24110     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24111     return 0;
24112   }
24113
24114   arg1 = (Dali::Actor *)jarg1;
24115   {
24116     try {
24117       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( DevelActor::Property::TOUCH_FOCUSABLE );
24118     } CALL_CATCH_EXCEPTION(0);
24119   }
24120
24121   jresult = result;
24122   return jresult;
24123 }
24124
24125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
24126   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24127   Dali::ResizePolicy::Type arg2 ;
24128   Dali::Dimension::Type arg3 ;
24129
24130   if (!jarg1) {
24131     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24132     return ;
24133   }
24134
24135   arg1 = (Dali::Actor *)jarg1;
24136   arg2 = (Dali::ResizePolicy::Type)jarg2;
24137   arg3 = (Dali::Dimension::Type)jarg3;
24138   {
24139     try {
24140       (arg1)->SetResizePolicy(arg2,arg3);
24141     } CALL_CATCH_EXCEPTION();
24142   }
24143
24144 }
24145
24146
24147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
24148   int jresult ;
24149   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24150   Dali::Dimension::Type arg2 ;
24151   Dali::ResizePolicy::Type result;
24152
24153   if (!jarg1) {
24154     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24155     return 0;
24156   }
24157
24158   arg1 = (Dali::Actor *)jarg1;
24159   arg2 = (Dali::Dimension::Type)jarg2;
24160   {
24161     try {
24162       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
24163     } CALL_CATCH_EXCEPTION(0);
24164   }
24165
24166   jresult = (int)result;
24167   return jresult;
24168 }
24169
24170
24171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
24172   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24173   Dali::SizeScalePolicy::Type arg2 ;
24174
24175   if (!jarg1) {
24176     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24177     return ;
24178   }
24179
24180   arg1 = (Dali::Actor *)jarg1;
24181   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
24182   {
24183     try {
24184       (arg1)->SetProperty( Actor::Property::SIZE_SCALE_POLICY,arg2);
24185     } CALL_CATCH_EXCEPTION();
24186   }
24187
24188 }
24189
24190
24191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
24192   int jresult ;
24193   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24194   Dali::SizeScalePolicy::Type result;
24195
24196   if (!jarg1) {
24197     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24198     return 0;
24199   }
24200
24201   arg1 = (Dali::Actor *)jarg1;
24202   {
24203     try {
24204       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY );
24205     } CALL_CATCH_EXCEPTION(0);
24206   }
24207
24208   jresult = (int)result;
24209   return jresult;
24210 }
24211
24212
24213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
24214   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24215   Dali::Vector3 *arg2 = 0 ;
24216
24217   if (!jarg1) {
24218     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24219     return ;
24220   }
24221
24222   arg1 = (Dali::Actor *)jarg1;
24223   arg2 = (Dali::Vector3 *)jarg2;
24224   if (!arg2) {
24225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
24226     return ;
24227   }
24228   {
24229     try {
24230       (arg1)->SetProperty( Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const &)*arg2);
24231     } CALL_CATCH_EXCEPTION();
24232   }
24233
24234 }
24235
24236
24237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
24238   void * jresult ;
24239   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24240   Dali::Vector3 result;
24241
24242   if (!jarg1) {
24243     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24244     return 0;
24245   }
24246
24247   arg1 = (Dali::Actor *)jarg1;
24248   {
24249     try {
24250       result = ((Dali::Actor const *)arg1)->GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR );
24251     } CALL_CATCH_EXCEPTION(0);
24252   }
24253
24254   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
24255   return jresult;
24256 }
24257
24258
24259 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
24260   float jresult ;
24261   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24262   float arg2 ;
24263   float result;
24264
24265   if (!jarg1) {
24266     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24267     return 0;
24268   }
24269
24270   arg1 = (Dali::Actor *)jarg1;
24271   arg2 = (float)jarg2;
24272   {
24273     try {
24274       result = (float)(arg1)->GetHeightForWidth(arg2);
24275     } CALL_CATCH_EXCEPTION(0);
24276   }
24277
24278   jresult = result;
24279   return jresult;
24280 }
24281
24282
24283 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
24284   float jresult ;
24285   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24286   float arg2 ;
24287   float result;
24288
24289   if (!jarg1) {
24290     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24291     return 0;
24292   }
24293
24294   arg1 = (Dali::Actor *)jarg1;
24295   arg2 = (float)jarg2;
24296   {
24297     try {
24298       result = (float)(arg1)->GetWidthForHeight(arg2);
24299     } CALL_CATCH_EXCEPTION(0);
24300   }
24301
24302   jresult = result;
24303   return jresult;
24304 }
24305
24306
24307 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
24308   float jresult ;
24309   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24310   Dali::Dimension::Type arg2 ;
24311   float result;
24312
24313   if (!jarg1) {
24314     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24315     return 0;
24316   }
24317
24318   arg1 = (Dali::Actor *)jarg1;
24319   arg2 = (Dali::Dimension::Type)jarg2;
24320   {
24321     try {
24322       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
24323     } CALL_CATCH_EXCEPTION(0);
24324   }
24325
24326   jresult = result;
24327   return jresult;
24328 }
24329
24330
24331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
24332   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24333   Dali::Padding *arg2 = 0 ;
24334
24335   if (!jarg1) {
24336     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24337     return ;
24338   }
24339
24340   arg1 = (Dali::Actor *)jarg1;
24341   arg2 = (Dali::Padding *)jarg2;
24342   if (!arg2) {
24343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
24344     return ;
24345   }
24346   {
24347     try {
24348       (arg1)->SetProperty( Actor::Property::PADDING, (Dali::Padding const &)*arg2);
24349     } CALL_CATCH_EXCEPTION();
24350   }
24351
24352 }
24353
24354
24355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
24356   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24357   Dali::Padding *arg2 = 0 ;
24358
24359   if (!jarg1) {
24360     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24361     return ;
24362   }
24363
24364   arg1 = (Dali::Actor *)jarg1;
24365   arg2 = (Dali::Padding *)jarg2;
24366   if (!arg2) {
24367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
24368     return ;
24369   }
24370   {
24371     try {
24372       *arg2 = ((Dali::Actor const *)arg1)->GetProperty<Vector4>( Actor::Property::PADDING );
24373     } CALL_CATCH_EXCEPTION();
24374   }
24375
24376 }
24377
24378
24379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
24380   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24381   Dali::Vector2 *arg2 = 0 ;
24382
24383   if (!jarg1) {
24384     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24385     return ;
24386   }
24387
24388   arg1 = (Dali::Actor *)jarg1;
24389   arg2 = (Dali::Vector2 *)jarg2;
24390   if (!arg2) {
24391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
24392     return ;
24393   }
24394   {
24395     try {
24396       (arg1)->SetProperty( Actor::Property::MINIMUM_SIZE,(Dali::Vector2 const &)*arg2);
24397     } CALL_CATCH_EXCEPTION();
24398   }
24399
24400 }
24401
24402
24403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
24404   void * jresult ;
24405   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24406   Dali::Vector2 result;
24407
24408   if (!jarg1) {
24409     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24410     return 0;
24411   }
24412
24413   arg1 = (Dali::Actor *)jarg1;
24414   {
24415     try {
24416       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
24417     } CALL_CATCH_EXCEPTION(0);
24418   }
24419
24420   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
24421   return jresult;
24422 }
24423
24424
24425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
24426   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24427   Dali::Vector2 *arg2 = 0 ;
24428
24429   if (!jarg1) {
24430     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24431     return ;
24432   }
24433
24434   arg1 = (Dali::Actor *)jarg1;
24435   arg2 = (Dali::Vector2 *)jarg2;
24436   if (!arg2) {
24437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
24438     return ;
24439   }
24440   {
24441     try {
24442       (arg1)->SetProperty( Actor::Property::MAXIMUM_SIZE,(Dali::Vector2 const &)*arg2);
24443     } CALL_CATCH_EXCEPTION();
24444   }
24445
24446 }
24447
24448
24449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
24450   void * jresult ;
24451   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24452   Dali::Vector2 result;
24453
24454   if (!jarg1) {
24455     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24456     return 0;
24457   }
24458
24459   arg1 = (Dali::Actor *)jarg1;
24460   {
24461     try {
24462       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
24463     } CALL_CATCH_EXCEPTION(0);
24464   }
24465
24466   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
24467   return jresult;
24468 }
24469
24470
24471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
24472   int jresult ;
24473   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24474   int result;
24475
24476   if (!jarg1) {
24477     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24478     return 0;
24479   }
24480
24481   arg1 = (Dali::Actor *)jarg1;
24482   {
24483     try {
24484       result = (int)(arg1)->GetProperty< int >( Actor::Property::HIERARCHY_DEPTH );
24485       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
24486     } CALL_CATCH_EXCEPTION(0);
24487   }
24488
24489   jresult = result;
24490   return jresult;
24491 }
24492
24493
24494 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
24495   unsigned int jresult ;
24496   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24497   Dali::Renderer *arg2 = 0 ;
24498   unsigned int result;
24499
24500   if (!jarg1) {
24501     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24502     return 0;
24503   }
24504
24505   arg1 = (Dali::Actor *)jarg1;
24506   arg2 = (Dali::Renderer *)jarg2;
24507   if (!arg2) {
24508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
24509     return 0;
24510   }
24511   {
24512     try {
24513       result = (unsigned int)(arg1)->AddRenderer(*arg2);
24514     } CALL_CATCH_EXCEPTION(0);
24515   }
24516
24517   jresult = result;
24518   return jresult;
24519 }
24520
24521
24522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
24523   unsigned int jresult ;
24524   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24525   unsigned int result;
24526
24527   if (!jarg1) {
24528     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24529     return 0;
24530   }
24531
24532   arg1 = (Dali::Actor *)jarg1;
24533   {
24534     try {
24535       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
24536     } CALL_CATCH_EXCEPTION(0);
24537   }
24538
24539   jresult = result;
24540   return jresult;
24541 }
24542
24543
24544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
24545   void * jresult ;
24546   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24547   unsigned int arg2 ;
24548   Dali::Renderer result;
24549
24550   if (!jarg1) {
24551     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24552     return 0;
24553   }
24554
24555   arg1 = (Dali::Actor *)jarg1;
24556   arg2 = (unsigned int)jarg2;
24557   {
24558     try {
24559       result = (arg1)->GetRendererAt(arg2);
24560     } CALL_CATCH_EXCEPTION(0);
24561   }
24562
24563   jresult = new Dali::Renderer((const Dali::Renderer &)result);
24564   return jresult;
24565 }
24566
24567
24568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
24569   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24570   Dali::Renderer *arg2 = 0 ;
24571
24572   if (!jarg1) {
24573     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24574     return ;
24575   }
24576
24577   arg1 = (Dali::Actor *)jarg1;
24578   arg2 = (Dali::Renderer *)jarg2;
24579   if (!arg2) {
24580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
24581     return ;
24582   }
24583   {
24584     try {
24585       (arg1)->RemoveRenderer(*arg2);
24586     } CALL_CATCH_EXCEPTION();
24587   }
24588
24589 }
24590
24591
24592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
24593   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24594   unsigned int arg2 ;
24595
24596   if (!jarg1) {
24597     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24598     return ;
24599   }
24600
24601   arg1 = (Dali::Actor *)jarg1;
24602   arg2 = (unsigned int)jarg2;
24603   {
24604     try {
24605       (arg1)->RemoveRenderer(arg2);
24606     } CALL_CATCH_EXCEPTION();
24607   }
24608
24609 }
24610
24611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HitTestResultSignal(void * jarg1) {
24612   void * jresult ;
24613   Dali::Actor arg1 ;
24614   Dali::Actor *argp1 = (Dali::Actor *) 0 ;
24615   Dali::Actor::TouchEventSignalType *result = 0 ;
24616
24617
24618   argp1 = (Dali::Actor *)jarg1;
24619   if (!argp1) {
24620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24621     return 0;
24622   }
24623   arg1 = *argp1;
24624   {
24625     try {
24626       result = (Dali::Actor::TouchEventSignalType *) &Dali::DevelActor::HitTestResultSignal(arg1);
24627     } CALL_CATCH_EXCEPTION(0);
24628   }
24629
24630   jresult = (void *)result;
24631   return jresult;
24632 }
24633
24634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_InterceptTouchSignal(void * jarg1) {
24635   void * jresult ;
24636   Dali::Actor arg1 ;
24637   Dali::Actor *argp1 = (Dali::Actor *) 0 ;
24638   Dali::Actor::TouchEventSignalType *result = 0 ;
24639
24640
24641   argp1 = (Dali::Actor *)jarg1;
24642   if (!argp1) {
24643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24644     return 0;
24645   }
24646   arg1 = *argp1;
24647   {
24648     try {
24649       result = (Dali::Actor::TouchEventSignalType *) &Dali::DevelActor::InterceptTouchedSignal(arg1);
24650     } CALL_CATCH_EXCEPTION(0);
24651   }
24652
24653   jresult = (void *)result;
24654   return jresult;
24655 }
24656
24657
24658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
24659   void * jresult ;
24660   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24661   Dali::Actor::TouchEventSignalType *result = 0 ;
24662
24663   if (!jarg1) {
24664     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24665     return 0;
24666   }
24667
24668   arg1 = (Dali::Actor *)jarg1;
24669   {
24670     try {
24671       result = (Dali::Actor::TouchEventSignalType *) &(arg1)->TouchedSignal();
24672     } CALL_CATCH_EXCEPTION(0);
24673   }
24674
24675   jresult = (void *)result;
24676   return jresult;
24677 }
24678
24679
24680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
24681   void * jresult ;
24682   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24683   Dali::Actor::HoverSignalType *result = 0 ;
24684
24685   if (!jarg1) {
24686     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24687     return 0;
24688   }
24689
24690   arg1 = (Dali::Actor *)jarg1;
24691   {
24692     try {
24693       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
24694     } CALL_CATCH_EXCEPTION(0);
24695   }
24696
24697   jresult = (void *)result;
24698   return jresult;
24699 }
24700
24701
24702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
24703   void * jresult ;
24704   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24705   Dali::Actor::WheelEventSignalType *result = 0 ;
24706
24707   if (!jarg1) {
24708     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24709     return 0;
24710   }
24711
24712   arg1 = (Dali::Actor *)jarg1;
24713   {
24714     try {
24715       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
24716     } CALL_CATCH_EXCEPTION(0);
24717   }
24718
24719   jresult = (void *)result;
24720   return jresult;
24721 }
24722
24723
24724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnSceneSignal(void * jarg1) {
24725   void * jresult ;
24726   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24727   Dali::Actor::OnSceneSignalType *result = 0 ;
24728
24729   if (!jarg1) {
24730     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24731     return 0;
24732   }
24733
24734   arg1 = (Dali::Actor *)jarg1;
24735   {
24736     try {
24737       result = (Dali::Actor::OnSceneSignalType *) &(arg1)->OnSceneSignal();
24738     } CALL_CATCH_EXCEPTION(0);
24739   }
24740
24741   jresult = (void *)result;
24742   return jresult;
24743 }
24744
24745
24746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffSceneSignal(void * jarg1) {
24747   void * jresult ;
24748   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24749   Dali::Actor::OffSceneSignalType *result = 0 ;
24750
24751   if (!jarg1) {
24752     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24753     return 0;
24754   }
24755
24756   arg1 = (Dali::Actor *)jarg1;
24757   {
24758     try {
24759       result = (Dali::Actor::OffSceneSignalType *) &(arg1)->OffSceneSignal();
24760     } CALL_CATCH_EXCEPTION(0);
24761   }
24762
24763   jresult = (void *)result;
24764   return jresult;
24765 }
24766
24767
24768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
24769   void * jresult ;
24770   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24771   Dali::Actor::OnRelayoutSignalType *result = 0 ;
24772
24773   if (!jarg1) {
24774     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24775     return 0;
24776   }
24777
24778   arg1 = (Dali::Actor *)jarg1;
24779   {
24780     try {
24781       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
24782     } CALL_CATCH_EXCEPTION(0);
24783   }
24784
24785   jresult = (void *)result;
24786   return jresult;
24787 }
24788
24789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetNeedGesturePropagation(void * jarg1, bool jarg2) {
24790   Dali::Actor arg1 ;
24791   bool arg2;
24792   Dali::Actor *argp1 = (Dali::Actor *) 0 ;
24793
24794
24795   argp1 = (Dali::Actor *)jarg1;
24796   if (!argp1) {
24797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24798     return;
24799   }
24800   arg1 = *argp1;
24801   arg2 = jarg2;
24802   {
24803     try {
24804       Dali::DevelActor::SetNeedGesturePropagation(arg1, arg2);
24805     } CALL_CATCH_EXCEPTION();
24806   }
24807   return;
24808 }
24809
24810 SWIGEXPORT void SWIGSTDCALL CSharp_DevelActor_Property_SetTouchAreaOffset(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
24811   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24812   arg1 = (Dali::Actor *)jarg1;
24813   Rect<int> arg2 = Rect(jarg2, jarg3, jarg4, jarg5);
24814   {
24815     try {
24816       (arg1)->SetProperty( Dali::DevelActor::Property::TOUCH_AREA_OFFSET, arg2 );
24817     } CALL_CATCH_EXCEPTION();
24818   }
24819 }
24820
24821 SWIGEXPORT void SWIGSTDCALL CSharp_DevelActor_Property_GetTouchAreaOffset(void * jarg1, int* jarg2, int* jarg3, int* jarg4, int* jarg5) {
24822   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24823   arg1 = (Dali::Actor *)jarg1;
24824
24825   Rect<int32_t> result;
24826   {
24827     try {
24828       result = (arg1)->GetProperty<Rect<int32_t>>( Dali::DevelActor::Property::TOUCH_AREA_OFFSET);
24829       *jarg2 = result.left;
24830       *jarg3 = result.right;
24831       *jarg4 = result.bottom;
24832       *jarg5 = result.top;
24833     } CALL_CATCH_EXCEPTION();
24834   }
24835 }
24836
24837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
24838   Dali::Actor *arg1 = 0 ;
24839
24840   arg1 = (Dali::Actor *)jarg1;
24841   if (!arg1) {
24842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
24843     return ;
24844   }
24845   {
24846     try {
24847       Dali::UnparentAndReset(*arg1);
24848     } CALL_CATCH_EXCEPTION();
24849   }
24850
24851 }
24852
24853
24854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
24855   int jresult ;
24856   int result;
24857
24858   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
24859   jresult = (int)result;
24860   return jresult;
24861 }
24862
24863
24864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
24865   int jresult ;
24866   int result;
24867
24868   result = (int)Dali::Layer::Property::CLIPPING_BOX;
24869   jresult = (int)result;
24870   return jresult;
24871 }
24872
24873
24874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
24875   int jresult ;
24876   int result;
24877
24878   result = (int)Dali::Layer::Property::BEHAVIOR;
24879   jresult = (int)result;
24880   return jresult;
24881 }
24882
24883
24884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
24885   void * jresult ;
24886   Dali::Layer::Property *result = 0 ;
24887
24888   {
24889     try {
24890       result = (Dali::Layer::Property *)new Dali::Layer::Property();
24891     } CALL_CATCH_EXCEPTION(0);
24892   }
24893
24894   jresult = (void *)result;
24895   return jresult;
24896 }
24897
24898
24899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
24900   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
24901
24902   arg1 = (Dali::Layer::Property *)jarg1;
24903   {
24904     try {
24905       delete arg1;
24906     } CALL_CATCH_EXCEPTION();
24907   }
24908
24909 }
24910
24911
24912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
24913   void * jresult ;
24914   Dali::Layer *result = 0 ;
24915
24916   {
24917     try {
24918       result = (Dali::Layer *)new Dali::Layer();
24919     } CALL_CATCH_EXCEPTION(0);
24920   }
24921
24922   jresult = (void *)result;
24923   return jresult;
24924 }
24925
24926
24927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
24928   void * jresult ;
24929   Dali::Layer result;
24930
24931   {
24932     try {
24933       result = Dali::Layer::New();
24934     } CALL_CATCH_EXCEPTION(0);
24935   }
24936
24937   jresult = new Dali::Layer((const Dali::Layer &)result);
24938   return jresult;
24939 }
24940
24941
24942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
24943   void * jresult ;
24944   Dali::BaseHandle arg1 ;
24945   Dali::BaseHandle *argp1 ;
24946   Dali::Layer result;
24947
24948   argp1 = (Dali::BaseHandle *)jarg1;
24949   if (!argp1) {
24950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24951     return 0;
24952   }
24953   arg1 = *argp1;
24954   {
24955     try {
24956       result = Dali::Layer::DownCast(arg1);
24957     } CALL_CATCH_EXCEPTION(0);
24958   }
24959
24960   jresult = new Dali::Layer((const Dali::Layer &)result);
24961   return jresult;
24962 }
24963
24964
24965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
24966   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24967
24968   arg1 = (Dali::Layer *)jarg1;
24969   {
24970     try {
24971       delete arg1;
24972     } CALL_CATCH_EXCEPTION();
24973   }
24974
24975 }
24976
24977
24978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
24979   void * jresult ;
24980   Dali::Layer *arg1 = 0 ;
24981   Dali::Layer *result = 0 ;
24982
24983   arg1 = (Dali::Layer *)jarg1;
24984   if (!arg1) {
24985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
24986     return 0;
24987   }
24988   {
24989     try {
24990       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
24991     } CALL_CATCH_EXCEPTION(0);
24992   }
24993
24994   jresult = (void *)result;
24995   return jresult;
24996 }
24997
24998
24999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
25000   void * jresult ;
25001   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25002   Dali::Layer *arg2 = 0 ;
25003   Dali::Layer *result = 0 ;
25004
25005   arg1 = (Dali::Layer *)jarg1;
25006   arg2 = (Dali::Layer *)jarg2;
25007   if (!arg2) {
25008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
25009     return 0;
25010   }
25011   {
25012     try {
25013       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
25014     } CALL_CATCH_EXCEPTION(0);
25015   }
25016
25017   jresult = (void *)result;
25018   return jresult;
25019 }
25020
25021
25022 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
25023   unsigned int jresult ;
25024   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25025   unsigned int result;
25026
25027   arg1 = (Dali::Layer *)jarg1;
25028   {
25029     try {
25030       result = (unsigned int)((Dali::Layer const *)arg1)->GetProperty< int >( Layer::Property::DEPTH );
25031     } CALL_CATCH_EXCEPTION(0);
25032   }
25033
25034   jresult = result;
25035   return jresult;
25036 }
25037
25038
25039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
25040   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25041
25042   arg1 = (Dali::Layer *)jarg1;
25043   {
25044     try {
25045       (arg1)->Raise();
25046     } CALL_CATCH_EXCEPTION();
25047   }
25048
25049 }
25050
25051
25052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
25053   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25054
25055   arg1 = (Dali::Layer *)jarg1;
25056   {
25057     try {
25058       (arg1)->Lower();
25059     } CALL_CATCH_EXCEPTION();
25060   }
25061
25062 }
25063
25064
25065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
25066   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25067   Dali::Layer arg2 ;
25068   Dali::Layer *argp2 ;
25069
25070   arg1 = (Dali::Layer *)jarg1;
25071   argp2 = (Dali::Layer *)jarg2;
25072   if (!argp2) {
25073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
25074     return ;
25075   }
25076   arg2 = *argp2;
25077   {
25078     try {
25079       (arg1)->RaiseAbove(arg2);
25080     } CALL_CATCH_EXCEPTION();
25081   }
25082
25083 }
25084
25085
25086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
25087   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25088   Dali::Layer arg2 ;
25089   Dali::Layer *argp2 ;
25090
25091   arg1 = (Dali::Layer *)jarg1;
25092   argp2 = (Dali::Layer *)jarg2;
25093   if (!argp2) {
25094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
25095     return ;
25096   }
25097   arg2 = *argp2;
25098   {
25099     try {
25100       (arg1)->LowerBelow(arg2);
25101     } CALL_CATCH_EXCEPTION();
25102   }
25103
25104 }
25105
25106
25107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
25108   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25109
25110   arg1 = (Dali::Layer *)jarg1;
25111   {
25112     try {
25113       (arg1)->RaiseToTop();
25114     } CALL_CATCH_EXCEPTION();
25115   }
25116
25117 }
25118
25119
25120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
25121   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25122
25123   arg1 = (Dali::Layer *)jarg1;
25124   {
25125     try {
25126       (arg1)->LowerToBottom();
25127     } CALL_CATCH_EXCEPTION();
25128   }
25129
25130 }
25131
25132
25133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
25134   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25135   Dali::Layer arg2 ;
25136   Dali::Layer *argp2 ;
25137
25138   arg1 = (Dali::Layer *)jarg1;
25139   argp2 = (Dali::Layer *)jarg2;
25140   if (!argp2) {
25141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
25142     return ;
25143   }
25144   arg2 = *argp2;
25145   {
25146     try {
25147       (arg1)->MoveAbove(arg2);
25148     } CALL_CATCH_EXCEPTION();
25149   }
25150
25151 }
25152
25153
25154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
25155   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25156   Dali::Layer arg2 ;
25157   Dali::Layer *argp2 ;
25158
25159   arg1 = (Dali::Layer *)jarg1;
25160   argp2 = (Dali::Layer *)jarg2;
25161   if (!argp2) {
25162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
25163     return ;
25164   }
25165   arg2 = *argp2;
25166   {
25167     try {
25168       (arg1)->MoveBelow(arg2);
25169     } CALL_CATCH_EXCEPTION();
25170   }
25171
25172 }
25173
25174
25175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
25176   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25177   Dali::Layer::Behavior arg2 ;
25178
25179   arg1 = (Dali::Layer *)jarg1;
25180   arg2 = (Dali::Layer::Behavior)jarg2;
25181   {
25182     try {
25183       (arg1)->SetProperty( Layer::Property::BEHAVIOR, arg2 );
25184     } CALL_CATCH_EXCEPTION();
25185   }
25186
25187 }
25188
25189
25190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
25191   int jresult ;
25192   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25193   Dali::Layer::Behavior result;
25194
25195   arg1 = (Dali::Layer *)jarg1;
25196   {
25197     try {
25198       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetProperty<Dali::Layer::Behavior>( Dali::Layer::Property::BEHAVIOR );
25199     } CALL_CATCH_EXCEPTION(0);
25200   }
25201
25202   jresult = (int)result;
25203   return jresult;
25204 }
25205
25206
25207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, bool jarg2) {
25208   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25209   bool arg2 ;
25210
25211   arg1 = (Dali::Layer *)jarg1;
25212   arg2 = jarg2 ? true : false;
25213   {
25214     try {
25215       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_ENABLE, arg2 );
25216     } CALL_CATCH_EXCEPTION();
25217   }
25218
25219 }
25220
25221
25222 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
25223   bool jresult ;
25224   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25225   bool result;
25226
25227   arg1 = (Dali::Layer *)jarg1;
25228   {
25229     try {
25230       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Dali::Layer::Property::CLIPPING_ENABLE );
25231     } CALL_CATCH_EXCEPTION(0);
25232   }
25233
25234   jresult = result;
25235   return jresult;
25236 }
25237
25238
25239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
25240   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25241   int arg2 ;
25242   int arg3 ;
25243   int arg4 ;
25244   int arg5 ;
25245
25246   arg1 = (Dali::Layer *)jarg1;
25247   arg2 = (int)jarg2;
25248   arg3 = (int)jarg3;
25249   arg4 = (int)jarg4;
25250   arg5 = (int)jarg5;
25251   {
25252     try {
25253       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, Rect<int32_t>( arg2,arg3,arg4,arg5 ) );
25254     } CALL_CATCH_EXCEPTION();
25255   }
25256
25257 }
25258
25259
25260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
25261   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25262   Dali::ClippingBox arg2 ;
25263   Dali::ClippingBox *argp2 ;
25264
25265   arg1 = (Dali::Layer *)jarg1;
25266   argp2 = (Dali::ClippingBox *)jarg2;
25267   if (!argp2) {
25268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
25269     return ;
25270   }
25271   arg2 = *argp2;
25272   {
25273     try {
25274       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, arg2 );
25275     } CALL_CATCH_EXCEPTION();
25276   }
25277
25278 }
25279
25280
25281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
25282   void * jresult ;
25283   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25284   Dali::ClippingBox result;
25285
25286   arg1 = (Dali::Layer *)jarg1;
25287   {
25288     try {
25289       result = ((Dali::Layer const *)arg1)->GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX );
25290     } CALL_CATCH_EXCEPTION(0);
25291   }
25292
25293   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
25294   return jresult;
25295 }
25296
25297
25298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, bool jarg2) {
25299   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25300   bool arg2 ;
25301
25302   arg1 = (Dali::Layer *)jarg1;
25303   arg2 = jarg2 ? true : false;
25304   {
25305     try {
25306       (arg1)->SetProperty( Layer::Property::DEPTH_TEST, !arg2 );
25307     } CALL_CATCH_EXCEPTION();
25308   }
25309
25310 }
25311
25312
25313 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
25314   bool jresult ;
25315   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25316   bool result;
25317
25318   arg1 = (Dali::Layer *)jarg1;
25319   {
25320     try {
25321       result = !(bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::DEPTH_TEST );
25322     } CALL_CATCH_EXCEPTION(0);
25323   }
25324
25325   jresult = result;
25326   return jresult;
25327 }
25328
25329
25330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
25331   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25332   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
25333
25334   arg1 = (Dali::Layer *)jarg1;
25335   arg2 = (Dali::Layer::SortFunctionType)jarg2;
25336   {
25337     try {
25338       (arg1)->SetSortFunction(arg2);
25339     } CALL_CATCH_EXCEPTION();
25340   }
25341
25342 }
25343
25344
25345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, bool jarg2) {
25346   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25347   bool arg2 ;
25348
25349   arg1 = (Dali::Layer *)jarg1;
25350   arg2 = jarg2 ? true : false;
25351   {
25352     try {
25353       (arg1)->SetProperty( Layer::Property::CONSUMES_TOUCH, arg2 );
25354     } CALL_CATCH_EXCEPTION();
25355   }
25356
25357 }
25358
25359
25360 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
25361   bool jresult ;
25362   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25363   bool result;
25364
25365   arg1 = (Dali::Layer *)jarg1;
25366   {
25367     try {
25368       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_TOUCH );
25369     } CALL_CATCH_EXCEPTION(0);
25370   }
25371
25372   jresult = result;
25373   return jresult;
25374 }
25375
25376
25377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, bool jarg2) {
25378   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25379   bool arg2 ;
25380
25381   arg1 = (Dali::Layer *)jarg1;
25382   arg2 = jarg2 ? true : false;
25383   {
25384     try {
25385       (arg1)->SetProperty( Layer::Property::CONSUMES_HOVER, arg2 );
25386     } CALL_CATCH_EXCEPTION();
25387   }
25388
25389 }
25390
25391
25392 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
25393   bool jresult ;
25394   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25395   bool result;
25396
25397   arg1 = (Dali::Layer *)jarg1;
25398   {
25399     try {
25400       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_HOVER );
25401     } CALL_CATCH_EXCEPTION(0);
25402   }
25403
25404   jresult = result;
25405   return jresult;
25406 }
25407
25408
25409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
25410   void * jresult ;
25411   Dali::Stage result;
25412
25413   {
25414     try {
25415       result = Dali::Stage::GetCurrent();
25416     } CALL_CATCH_EXCEPTION(0);
25417   }
25418
25419   jresult = new Dali::Stage((const Dali::Stage &)result);
25420   return jresult;
25421 }
25422
25423
25424 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
25425   bool jresult ;
25426   bool result;
25427
25428   {
25429     try {
25430       result = (bool)Dali::Stage::IsInstalled();
25431     } CALL_CATCH_EXCEPTION(0);
25432   }
25433
25434   jresult = result;
25435   return jresult;
25436 }
25437
25438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
25439   void * jresult ;
25440   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
25441   Dali::RenderTaskList result;
25442
25443   arg1 = (Dali::Stage *)jarg1;
25444   {
25445     try {
25446       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
25447     } CALL_CATCH_EXCEPTION(0);
25448   }
25449
25450   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
25451   return jresult;
25452 }
25453
25454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
25455   void * jresult ;
25456   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
25457   Dali::Vector2 result;
25458
25459   arg1 = (Dali::Stage *)jarg1;
25460   {
25461     try {
25462       result = ((Dali::Stage const *)arg1)->GetDpi();
25463     } CALL_CATCH_EXCEPTION(0);
25464   }
25465
25466   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25467   return jresult;
25468 }
25469
25470
25471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
25472   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
25473   float arg2 ;
25474
25475   arg1 = (Dali::Stage *)jarg1;
25476   arg2 = (float)jarg2;
25477   {
25478     try {
25479       (arg1)->KeepRendering(arg2);
25480     } CALL_CATCH_EXCEPTION();
25481   }
25482
25483 }
25484
25485
25486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
25487   void * jresult ;
25488   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
25489   Dali::Stage::KeyEventSignalType *result = 0 ;
25490
25491   arg1 = (Dali::Stage *)jarg1;
25492   {
25493     try {
25494       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
25495     } CALL_CATCH_EXCEPTION(0);
25496   }
25497
25498   jresult = (void *)result;
25499   return jresult;
25500 }
25501
25502
25503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
25504   void * jresult ;
25505   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
25506   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
25507
25508   arg1 = (Dali::Stage *)jarg1;
25509   {
25510     try {
25511       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
25512     } CALL_CATCH_EXCEPTION(0);
25513   }
25514
25515   jresult = (void *)result;
25516   return jresult;
25517 }
25518
25519
25520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
25521   void * jresult ;
25522   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
25523   Dali::Stage::TouchEventSignalType *result = 0 ;
25524
25525   arg1 = (Dali::Stage *)jarg1;
25526   {
25527     try {
25528       result = (Dali::Stage::TouchEventSignalType *) &(arg1)->TouchedSignal();
25529     } CALL_CATCH_EXCEPTION(0);
25530   }
25531
25532   jresult = (void *)result;
25533   return jresult;
25534 }
25535
25536
25537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
25538   void * jresult ;
25539   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
25540   Dali::Stage::WheelEventSignalType *result = 0 ;
25541
25542   arg1 = (Dali::Stage *)jarg1;
25543   {
25544     try {
25545       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
25546     } CALL_CATCH_EXCEPTION(0);
25547   }
25548
25549   jresult = (void *)result;
25550   return jresult;
25551 }
25552
25553
25554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
25555   void * jresult ;
25556   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
25557   Dali::Stage::ContextStatusSignal *result = 0 ;
25558
25559   arg1 = (Dali::Stage *)jarg1;
25560   {
25561     try {
25562       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
25563     } CALL_CATCH_EXCEPTION(0);
25564   }
25565
25566   jresult = (void *)result;
25567   return jresult;
25568 }
25569
25570
25571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
25572   void * jresult ;
25573   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
25574   Dali::Stage::ContextStatusSignal *result = 0 ;
25575
25576   arg1 = (Dali::Stage *)jarg1;
25577   {
25578     try {
25579       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
25580     } CALL_CATCH_EXCEPTION(0);
25581   }
25582
25583   jresult = (void *)result;
25584   return jresult;
25585 }
25586
25587
25588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
25589   void * jresult ;
25590   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
25591   Dali::Stage::SceneCreatedSignalType *result = 0 ;
25592
25593   arg1 = (Dali::Stage *)jarg1;
25594   {
25595     try {
25596       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
25597     } CALL_CATCH_EXCEPTION(0);
25598   }
25599
25600   jresult = (void *)result;
25601   return jresult;
25602 }
25603
25604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
25605   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
25606   Dali::DevelStage::Rendering arg2 ;
25607
25608   arg1 = (Dali::Stage *)jarg1;
25609   arg2 = (Dali::DevelStage::Rendering)jarg2;
25610   {
25611     try {
25612       DevelStage::SetRenderingBehavior(*arg1,arg2);
25613     } CALL_CATCH_EXCEPTION();
25614   }
25615
25616 }
25617
25618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
25619
25620   int jresult ;
25621   int result ;
25622   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
25623
25624   arg1 = (Dali::Stage *)jarg1;
25625   {
25626     try {
25627       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
25628     } CALL_CATCH_EXCEPTION(0);
25629   }
25630
25631   jresult = result;
25632   return jresult;
25633 }
25634
25635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
25636   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
25637
25638   arg1 = (Dali::RelayoutContainer *)jarg1;
25639   {
25640     try {
25641       delete arg1;
25642     } CALL_CATCH_EXCEPTION();
25643   }
25644
25645 }
25646
25647
25648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
25649   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
25650   Dali::Actor *arg2 = 0 ;
25651   Dali::Vector2 *arg3 = 0 ;
25652
25653   arg1 = (Dali::RelayoutContainer *)jarg1;
25654   arg2 = (Dali::Actor *)jarg2;
25655   if (!arg2) {
25656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
25657     return ;
25658   }
25659   arg3 = (Dali::Vector2 *)jarg3;
25660   if (!arg3) {
25661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
25662     return ;
25663   }
25664   {
25665     try {
25666       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
25667     } CALL_CATCH_EXCEPTION();
25668   }
25669
25670 }
25671
25672
25673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
25674   void * jresult ;
25675   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25676   Dali::CustomActor result;
25677
25678   arg1 = (Dali::CustomActorImpl *)jarg1;
25679   {
25680     try {
25681       result = ((Dali::CustomActorImpl const *)arg1)->Self();
25682     } CALL_CATCH_EXCEPTION(0);
25683   }
25684
25685   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
25686   return jresult;
25687 }
25688
25689
25690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneConnection(void * jarg1, int jarg2) {
25691   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25692   int arg2 ;
25693
25694   arg1 = (Dali::CustomActorImpl *)jarg1;
25695   arg2 = (int)jarg2;
25696   {
25697     try {
25698       (arg1)->OnSceneConnection(arg2);
25699     } CALL_CATCH_EXCEPTION();
25700   }
25701
25702 }
25703
25704
25705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneDisconnection(void * jarg1) {
25706   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25707
25708   arg1 = (Dali::CustomActorImpl *)jarg1;
25709   {
25710     try {
25711       (arg1)->OnSceneDisconnection();
25712     } CALL_CATCH_EXCEPTION();
25713   }
25714
25715 }
25716
25717
25718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
25719   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25720   Dali::Actor *arg2 = 0 ;
25721
25722   arg1 = (Dali::CustomActorImpl *)jarg1;
25723   arg2 = (Dali::Actor *)jarg2;
25724   if (!arg2) {
25725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
25726     return ;
25727   }
25728   {
25729     try {
25730       (arg1)->OnChildAdd(*arg2);
25731     } CALL_CATCH_EXCEPTION();
25732   }
25733
25734 }
25735
25736
25737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
25738   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25739   Dali::Actor *arg2 = 0 ;
25740
25741   arg1 = (Dali::CustomActorImpl *)jarg1;
25742   arg2 = (Dali::Actor *)jarg2;
25743   if (!arg2) {
25744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
25745     return ;
25746   }
25747   {
25748     try {
25749       (arg1)->OnChildRemove(*arg2);
25750     } CALL_CATCH_EXCEPTION();
25751   }
25752
25753 }
25754
25755
25756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
25757   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25758   Dali::Property::Index arg2 ;
25759   Dali::Property::Value arg3 ;
25760   Dali::Property::Value *argp3 ;
25761
25762   arg1 = (Dali::CustomActorImpl *)jarg1;
25763   arg2 = (Dali::Property::Index)jarg2;
25764   argp3 = (Dali::Property::Value *)jarg3;
25765   if (!argp3) {
25766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
25767     return ;
25768   }
25769   arg3 = *argp3;
25770   {
25771     try {
25772       (arg1)->OnPropertySet(arg2,arg3);
25773     } CALL_CATCH_EXCEPTION();
25774   }
25775
25776 }
25777
25778
25779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
25780   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25781   Dali::Vector3 *arg2 = 0 ;
25782
25783   arg1 = (Dali::CustomActorImpl *)jarg1;
25784   arg2 = (Dali::Vector3 *)jarg2;
25785   if (!arg2) {
25786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25787     return ;
25788   }
25789   {
25790     try {
25791       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
25792     } CALL_CATCH_EXCEPTION();
25793   }
25794
25795 }
25796
25797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
25798   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25799   Dali::Animation *arg2 = 0 ;
25800   Dali::Vector3 *arg3 = 0 ;
25801
25802   arg1 = (Dali::CustomActorImpl *)jarg1;
25803   arg2 = (Dali::Animation *)jarg2;
25804   if (!arg2) {
25805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
25806     return ;
25807   }
25808   arg3 = (Dali::Vector3 *)jarg3;
25809   if (!arg3) {
25810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25811     return ;
25812   }
25813   {
25814     try {
25815       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
25816     } CALL_CATCH_EXCEPTION();
25817   }
25818 }
25819
25820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
25821   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25822   Dali::Vector2 *arg2 = 0 ;
25823   Dali::RelayoutContainer *arg3 = 0 ;
25824
25825   arg1 = (Dali::CustomActorImpl *)jarg1;
25826   arg2 = (Dali::Vector2 *)jarg2;
25827   if (!arg2) {
25828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
25829     return ;
25830   }
25831   arg3 = (Dali::RelayoutContainer *)jarg3;
25832   if (!arg3) {
25833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
25834     return ;
25835   }
25836   {
25837     try {
25838       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
25839     } CALL_CATCH_EXCEPTION();
25840   }
25841
25842 }
25843
25844
25845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
25846   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25847   Dali::ResizePolicy::Type arg2 ;
25848   Dali::Dimension::Type arg3 ;
25849
25850   arg1 = (Dali::CustomActorImpl *)jarg1;
25851   arg2 = (Dali::ResizePolicy::Type)jarg2;
25852   arg3 = (Dali::Dimension::Type)jarg3;
25853   {
25854     try {
25855       (arg1)->OnSetResizePolicy(arg2,arg3);
25856     } CALL_CATCH_EXCEPTION();
25857   }
25858
25859 }
25860
25861
25862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
25863   void * jresult ;
25864   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25865   Dali::Vector3 result;
25866
25867   arg1 = (Dali::CustomActorImpl *)jarg1;
25868   {
25869     try {
25870       result = (arg1)->GetNaturalSize();
25871     } CALL_CATCH_EXCEPTION(0);
25872   }
25873
25874   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
25875   return jresult;
25876 }
25877
25878
25879 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
25880   float jresult ;
25881   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25882   Dali::Actor *arg2 = 0 ;
25883   Dali::Dimension::Type arg3 ;
25884   float result;
25885
25886   arg1 = (Dali::CustomActorImpl *)jarg1;
25887   arg2 = (Dali::Actor *)jarg2;
25888   if (!arg2) {
25889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
25890     return 0;
25891   }
25892   arg3 = (Dali::Dimension::Type)jarg3;
25893   {
25894     try {
25895       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
25896     } CALL_CATCH_EXCEPTION(0);
25897   }
25898
25899   jresult = result;
25900   return jresult;
25901 }
25902
25903
25904 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
25905   float jresult ;
25906   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25907   float arg2 ;
25908   float result;
25909
25910   arg1 = (Dali::CustomActorImpl *)jarg1;
25911   arg2 = (float)jarg2;
25912   {
25913     try {
25914       result = (float)(arg1)->GetHeightForWidth(arg2);
25915     } CALL_CATCH_EXCEPTION(0);
25916   }
25917
25918   jresult = result;
25919   return jresult;
25920 }
25921
25922
25923 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
25924   float jresult ;
25925   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25926   float arg2 ;
25927   float result;
25928
25929   arg1 = (Dali::CustomActorImpl *)jarg1;
25930   arg2 = (float)jarg2;
25931   {
25932     try {
25933       result = (float)(arg1)->GetWidthForHeight(arg2);
25934     } CALL_CATCH_EXCEPTION(0);
25935   }
25936
25937   jresult = result;
25938   return jresult;
25939 }
25940
25941
25942 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
25943   bool jresult ;
25944   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25945   Dali::Dimension::Type arg2 ;
25946   bool result;
25947
25948   arg1 = (Dali::CustomActorImpl *)jarg1;
25949   arg2 = (Dali::Dimension::Type)jarg2;
25950   {
25951     try {
25952       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
25953     } CALL_CATCH_EXCEPTION(0);
25954   }
25955
25956   jresult = result;
25957   return jresult;
25958 }
25959
25960
25961 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
25962   bool jresult ;
25963   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25964   bool result;
25965
25966   arg1 = (Dali::CustomActorImpl *)jarg1;
25967   {
25968     try {
25969       result = (bool)(arg1)->RelayoutDependentOnChildren();
25970     } CALL_CATCH_EXCEPTION(0);
25971   }
25972
25973   jresult = result;
25974   return jresult;
25975 }
25976
25977
25978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
25979   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25980   Dali::Dimension::Type arg2 ;
25981
25982   arg1 = (Dali::CustomActorImpl *)jarg1;
25983   arg2 = (Dali::Dimension::Type)jarg2;
25984   {
25985     try {
25986       (arg1)->OnCalculateRelayoutSize(arg2);
25987     } CALL_CATCH_EXCEPTION();
25988   }
25989
25990 }
25991
25992
25993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
25994   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25995   float arg2 ;
25996   Dali::Dimension::Type arg3 ;
25997
25998   arg1 = (Dali::CustomActorImpl *)jarg1;
25999   arg2 = (float)jarg2;
26000   arg3 = (Dali::Dimension::Type)jarg3;
26001   {
26002     try {
26003       (arg1)->OnLayoutNegotiated(arg2,arg3);
26004     } CALL_CATCH_EXCEPTION();
26005   }
26006
26007 }
26008
26009 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
26010   bool jresult ;
26011   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26012   bool result;
26013
26014   arg1 = (Dali::CustomActorImpl *)jarg1;
26015   {
26016     try {
26017       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
26018     } CALL_CATCH_EXCEPTION(0);
26019   }
26020
26021   jresult = result;
26022   return jresult;
26023 }
26024
26025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
26026   void * jresult ;
26027   Dali::CustomActor *result = 0 ;
26028
26029   {
26030     try {
26031       result = (Dali::CustomActor *)new Dali::CustomActor();
26032     } CALL_CATCH_EXCEPTION(0);
26033   }
26034
26035   jresult = (void *)result;
26036   return jresult;
26037 }
26038
26039
26040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
26041   void * jresult ;
26042   Dali::BaseHandle arg1 ;
26043   Dali::BaseHandle *argp1 ;
26044   Dali::CustomActor result;
26045
26046   argp1 = (Dali::BaseHandle *)jarg1;
26047   if (!argp1) {
26048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26049     return 0;
26050   }
26051   arg1 = *argp1;
26052   {
26053     try {
26054       result = Dali::CustomActor::DownCast(arg1);
26055     } CALL_CATCH_EXCEPTION(0);
26056   }
26057
26058   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
26059   return jresult;
26060 }
26061
26062
26063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
26064   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
26065
26066   arg1 = (Dali::CustomActor *)jarg1;
26067   {
26068     try {
26069       delete arg1;
26070     } CALL_CATCH_EXCEPTION();
26071   }
26072
26073 }
26074
26075
26076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
26077   void * jresult ;
26078   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
26079   Dali::CustomActorImpl *result = 0 ;
26080
26081   arg1 = (Dali::CustomActor *)jarg1;
26082   {
26083     try {
26084       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
26085     } CALL_CATCH_EXCEPTION(0);
26086   }
26087
26088   jresult = (void *)result;
26089   return jresult;
26090 }
26091
26092
26093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
26094   void * jresult ;
26095   Dali::CustomActorImpl *arg1 = 0 ;
26096   Dali::CustomActor *result = 0 ;
26097
26098   arg1 = (Dali::CustomActorImpl *)jarg1;
26099   if (!arg1) {
26100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
26101     return 0;
26102   }
26103   {
26104     try {
26105       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
26106     } CALL_CATCH_EXCEPTION(0);
26107   }
26108
26109   jresult = (void *)result;
26110   return jresult;
26111 }
26112
26113
26114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
26115   void * jresult ;
26116   Dali::CustomActor *arg1 = 0 ;
26117   Dali::CustomActor *result = 0 ;
26118
26119   arg1 = (Dali::CustomActor *)jarg1;
26120   if (!arg1) {
26121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
26122     return 0;
26123   }
26124   {
26125     try {
26126       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
26127     } CALL_CATCH_EXCEPTION(0);
26128   }
26129
26130   jresult = (void *)result;
26131   return jresult;
26132 }
26133
26134
26135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
26136   void * jresult ;
26137   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
26138   Dali::CustomActor *arg2 = 0 ;
26139   Dali::CustomActor *result = 0 ;
26140
26141   arg1 = (Dali::CustomActor *)jarg1;
26142   arg2 = (Dali::CustomActor *)jarg2;
26143   if (!arg2) {
26144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
26145     return 0;
26146   }
26147   {
26148     try {
26149       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
26150     } CALL_CATCH_EXCEPTION(0);
26151   }
26152
26153   jresult = (void *)result;
26154   return jresult;
26155 }
26156
26157
26158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
26159   int jresult ;
26160   int result;
26161
26162   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
26163   jresult = (int)result;
26164   return jresult;
26165 }
26166
26167
26168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
26169   int jresult ;
26170   int result;
26171
26172   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
26173   jresult = (int)result;
26174   return jresult;
26175 }
26176
26177
26178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
26179   int jresult ;
26180   int result;
26181
26182   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
26183   jresult = (int)result;
26184   return jresult;
26185 }
26186
26187
26188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
26189   int jresult ;
26190   int result;
26191
26192   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
26193   jresult = (int)result;
26194   return jresult;
26195 }
26196
26197
26198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
26199   int jresult ;
26200   int result;
26201
26202   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
26203   jresult = (int)result;
26204   return jresult;
26205 }
26206
26207
26208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
26209   int jresult ;
26210   int result;
26211
26212   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
26213   jresult = (int)result;
26214   return jresult;
26215 }
26216
26217
26218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
26219   int jresult ;
26220   int result;
26221
26222   result = (int)Dali::PanGestureDetector::Property::PANNING;
26223   jresult = (int)result;
26224   return jresult;
26225 }
26226
26227
26228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
26229   void * jresult ;
26230   Dali::PanGestureDetector::Property *result = 0 ;
26231
26232   {
26233     try {
26234       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
26235     } CALL_CATCH_EXCEPTION(0);
26236   }
26237
26238   jresult = (void *)result;
26239   return jresult;
26240 }
26241
26242
26243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
26244   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
26245
26246   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
26247   {
26248     try {
26249       delete arg1;
26250     } CALL_CATCH_EXCEPTION();
26251   }
26252
26253 }
26254
26255
26256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
26257   void * jresult ;
26258   Dali::Radian *result = 0 ;
26259
26260   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
26261   jresult = (void *)result;
26262   return jresult;
26263 }
26264
26265
26266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
26267   void * jresult ;
26268   Dali::Radian *result = 0 ;
26269
26270   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
26271   jresult = (void *)result;
26272   return jresult;
26273 }
26274
26275
26276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
26277   void * jresult ;
26278   Dali::Radian *result = 0 ;
26279
26280   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
26281   jresult = (void *)result;
26282   return jresult;
26283 }
26284
26285
26286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
26287   void * jresult ;
26288   Dali::Radian *result = 0 ;
26289
26290   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
26291   jresult = (void *)result;
26292   return jresult;
26293 }
26294
26295
26296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
26297   void * jresult ;
26298   Dali::Radian *result = 0 ;
26299
26300   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
26301   jresult = (void *)result;
26302   return jresult;
26303 }
26304
26305
26306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
26307   void * jresult ;
26308   Dali::Radian *result = 0 ;
26309
26310   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
26311   jresult = (void *)result;
26312   return jresult;
26313 }
26314
26315
26316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
26317   void * jresult ;
26318   Dali::Radian *result = 0 ;
26319
26320   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
26321   jresult = (void *)result;
26322   return jresult;
26323 }
26324
26325
26326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
26327   void * jresult ;
26328   Dali::PanGestureDetector *result = 0 ;
26329
26330   {
26331     try {
26332       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
26333     } CALL_CATCH_EXCEPTION(0);
26334   }
26335
26336   jresult = (void *)result;
26337   return jresult;
26338 }
26339
26340
26341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
26342   void * jresult ;
26343   Dali::PanGestureDetector result;
26344
26345   {
26346     try {
26347       result = Dali::PanGestureDetector::New();
26348     } CALL_CATCH_EXCEPTION(0);
26349   }
26350
26351   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
26352   return jresult;
26353 }
26354
26355
26356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
26357   void * jresult ;
26358   Dali::BaseHandle arg1 ;
26359   Dali::BaseHandle *argp1 ;
26360   Dali::PanGestureDetector result;
26361
26362   argp1 = (Dali::BaseHandle *)jarg1;
26363   if (!argp1) {
26364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26365     return 0;
26366   }
26367   arg1 = *argp1;
26368   {
26369     try {
26370       result = Dali::PanGestureDetector::DownCast(arg1);
26371     } CALL_CATCH_EXCEPTION(0);
26372   }
26373
26374   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
26375   return jresult;
26376 }
26377
26378
26379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
26380   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26381
26382   arg1 = (Dali::PanGestureDetector *)jarg1;
26383   {
26384     try {
26385       delete arg1;
26386     } CALL_CATCH_EXCEPTION();
26387   }
26388
26389 }
26390
26391
26392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
26393   void * jresult ;
26394   Dali::PanGestureDetector *arg1 = 0 ;
26395   Dali::PanGestureDetector *result = 0 ;
26396
26397   arg1 = (Dali::PanGestureDetector *)jarg1;
26398   if (!arg1) {
26399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
26400     return 0;
26401   }
26402   {
26403     try {
26404       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
26405     } CALL_CATCH_EXCEPTION(0);
26406   }
26407
26408   jresult = (void *)result;
26409   return jresult;
26410 }
26411
26412
26413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
26414   void * jresult ;
26415   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26416   Dali::PanGestureDetector *arg2 = 0 ;
26417   Dali::PanGestureDetector *result = 0 ;
26418
26419   arg1 = (Dali::PanGestureDetector *)jarg1;
26420   arg2 = (Dali::PanGestureDetector *)jarg2;
26421   if (!arg2) {
26422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
26423     return 0;
26424   }
26425   {
26426     try {
26427       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
26428     } CALL_CATCH_EXCEPTION(0);
26429   }
26430
26431   jresult = (void *)result;
26432   return jresult;
26433 }
26434
26435
26436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
26437   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26438   unsigned int arg2 ;
26439
26440   arg1 = (Dali::PanGestureDetector *)jarg1;
26441   arg2 = (unsigned int)jarg2;
26442   {
26443     try {
26444       (arg1)->SetMinimumTouchesRequired(arg2);
26445     } CALL_CATCH_EXCEPTION();
26446   }
26447
26448 }
26449
26450
26451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
26452   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26453   unsigned int arg2 ;
26454
26455   arg1 = (Dali::PanGestureDetector *)jarg1;
26456   arg2 = (unsigned int)jarg2;
26457   {
26458     try {
26459       (arg1)->SetMaximumTouchesRequired(arg2);
26460     } CALL_CATCH_EXCEPTION();
26461   }
26462
26463 }
26464
26465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumMotionEventAge(void * jarg1, unsigned int jarg2) {
26466   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26467   uint32_t arg2 ;
26468
26469   arg1 = (Dali::PanGestureDetector *)jarg1;
26470   arg2 = (uint32_t)jarg2;
26471   {
26472     try {
26473       (arg1)->SetMaximumMotionEventAge(arg2);
26474     } CALL_CATCH_EXCEPTION();
26475   }
26476
26477 }
26478
26479
26480 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
26481   unsigned int jresult ;
26482   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26483   unsigned int result;
26484
26485   arg1 = (Dali::PanGestureDetector *)jarg1;
26486   {
26487     try {
26488       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
26489     } CALL_CATCH_EXCEPTION(0);
26490   }
26491
26492   jresult = result;
26493   return jresult;
26494 }
26495
26496
26497 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
26498   unsigned int jresult ;
26499   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26500   unsigned int result;
26501
26502   arg1 = (Dali::PanGestureDetector *)jarg1;
26503   {
26504     try {
26505       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
26506     } CALL_CATCH_EXCEPTION(0);
26507   }
26508
26509   jresult = result;
26510   return jresult;
26511 }
26512
26513 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumMotionEventAge(void * jarg1) {
26514   unsigned int jresult ;
26515   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26516   uint32_t result;
26517
26518   arg1 = (Dali::PanGestureDetector *)jarg1;
26519   {
26520     try {
26521       result = (uint32_t)((Dali::PanGestureDetector const *)arg1)->GetMaximumMotionEventAge();
26522     } CALL_CATCH_EXCEPTION(0);
26523   }
26524
26525   jresult = result;
26526   return jresult;
26527 }
26528
26529
26530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
26531   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26532   Dali::Radian arg2 ;
26533   Dali::Radian arg3 ;
26534   Dali::Radian *argp2 ;
26535   Dali::Radian *argp3 ;
26536
26537   arg1 = (Dali::PanGestureDetector *)jarg1;
26538   argp2 = (Dali::Radian *)jarg2;
26539   if (!argp2) {
26540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
26541     return ;
26542   }
26543   arg2 = *argp2;
26544   argp3 = (Dali::Radian *)jarg3;
26545   if (!argp3) {
26546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
26547     return ;
26548   }
26549   arg3 = *argp3;
26550   {
26551     try {
26552       (arg1)->AddAngle(arg2,arg3);
26553     } CALL_CATCH_EXCEPTION();
26554   }
26555
26556 }
26557
26558
26559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
26560   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26561   Dali::Radian arg2 ;
26562   Dali::Radian *argp2 ;
26563
26564   arg1 = (Dali::PanGestureDetector *)jarg1;
26565   argp2 = (Dali::Radian *)jarg2;
26566   if (!argp2) {
26567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
26568     return ;
26569   }
26570   arg2 = *argp2;
26571   {
26572     try {
26573       (arg1)->AddAngle(arg2);
26574     } CALL_CATCH_EXCEPTION();
26575   }
26576
26577 }
26578
26579
26580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
26581   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26582   Dali::Radian arg2 ;
26583   Dali::Radian arg3 ;
26584   Dali::Radian *argp2 ;
26585   Dali::Radian *argp3 ;
26586
26587   arg1 = (Dali::PanGestureDetector *)jarg1;
26588   argp2 = (Dali::Radian *)jarg2;
26589   if (!argp2) {
26590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
26591     return ;
26592   }
26593   arg2 = *argp2;
26594   argp3 = (Dali::Radian *)jarg3;
26595   if (!argp3) {
26596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
26597     return ;
26598   }
26599   arg3 = *argp3;
26600   {
26601     try {
26602       (arg1)->AddDirection(arg2,arg3);
26603     } CALL_CATCH_EXCEPTION();
26604   }
26605
26606 }
26607
26608
26609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
26610   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26611   Dali::Radian arg2 ;
26612   Dali::Radian *argp2 ;
26613
26614   arg1 = (Dali::PanGestureDetector *)jarg1;
26615   argp2 = (Dali::Radian *)jarg2;
26616   if (!argp2) {
26617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
26618     return ;
26619   }
26620   arg2 = *argp2;
26621   {
26622     try {
26623       (arg1)->AddDirection(arg2);
26624     } CALL_CATCH_EXCEPTION();
26625   }
26626
26627 }
26628
26629
26630 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
26631   unsigned long jresult ;
26632   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26633   size_t result;
26634
26635   arg1 = (Dali::PanGestureDetector *)jarg1;
26636   {
26637     try {
26638       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
26639     } CALL_CATCH_EXCEPTION(0);
26640   }
26641
26642   jresult = (unsigned long)result;
26643   return jresult;
26644 }
26645
26646
26647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
26648   void * jresult ;
26649   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26650   size_t arg2 ;
26651   Dali::PanGestureDetector::AngleThresholdPair result;
26652
26653   arg1 = (Dali::PanGestureDetector *)jarg1;
26654   arg2 = (size_t)jarg2;
26655   {
26656     try {
26657       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
26658     } CALL_CATCH_EXCEPTION(0);
26659   }
26660
26661   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
26662   return jresult;
26663 }
26664
26665
26666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
26667   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26668
26669   arg1 = (Dali::PanGestureDetector *)jarg1;
26670   {
26671     try {
26672       (arg1)->ClearAngles();
26673     } CALL_CATCH_EXCEPTION();
26674   }
26675
26676 }
26677
26678
26679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
26680   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26681   Dali::Radian arg2 ;
26682   Dali::Radian *argp2 ;
26683
26684   arg1 = (Dali::PanGestureDetector *)jarg1;
26685   argp2 = (Dali::Radian *)jarg2;
26686   if (!argp2) {
26687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
26688     return ;
26689   }
26690   arg2 = *argp2;
26691   {
26692     try {
26693       (arg1)->RemoveAngle(arg2);
26694     } CALL_CATCH_EXCEPTION();
26695   }
26696
26697 }
26698
26699
26700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
26701   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26702   Dali::Radian arg2 ;
26703   Dali::Radian *argp2 ;
26704
26705   arg1 = (Dali::PanGestureDetector *)jarg1;
26706   argp2 = (Dali::Radian *)jarg2;
26707   if (!argp2) {
26708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
26709     return ;
26710   }
26711   arg2 = *argp2;
26712   {
26713     try {
26714       (arg1)->RemoveDirection(arg2);
26715     } CALL_CATCH_EXCEPTION();
26716   }
26717
26718 }
26719
26720
26721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
26722   void * jresult ;
26723   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26724   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
26725
26726   arg1 = (Dali::PanGestureDetector *)jarg1;
26727   {
26728     try {
26729       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
26730     } CALL_CATCH_EXCEPTION(0);
26731   }
26732
26733   jresult = (void *)result;
26734   return jresult;
26735 }
26736
26737
26738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
26739   Dali::PanGesture *arg1 = 0 ;
26740
26741   arg1 = (Dali::PanGesture *)jarg1;
26742   if (!arg1) {
26743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
26744     return ;
26745   }
26746   {
26747     try {
26748       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
26749     } CALL_CATCH_EXCEPTION();
26750   }
26751
26752 }
26753
26754
26755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
26756   void * jresult ;
26757   Dali::PanGesture *result = 0 ;
26758
26759   {
26760     try {
26761       result = (Dali::PanGesture *)new Dali::PanGesture();
26762     } CALL_CATCH_EXCEPTION(0);
26763   }
26764
26765   jresult = (void *)result;
26766   return jresult;
26767 }
26768
26769
26770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_New(int jarg1) {
26771   void * jresult ;
26772   Dali::GestureState arg1 ;
26773   Dali::PanGesture result;
26774
26775   arg1 = (Dali::GestureState)jarg1;
26776   {
26777     try {
26778       result = DevelPanGesture::New(arg1);
26779     } CALL_CATCH_EXCEPTION(0);
26780   }
26781
26782   jresult = new Dali::PanGesture((const Dali::PanGesture &)result);
26783   return jresult;
26784 }
26785
26786
26787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
26788   void * jresult ;
26789   Dali::PanGesture *arg1 = 0 ;
26790   Dali::PanGesture *result = 0 ;
26791
26792   arg1 = (Dali::PanGesture *)jarg1;
26793   if (!arg1) {
26794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
26795     return 0;
26796   }
26797   {
26798     try {
26799       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
26800     } CALL_CATCH_EXCEPTION(0);
26801   }
26802
26803   jresult = (void *)result;
26804   return jresult;
26805 }
26806
26807
26808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
26809   void * jresult ;
26810   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
26811   Dali::PanGesture *arg2 = 0 ;
26812   Dali::PanGesture *result = 0 ;
26813
26814   arg1 = (Dali::PanGesture *)jarg1;
26815   arg2 = (Dali::PanGesture *)jarg2;
26816   if (!arg2) {
26817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
26818     return 0;
26819   }
26820   {
26821     try {
26822       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
26823     } CALL_CATCH_EXCEPTION(0);
26824   }
26825
26826   jresult = (void *)result;
26827   return jresult;
26828 }
26829
26830
26831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
26832   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
26833
26834   arg1 = (Dali::PanGesture *)jarg1;
26835   {
26836     try {
26837       delete arg1;
26838     } CALL_CATCH_EXCEPTION();
26839   }
26840
26841 }
26842
26843
26844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
26845   void * jresult ;
26846   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
26847   Dali::Vector2 result;
26848
26849   arg1 = (Dali::PanGesture *)jarg1;
26850   {
26851     try {
26852       result = ((Dali::PanGesture const *)arg1)->GetVelocity();
26853     } catch (std::out_of_range& e) {
26854       {
26855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26856       };
26857     } catch (std::exception& e) {
26858       {
26859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26860       };
26861     } catch (Dali::DaliException e) {
26862       {
26863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26864       };
26865     } catch (...) {
26866       {
26867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26868       };
26869     }
26870   }
26871   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
26872   return jresult;
26873 }
26874
26875
26876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
26877   void * jresult ;
26878   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
26879   Dali::Vector2 result;
26880
26881   arg1 = (Dali::PanGesture *)jarg1;
26882   {
26883     try {
26884       result = ((Dali::PanGesture const *)arg1)->GetDisplacement();
26885     } catch (std::out_of_range& e) {
26886       {
26887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26888       };
26889     } catch (std::exception& e) {
26890       {
26891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26892       };
26893     } catch (Dali::DaliException e) {
26894       {
26895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26896       };
26897     } catch (...) {
26898       {
26899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26900       };
26901     }
26902   }
26903   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
26904   return jresult;
26905 }
26906
26907
26908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
26909   void * jresult ;
26910   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
26911   Dali::Vector2 result;
26912
26913   arg1 = (Dali::PanGesture *)jarg1;
26914   {
26915     try {
26916       result = ((Dali::PanGesture const *)arg1)->GetPosition();
26917     } catch (std::out_of_range& e) {
26918       {
26919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26920       };
26921     } catch (std::exception& e) {
26922       {
26923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26924       };
26925     } catch (Dali::DaliException e) {
26926       {
26927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26928       };
26929     } catch (...) {
26930       {
26931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26932       };
26933     }
26934   }
26935   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
26936   return jresult;
26937 }
26938
26939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
26940   void * jresult ;
26941   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
26942   Dali::Vector2 result;
26943
26944   arg1 = (Dali::PanGesture *)jarg1;
26945   {
26946     try {
26947       result = ((Dali::PanGesture const *)arg1)->GetScreenVelocity();
26948     } catch (std::out_of_range& e) {
26949       {
26950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26951       };
26952     } catch (std::exception& e) {
26953       {
26954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26955       };
26956     } catch (Dali::DaliException e) {
26957       {
26958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26959       };
26960     } catch (...) {
26961       {
26962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26963       };
26964     }
26965   }
26966   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
26967   return jresult;
26968 }
26969
26970
26971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
26972   void * jresult ;
26973   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
26974   Dali::Vector2 result;
26975
26976   arg1 = (Dali::PanGesture *)jarg1;
26977   {
26978     try {
26979       result = ((Dali::PanGesture const *)arg1)->GetScreenDisplacement();
26980     } catch (std::out_of_range& e) {
26981       {
26982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26983       };
26984     } catch (std::exception& e) {
26985       {
26986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26987       };
26988     } catch (Dali::DaliException e) {
26989       {
26990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26991       };
26992     } catch (...) {
26993       {
26994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26995       };
26996     }
26997   }
26998   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
26999   return jresult;
27000 }
27001
27002
27003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
27004   void * jresult ;
27005   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27006   Dali::Vector2 result;
27007
27008   arg1 = (Dali::PanGesture *)jarg1;
27009   {
27010     try {
27011       result = ((Dali::PanGesture const *)arg1)->GetScreenPosition();
27012     } catch (std::out_of_range& e) {
27013       {
27014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27015       };
27016     } catch (std::exception& e) {
27017       {
27018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27019       };
27020     } catch (Dali::DaliException e) {
27021       {
27022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27023       };
27024     } catch (...) {
27025       {
27026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27027       };
27028     }
27029   }
27030   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
27031   return jresult;
27032 }
27033
27034
27035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
27036   unsigned int jresult ;
27037   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27038   unsigned int result;
27039
27040   arg1 = (Dali::PanGesture *)jarg1;
27041   result = (unsigned int) ((arg1)->GetNumberOfTouches());
27042   jresult = result;
27043   return jresult;
27044 }
27045
27046
27047 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
27048   float jresult ;
27049   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27050   float result;
27051
27052   arg1 = (Dali::PanGesture *)jarg1;
27053   {
27054     try {
27055       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
27056     } CALL_CATCH_EXCEPTION(0);
27057   }
27058
27059   jresult = result;
27060   return jresult;
27061 }
27062
27063
27064 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
27065   float jresult ;
27066   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27067   float result;
27068
27069   arg1 = (Dali::PanGesture *)jarg1;
27070   {
27071     try {
27072       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
27073     } CALL_CATCH_EXCEPTION(0);
27074   }
27075
27076   jresult = result;
27077   return jresult;
27078 }
27079
27080
27081 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
27082   float jresult ;
27083   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27084   float result;
27085
27086   arg1 = (Dali::PanGesture *)jarg1;
27087   {
27088     try {
27089       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
27090     } CALL_CATCH_EXCEPTION(0);
27091   }
27092
27093   jresult = result;
27094   return jresult;
27095 }
27096
27097
27098 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
27099   float jresult ;
27100   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27101   float result;
27102
27103   arg1 = (Dali::PanGesture *)jarg1;
27104   {
27105     try {
27106       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
27107     } CALL_CATCH_EXCEPTION(0);
27108   }
27109
27110   jresult = result;
27111   return jresult;
27112 }
27113
27114
27115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
27116   void * jresult ;
27117   Dali::PinchGestureDetector *result = 0 ;
27118
27119   {
27120     try {
27121       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
27122     } CALL_CATCH_EXCEPTION(0);
27123   }
27124
27125   jresult = (void *)result;
27126   return jresult;
27127 }
27128
27129
27130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
27131   void * jresult ;
27132   Dali::PinchGestureDetector result;
27133
27134   {
27135     try {
27136       result = Dali::PinchGestureDetector::New();
27137     } CALL_CATCH_EXCEPTION(0);
27138   }
27139
27140   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
27141   return jresult;
27142 }
27143
27144
27145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
27146   void * jresult ;
27147   Dali::BaseHandle arg1 ;
27148   Dali::BaseHandle *argp1 ;
27149   Dali::PinchGestureDetector result;
27150
27151   argp1 = (Dali::BaseHandle *)jarg1;
27152   if (!argp1) {
27153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27154     return 0;
27155   }
27156   arg1 = *argp1;
27157   {
27158     try {
27159       result = Dali::PinchGestureDetector::DownCast(arg1);
27160     } CALL_CATCH_EXCEPTION(0);
27161   }
27162
27163   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
27164   return jresult;
27165 }
27166
27167
27168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
27169   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
27170
27171   arg1 = (Dali::PinchGestureDetector *)jarg1;
27172   {
27173     try {
27174       delete arg1;
27175     } CALL_CATCH_EXCEPTION();
27176   }
27177
27178 }
27179
27180
27181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
27182   void * jresult ;
27183   Dali::PinchGestureDetector *arg1 = 0 ;
27184   Dali::PinchGestureDetector *result = 0 ;
27185
27186   arg1 = (Dali::PinchGestureDetector *)jarg1;
27187   if (!arg1) {
27188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
27189     return 0;
27190   }
27191   {
27192     try {
27193       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
27194     } CALL_CATCH_EXCEPTION(0);
27195   }
27196
27197   jresult = (void *)result;
27198   return jresult;
27199 }
27200
27201
27202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
27203   void * jresult ;
27204   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
27205   Dali::PinchGestureDetector *arg2 = 0 ;
27206   Dali::PinchGestureDetector *result = 0 ;
27207
27208   arg1 = (Dali::PinchGestureDetector *)jarg1;
27209   arg2 = (Dali::PinchGestureDetector *)jarg2;
27210   if (!arg2) {
27211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
27212     return 0;
27213   }
27214   {
27215     try {
27216       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
27217     } CALL_CATCH_EXCEPTION(0);
27218   }
27219
27220   jresult = (void *)result;
27221   return jresult;
27222 }
27223
27224
27225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
27226   void * jresult ;
27227   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
27228   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
27229
27230   arg1 = (Dali::PinchGestureDetector *)jarg1;
27231   {
27232     try {
27233       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27234     } CALL_CATCH_EXCEPTION(0);
27235   }
27236
27237   jresult = (void *)result;
27238   return jresult;
27239 }
27240
27241
27242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0() {
27243   void * jresult ;
27244   Dali::PinchGesture *result = 0 ;
27245
27246   {
27247     try {
27248       result = (Dali::PinchGesture *)new Dali::PinchGesture();
27249     } CALL_CATCH_EXCEPTION(0);
27250   }
27251
27252   jresult = (void *)result;
27253   return jresult;
27254 }
27255
27256
27257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_New(int jarg1) {
27258   void * jresult ;
27259   Dali::GestureState arg1 ;
27260   Dali::PinchGesture result;
27261
27262   arg1 = (Dali::GestureState)jarg1;
27263   {
27264     try {
27265       result = DevelPinchGesture::New(arg1);
27266     } CALL_CATCH_EXCEPTION(0);
27267   }
27268
27269   jresult = new Dali::PinchGesture((const Dali::PinchGesture &)result);
27270   return jresult;
27271 }
27272
27273
27274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
27275   void * jresult ;
27276   Dali::PinchGesture *arg1 = 0 ;
27277   Dali::PinchGesture *result = 0 ;
27278
27279   arg1 = (Dali::PinchGesture *)jarg1;
27280   if (!arg1) {
27281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
27282     return 0;
27283   }
27284   {
27285     try {
27286       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
27287     } CALL_CATCH_EXCEPTION(0);
27288   }
27289
27290   jresult = (void *)result;
27291   return jresult;
27292 }
27293
27294
27295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
27296   void * jresult ;
27297   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
27298   Dali::PinchGesture *arg2 = 0 ;
27299   Dali::PinchGesture *result = 0 ;
27300
27301   arg1 = (Dali::PinchGesture *)jarg1;
27302   arg2 = (Dali::PinchGesture *)jarg2;
27303   if (!arg2) {
27304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
27305     return 0;
27306   }
27307   {
27308     try {
27309       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
27310     } CALL_CATCH_EXCEPTION(0);
27311   }
27312
27313   jresult = (void *)result;
27314   return jresult;
27315 }
27316
27317
27318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
27319   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
27320
27321   arg1 = (Dali::PinchGesture *)jarg1;
27322   {
27323     try {
27324       delete arg1;
27325     } CALL_CATCH_EXCEPTION();
27326   }
27327
27328 }
27329
27330
27331 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
27332   float jresult ;
27333   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
27334   float result;
27335
27336   arg1 = (Dali::PinchGesture *)jarg1;
27337   result = (float) ((arg1)->GetScale());
27338   jresult = result;
27339   return jresult;
27340 }
27341
27342
27343 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
27344   float jresult ;
27345   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
27346   float result;
27347
27348   arg1 = (Dali::PinchGesture *)jarg1;
27349   result = (float) ((arg1)->GetSpeed());
27350   jresult = result;
27351   return jresult;
27352 }
27353
27354
27355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
27356   void * jresult ;
27357   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
27358   Dali::Vector2 result;
27359
27360   arg1 = (Dali::PinchGesture *)jarg1;
27361   {
27362     try {
27363       result = ((Dali::PinchGesture const *)arg1)->GetScreenCenterPoint();
27364     } catch (std::out_of_range& e) {
27365       {
27366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27367       };
27368     } catch (std::exception& e) {
27369       {
27370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27371       };
27372     } catch (Dali::DaliException e) {
27373       {
27374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27375       };
27376     } catch (...) {
27377       {
27378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27379       };
27380     }
27381   }
27382   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
27383   return jresult;
27384 }
27385
27386
27387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
27388   void * jresult ;
27389   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
27390   Dali::Vector2 result;
27391
27392   arg1 = (Dali::PinchGesture *)jarg1;
27393   {
27394     try {
27395       result = ((Dali::PinchGesture const *)arg1)->GetLocalCenterPoint();
27396     } catch (std::out_of_range& e) {
27397       {
27398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27399       };
27400     } catch (std::exception& e) {
27401       {
27402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27403       };
27404     } catch (Dali::DaliException e) {
27405       {
27406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27407       };
27408     } catch (...) {
27409       {
27410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27411       };
27412     }
27413   }
27414   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
27415   return jresult;
27416 }
27417
27418
27419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
27420   void * jresult ;
27421   Dali::TapGestureDetector *result = 0 ;
27422
27423   {
27424     try {
27425       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
27426     } CALL_CATCH_EXCEPTION(0);
27427   }
27428
27429   jresult = (void *)result;
27430   return jresult;
27431 }
27432
27433
27434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
27435   void * jresult ;
27436   Dali::TapGestureDetector result;
27437
27438   {
27439     try {
27440       result = Dali::TapGestureDetector::New();
27441     } CALL_CATCH_EXCEPTION(0);
27442   }
27443
27444   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
27445   return jresult;
27446 }
27447
27448
27449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
27450   void * jresult ;
27451   unsigned int arg1 ;
27452   Dali::TapGestureDetector result;
27453
27454   arg1 = (unsigned int)jarg1;
27455   {
27456     try {
27457       result = Dali::TapGestureDetector::New(arg1);
27458     } CALL_CATCH_EXCEPTION(0);
27459   }
27460
27461   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
27462   return jresult;
27463 }
27464
27465
27466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
27467   void * jresult ;
27468   Dali::BaseHandle arg1 ;
27469   Dali::BaseHandle *argp1 ;
27470   Dali::TapGestureDetector result;
27471
27472   argp1 = (Dali::BaseHandle *)jarg1;
27473   if (!argp1) {
27474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27475     return 0;
27476   }
27477   arg1 = *argp1;
27478   {
27479     try {
27480       result = Dali::TapGestureDetector::DownCast(arg1);
27481     } CALL_CATCH_EXCEPTION(0);
27482   }
27483
27484   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
27485   return jresult;
27486 }
27487
27488
27489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
27490   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
27491
27492   arg1 = (Dali::TapGestureDetector *)jarg1;
27493   {
27494     try {
27495       delete arg1;
27496     } CALL_CATCH_EXCEPTION();
27497   }
27498
27499 }
27500
27501
27502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
27503   void * jresult ;
27504   Dali::TapGestureDetector *arg1 = 0 ;
27505   Dali::TapGestureDetector *result = 0 ;
27506
27507   arg1 = (Dali::TapGestureDetector *)jarg1;
27508   if (!arg1) {
27509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
27510     return 0;
27511   }
27512   {
27513     try {
27514       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
27515     } CALL_CATCH_EXCEPTION(0);
27516   }
27517
27518   jresult = (void *)result;
27519   return jresult;
27520 }
27521
27522
27523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
27524   void * jresult ;
27525   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
27526   Dali::TapGestureDetector *arg2 = 0 ;
27527   Dali::TapGestureDetector *result = 0 ;
27528
27529   arg1 = (Dali::TapGestureDetector *)jarg1;
27530   arg2 = (Dali::TapGestureDetector *)jarg2;
27531   if (!arg2) {
27532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
27533     return 0;
27534   }
27535   {
27536     try {
27537       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
27538     } CALL_CATCH_EXCEPTION(0);
27539   }
27540
27541   jresult = (void *)result;
27542   return jresult;
27543 }
27544
27545
27546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
27547   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
27548   unsigned int arg2 ;
27549
27550   arg1 = (Dali::TapGestureDetector *)jarg1;
27551   arg2 = (unsigned int)jarg2;
27552   {
27553     try {
27554       (arg1)->SetMinimumTapsRequired(arg2);
27555     } CALL_CATCH_EXCEPTION();
27556   }
27557
27558 }
27559
27560
27561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
27562   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
27563   unsigned int arg2 ;
27564
27565   arg1 = (Dali::TapGestureDetector *)jarg1;
27566   arg2 = (unsigned int)jarg2;
27567   {
27568     try {
27569       (arg1)->SetMaximumTapsRequired(arg2);
27570     } CALL_CATCH_EXCEPTION();
27571   }
27572
27573 }
27574
27575
27576 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
27577   unsigned int jresult ;
27578   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
27579   unsigned int result;
27580
27581   arg1 = (Dali::TapGestureDetector *)jarg1;
27582   {
27583     try {
27584       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
27585     } CALL_CATCH_EXCEPTION(0);
27586   }
27587
27588   jresult = result;
27589   return jresult;
27590 }
27591
27592
27593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
27594   unsigned int jresult ;
27595   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
27596   unsigned int result;
27597
27598   arg1 = (Dali::TapGestureDetector *)jarg1;
27599   {
27600     try {
27601       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
27602     } CALL_CATCH_EXCEPTION(0);
27603   }
27604
27605   jresult = result;
27606   return jresult;
27607 }
27608
27609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_ReceiveAllTapEvents(void * tapGestureDetector, bool isReceive) {
27610   Dali::TapGestureDetector *detector = (Dali::TapGestureDetector *) 0 ;
27611
27612   detector = (Dali::TapGestureDetector *)tapGestureDetector;
27613   if (!detector) {
27614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
27615     return;
27616   }
27617   {
27618     try {
27619       (detector)->ReceiveAllTapEvents(isReceive);
27620     } CALL_CATCH_EXCEPTION();
27621   }
27622
27623 }
27624
27625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
27626   void * jresult ;
27627   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
27628   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
27629
27630   arg1 = (Dali::TapGestureDetector *)jarg1;
27631   {
27632     try {
27633       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27634     } CALL_CATCH_EXCEPTION(0);
27635   }
27636
27637   jresult = (void *)result;
27638   return jresult;
27639 }
27640
27641
27642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
27643   void * jresult ;
27644   Dali::TapGesture *result = 0 ;
27645
27646   {
27647     try {
27648       result = (Dali::TapGesture *)new Dali::TapGesture();
27649     } CALL_CATCH_EXCEPTION(0);
27650   }
27651
27652   jresult = (void *)result;
27653   return jresult;
27654 }
27655
27656
27657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_New(int jarg1) {
27658   void * jresult ;
27659   Dali::GestureState arg1 ;
27660   Dali::TapGesture result;
27661
27662   arg1 = (Dali::GestureState)jarg1;
27663   {
27664     try {
27665       result = DevelTapGesture::New(arg1);
27666     } CALL_CATCH_EXCEPTION(0);
27667   }
27668
27669   jresult = new Dali::TapGesture((const Dali::TapGesture &)result);
27670   return jresult;
27671 }
27672
27673
27674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
27675   void * jresult ;
27676   Dali::TapGesture *arg1 = 0 ;
27677   Dali::TapGesture *result = 0 ;
27678
27679   arg1 = (Dali::TapGesture *)jarg1;
27680   if (!arg1) {
27681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
27682     return 0;
27683   }
27684   {
27685     try {
27686       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
27687     } CALL_CATCH_EXCEPTION(0);
27688   }
27689
27690   jresult = (void *)result;
27691   return jresult;
27692 }
27693
27694
27695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
27696   void * jresult ;
27697   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
27698   Dali::TapGesture *arg2 = 0 ;
27699   Dali::TapGesture *result = 0 ;
27700
27701   arg1 = (Dali::TapGesture *)jarg1;
27702   arg2 = (Dali::TapGesture *)jarg2;
27703   if (!arg2) {
27704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
27705     return 0;
27706   }
27707   {
27708     try {
27709       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
27710     } CALL_CATCH_EXCEPTION(0);
27711   }
27712
27713   jresult = (void *)result;
27714   return jresult;
27715 }
27716
27717
27718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
27719   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
27720
27721   arg1 = (Dali::TapGesture *)jarg1;
27722   {
27723     try {
27724       delete arg1;
27725     } CALL_CATCH_EXCEPTION();
27726   }
27727
27728 }
27729
27730
27731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
27732   unsigned int jresult ;
27733   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
27734   unsigned int result;
27735
27736   arg1 = (Dali::TapGesture *)jarg1;
27737   result = (unsigned int) ((arg1)->GetNumberOfTaps());
27738   jresult = result;
27739   return jresult;
27740 }
27741
27742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
27743   unsigned int jresult ;
27744   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
27745   unsigned int result;
27746
27747   arg1 = (Dali::TapGesture *)jarg1;
27748   result = (unsigned int) ((arg1)->GetNumberOfTouches());
27749   jresult = result;
27750   return jresult;
27751 }
27752
27753
27754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
27755   void * jresult ;
27756   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
27757   Dali::Vector2 result;
27758
27759   arg1 = (Dali::TapGesture *)jarg1;
27760   {
27761     try {
27762       result = ((Dali::TapGesture const *)arg1)->GetScreenPoint();
27763     } catch (std::out_of_range& e) {
27764       {
27765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27766       };
27767     } catch (std::exception& e) {
27768       {
27769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27770       };
27771     } catch (Dali::DaliException e) {
27772       {
27773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27774       };
27775     } catch (...) {
27776       {
27777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27778       };
27779     }
27780   }
27781   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
27782   return jresult;
27783 }
27784
27785
27786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
27787   void * jresult ;
27788   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
27789   Dali::Vector2 result;
27790
27791   arg1 = (Dali::TapGesture *)jarg1;
27792   {
27793     try {
27794       result = ((Dali::TapGesture const *)arg1)->GetLocalPoint();
27795     } catch (std::out_of_range& e) {
27796       {
27797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27798       };
27799     } catch (std::exception& e) {
27800       {
27801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27802       };
27803     } catch (Dali::DaliException e) {
27804       {
27805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27806       };
27807     } catch (...) {
27808       {
27809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27810       };
27811     }
27812   }
27813   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
27814   return jresult;
27815 }
27816
27817
27818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TapGesture_sourceType_get(void * jarg1) {
27819   int jresult ;
27820   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
27821   Dali::GestureSourceType result;
27822
27823   arg1 = (Dali::TapGesture *)jarg1;
27824   {
27825     try {
27826       result = ((Dali::TapGesture const *)arg1)->GetSourceType();
27827     } CALL_CATCH_EXCEPTION(0);
27828   }
27829
27830   jresult = static_cast< int >(result);
27831   return jresult;
27832 }
27833
27834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
27835   void * jresult ;
27836   Dali::AlphaFunction *result = 0 ;
27837
27838   {
27839     try {
27840       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
27841     } CALL_CATCH_EXCEPTION(0);
27842   }
27843
27844   jresult = (void *)result;
27845   return jresult;
27846 }
27847
27848
27849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
27850   void * jresult ;
27851   Dali::AlphaFunction::BuiltinFunction arg1 ;
27852   Dali::AlphaFunction *result = 0 ;
27853
27854   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
27855   {
27856     try {
27857       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
27858     } CALL_CATCH_EXCEPTION(0);
27859   }
27860
27861   jresult = (void *)result;
27862   return jresult;
27863 }
27864
27865
27866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
27867   void * jresult ;
27868   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
27869   Dali::AlphaFunction *result = 0 ;
27870
27871   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
27872   {
27873     try {
27874       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
27875     } CALL_CATCH_EXCEPTION(0);
27876   }
27877
27878   jresult = (void *)result;
27879   return jresult;
27880 }
27881
27882
27883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
27884   void * jresult ;
27885   Dali::Vector2 *arg1 = 0 ;
27886   Dali::Vector2 *arg2 = 0 ;
27887   Dali::AlphaFunction *result = 0 ;
27888
27889   arg1 = (Dali::Vector2 *)jarg1;
27890   if (!arg1) {
27891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27892     return 0;
27893   }
27894   arg2 = (Dali::Vector2 *)jarg2;
27895   if (!arg2) {
27896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27897     return 0;
27898   }
27899   {
27900     try {
27901       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
27902     } CALL_CATCH_EXCEPTION(0);
27903   }
27904
27905   jresult = (void *)result;
27906   return jresult;
27907 }
27908
27909
27910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
27911   void * jresult ;
27912   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
27913   Dali::Vector4 result;
27914
27915   arg1 = (Dali::AlphaFunction *)jarg1;
27916   {
27917     try {
27918       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
27919     } CALL_CATCH_EXCEPTION(0);
27920   }
27921
27922   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
27923   return jresult;
27924 }
27925
27926
27927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
27928   void * jresult ;
27929   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
27930   Dali::AlphaFunctionPrototype result;
27931
27932   arg1 = (Dali::AlphaFunction *)jarg1;
27933   {
27934     try {
27935       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
27936     } CALL_CATCH_EXCEPTION(0);
27937   }
27938
27939   jresult = (void *)result;
27940   return jresult;
27941 }
27942
27943
27944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
27945   int jresult ;
27946   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
27947   Dali::AlphaFunction::BuiltinFunction result;
27948
27949   arg1 = (Dali::AlphaFunction *)jarg1;
27950   {
27951     try {
27952       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
27953     } CALL_CATCH_EXCEPTION(0);
27954   }
27955
27956   jresult = (int)result;
27957   return jresult;
27958 }
27959
27960
27961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
27962   int jresult ;
27963   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
27964   Dali::AlphaFunction::Mode result;
27965
27966   arg1 = (Dali::AlphaFunction *)jarg1;
27967   {
27968     try {
27969       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
27970     } CALL_CATCH_EXCEPTION(0);
27971   }
27972
27973   jresult = (int)result;
27974   return jresult;
27975 }
27976
27977
27978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
27979   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
27980
27981   arg1 = (Dali::AlphaFunction *)jarg1;
27982   {
27983     try {
27984       delete arg1;
27985     } CALL_CATCH_EXCEPTION();
27986   }
27987
27988 }
27989
27990
27991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
27992   void * jresult ;
27993   Dali::KeyFrames result;
27994
27995   {
27996     try {
27997       result = Dali::KeyFrames::New();
27998     } CALL_CATCH_EXCEPTION(0);
27999   }
28000
28001   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
28002   return jresult;
28003 }
28004
28005
28006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
28007   void * jresult ;
28008   Dali::BaseHandle arg1 ;
28009   Dali::BaseHandle *argp1 ;
28010   Dali::KeyFrames result;
28011
28012   argp1 = (Dali::BaseHandle *)jarg1;
28013   if (!argp1) {
28014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28015     return 0;
28016   }
28017   arg1 = *argp1;
28018   {
28019     try {
28020       result = Dali::KeyFrames::DownCast(arg1);
28021     } CALL_CATCH_EXCEPTION(0);
28022   }
28023
28024   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
28025   return jresult;
28026 }
28027
28028
28029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
28030   void * jresult ;
28031   Dali::KeyFrames *result = 0 ;
28032
28033   {
28034     try {
28035       result = (Dali::KeyFrames *)new Dali::KeyFrames();
28036     } CALL_CATCH_EXCEPTION(0);
28037   }
28038
28039   jresult = (void *)result;
28040   return jresult;
28041 }
28042
28043
28044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
28045   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
28046
28047   arg1 = (Dali::KeyFrames *)jarg1;
28048   {
28049     try {
28050       delete arg1;
28051     } CALL_CATCH_EXCEPTION();
28052   }
28053
28054 }
28055
28056
28057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
28058   void * jresult ;
28059   Dali::KeyFrames *arg1 = 0 ;
28060   Dali::KeyFrames *result = 0 ;
28061
28062   arg1 = (Dali::KeyFrames *)jarg1;
28063   if (!arg1) {
28064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
28065     return 0;
28066   }
28067   {
28068     try {
28069       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
28070     } CALL_CATCH_EXCEPTION(0);
28071   }
28072
28073   jresult = (void *)result;
28074   return jresult;
28075 }
28076
28077
28078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
28079   void * jresult ;
28080   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
28081   Dali::KeyFrames *arg2 = 0 ;
28082   Dali::KeyFrames *result = 0 ;
28083
28084   arg1 = (Dali::KeyFrames *)jarg1;
28085   arg2 = (Dali::KeyFrames *)jarg2;
28086   if (!arg2) {
28087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
28088     return 0;
28089   }
28090   {
28091     try {
28092       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
28093     } CALL_CATCH_EXCEPTION(0);
28094   }
28095
28096   jresult = (void *)result;
28097   return jresult;
28098 }
28099
28100
28101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
28102   int jresult ;
28103   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
28104   Dali::Property::Type result;
28105
28106   arg1 = (Dali::KeyFrames *)jarg1;
28107   {
28108     try {
28109       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
28110     } CALL_CATCH_EXCEPTION(0);
28111   }
28112
28113   jresult = (int)result;
28114   return jresult;
28115 }
28116
28117
28118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
28119   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
28120   float arg2 ;
28121   Dali::Property::Value arg3 ;
28122   Dali::Property::Value *argp3 ;
28123
28124   arg1 = (Dali::KeyFrames *)jarg1;
28125   arg2 = (float)jarg2;
28126   argp3 = (Dali::Property::Value *)jarg3;
28127   if (!argp3) {
28128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
28129     return ;
28130   }
28131   arg3 = *argp3;
28132   {
28133     try {
28134       (arg1)->Add(arg2,arg3);
28135     } CALL_CATCH_EXCEPTION();
28136   }
28137
28138 }
28139
28140
28141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
28142   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
28143   float arg2 ;
28144   Dali::Property::Value arg3 ;
28145   Dali::AlphaFunction arg4 ;
28146   Dali::Property::Value *argp3 ;
28147   Dali::AlphaFunction *argp4 ;
28148
28149   arg1 = (Dali::KeyFrames *)jarg1;
28150   arg2 = (float)jarg2;
28151   argp3 = (Dali::Property::Value *)jarg3;
28152   if (!argp3) {
28153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
28154     return ;
28155   }
28156   arg3 = *argp3;
28157   argp4 = (Dali::AlphaFunction *)jarg4;
28158   if (!argp4) {
28159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
28160     return ;
28161   }
28162   arg4 = *argp4;
28163   {
28164     try {
28165       (arg1)->Add(arg2,arg3,arg4);
28166     } CALL_CATCH_EXCEPTION();
28167   }
28168
28169 }
28170
28171 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyFrames_GetKeyFrameCount(void* keyFrames)
28172 {
28173   return (unsigned int) Dali::DevelKeyFrames::GetKeyFrameCount(*((Dali::KeyFrames*)keyFrames));
28174 }
28175
28176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_GetKeyFrame(void* keyFrames, unsigned int index, float* time, void* value)
28177 {
28178   Dali::DevelKeyFrames::GetKeyFrame(*((Dali::KeyFrames*)keyFrames), (size_t)index, *time, *((Property::Value*)value));
28179 }
28180
28181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
28182   int jresult ;
28183   int result;
28184
28185   result = (int)Dali::Path::Property::POINTS;
28186   jresult = (int)result;
28187   return jresult;
28188 }
28189
28190
28191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
28192   int jresult ;
28193   int result;
28194
28195   result = (int)Dali::Path::Property::CONTROL_POINTS;
28196   jresult = (int)result;
28197   return jresult;
28198 }
28199
28200
28201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
28202   void * jresult ;
28203   Dali::Path::Property *result = 0 ;
28204
28205   {
28206     try {
28207       result = (Dali::Path::Property *)new Dali::Path::Property();
28208     } CALL_CATCH_EXCEPTION(0);
28209   }
28210
28211   jresult = (void *)result;
28212   return jresult;
28213 }
28214
28215
28216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
28217   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
28218
28219   arg1 = (Dali::Path::Property *)jarg1;
28220   {
28221     try {
28222       delete arg1;
28223     } CALL_CATCH_EXCEPTION();
28224   }
28225
28226 }
28227
28228
28229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
28230   void * jresult ;
28231   Dali::Path result;
28232
28233   {
28234     try {
28235       result = Dali::Path::New();
28236     } CALL_CATCH_EXCEPTION(0);
28237   }
28238
28239   jresult = new Dali::Path((const Dali::Path &)result);
28240   return jresult;
28241 }
28242
28243
28244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
28245   void * jresult ;
28246   Dali::BaseHandle arg1 ;
28247   Dali::BaseHandle *argp1 ;
28248   Dali::Path result;
28249
28250   argp1 = (Dali::BaseHandle *)jarg1;
28251   if (!argp1) {
28252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28253     return 0;
28254   }
28255   arg1 = *argp1;
28256   {
28257     try {
28258       result = Dali::Path::DownCast(arg1);
28259     } CALL_CATCH_EXCEPTION(0);
28260   }
28261
28262   jresult = new Dali::Path((const Dali::Path &)result);
28263   return jresult;
28264 }
28265
28266
28267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
28268   void * jresult ;
28269   Dali::Path *result = 0 ;
28270
28271   {
28272     try {
28273       result = (Dali::Path *)new Dali::Path();
28274     } CALL_CATCH_EXCEPTION(0);
28275   }
28276
28277   jresult = (void *)result;
28278   return jresult;
28279 }
28280
28281
28282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
28283   Dali::Path *arg1 = (Dali::Path *) 0 ;
28284
28285   arg1 = (Dali::Path *)jarg1;
28286   {
28287     try {
28288       delete arg1;
28289     } CALL_CATCH_EXCEPTION();
28290   }
28291
28292 }
28293
28294
28295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
28296   void * jresult ;
28297   Dali::Path *arg1 = 0 ;
28298   Dali::Path *result = 0 ;
28299
28300   arg1 = (Dali::Path *)jarg1;
28301   if (!arg1) {
28302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
28303     return 0;
28304   }
28305   {
28306     try {
28307       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
28308     } CALL_CATCH_EXCEPTION(0);
28309   }
28310
28311   jresult = (void *)result;
28312   return jresult;
28313 }
28314
28315
28316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
28317   void * jresult ;
28318   Dali::Path *arg1 = (Dali::Path *) 0 ;
28319   Dali::Path *arg2 = 0 ;
28320   Dali::Path *result = 0 ;
28321
28322   arg1 = (Dali::Path *)jarg1;
28323   arg2 = (Dali::Path *)jarg2;
28324   if (!arg2) {
28325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
28326     return 0;
28327   }
28328   {
28329     try {
28330       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
28331     } CALL_CATCH_EXCEPTION(0);
28332   }
28333
28334   jresult = (void *)result;
28335   return jresult;
28336 }
28337
28338
28339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
28340   Dali::Path *arg1 = (Dali::Path *) 0 ;
28341   Dali::Vector3 *arg2 = 0 ;
28342
28343   arg1 = (Dali::Path *)jarg1;
28344   arg2 = (Dali::Vector3 *)jarg2;
28345   if (!arg2) {
28346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
28347     return ;
28348   }
28349   {
28350     try {
28351       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
28352     } CALL_CATCH_EXCEPTION();
28353   }
28354
28355 }
28356
28357
28358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
28359   Dali::Path *arg1 = (Dali::Path *) 0 ;
28360   Dali::Vector3 *arg2 = 0 ;
28361
28362   arg1 = (Dali::Path *)jarg1;
28363   arg2 = (Dali::Vector3 *)jarg2;
28364   if (!arg2) {
28365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
28366     return ;
28367   }
28368   {
28369     try {
28370       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
28371     } CALL_CATCH_EXCEPTION();
28372   }
28373
28374 }
28375
28376
28377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
28378   Dali::Path *arg1 = (Dali::Path *) 0 ;
28379   float arg2 ;
28380
28381   arg1 = (Dali::Path *)jarg1;
28382   arg2 = (float)jarg2;
28383   {
28384     try {
28385       (arg1)->GenerateControlPoints(arg2);
28386     } CALL_CATCH_EXCEPTION();
28387   }
28388
28389 }
28390
28391
28392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
28393   Dali::Path *arg1 = (Dali::Path *) 0 ;
28394   float arg2 ;
28395   Dali::Vector3 *arg3 = 0 ;
28396   Dali::Vector3 *arg4 = 0 ;
28397
28398   arg1 = (Dali::Path *)jarg1;
28399   arg2 = (float)jarg2;
28400   arg3 = (Dali::Vector3 *)jarg3;
28401   if (!arg3) {
28402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
28403     return ;
28404   }
28405   arg4 = (Dali::Vector3 *)jarg4;
28406   if (!arg4) {
28407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
28408     return ;
28409   }
28410   {
28411     try {
28412       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
28413     } CALL_CATCH_EXCEPTION();
28414   }
28415
28416 }
28417
28418
28419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
28420   void * jresult ;
28421   Dali::Path *arg1 = (Dali::Path *) 0 ;
28422   size_t arg2 ;
28423   Dali::Vector3 *result = 0 ;
28424
28425   arg1 = (Dali::Path *)jarg1;
28426   arg2 = (size_t)jarg2;
28427   {
28428     try {
28429       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
28430     } CALL_CATCH_EXCEPTION(0);
28431   }
28432
28433   jresult = (void *)result;
28434   return jresult;
28435 }
28436
28437
28438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
28439   void * jresult ;
28440   Dali::Path *arg1 = (Dali::Path *) 0 ;
28441   size_t arg2 ;
28442   Dali::Vector3 *result = 0 ;
28443
28444   arg1 = (Dali::Path *)jarg1;
28445   arg2 = (size_t)jarg2;
28446   {
28447     try {
28448       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
28449     } CALL_CATCH_EXCEPTION(0);
28450   }
28451
28452   jresult = (void *)result;
28453   return jresult;
28454 }
28455
28456
28457 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
28458   unsigned long jresult ;
28459   Dali::Path *arg1 = (Dali::Path *) 0 ;
28460   size_t result;
28461
28462   arg1 = (Dali::Path *)jarg1;
28463   {
28464     try {
28465       result = ((Dali::Path const *)arg1)->GetPointCount();
28466     } CALL_CATCH_EXCEPTION(0);
28467   }
28468
28469   jresult = (unsigned long)result;
28470   return jresult;
28471 }
28472
28473
28474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
28475   void * jresult ;
28476   float arg1 ;
28477   Dali::TimePeriod *result = 0 ;
28478
28479   arg1 = (float)jarg1;
28480   {
28481     try {
28482       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
28483     } CALL_CATCH_EXCEPTION(0);
28484   }
28485
28486   jresult = (void *)result;
28487   return jresult;
28488 }
28489
28490
28491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
28492   void * jresult ;
28493   float arg1 ;
28494   float arg2 ;
28495   Dali::TimePeriod *result = 0 ;
28496
28497   arg1 = (float)jarg1;
28498   arg2 = (float)jarg2;
28499   {
28500     try {
28501       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
28502     } CALL_CATCH_EXCEPTION(0);
28503   }
28504
28505   jresult = (void *)result;
28506   return jresult;
28507 }
28508
28509
28510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
28511   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
28512
28513   arg1 = (Dali::TimePeriod *)jarg1;
28514   {
28515     try {
28516       delete arg1;
28517     } CALL_CATCH_EXCEPTION();
28518   }
28519
28520 }
28521
28522
28523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
28524   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
28525   float arg2 ;
28526
28527   arg1 = (Dali::TimePeriod *)jarg1;
28528   arg2 = (float)jarg2;
28529   if (arg1) (arg1)->delaySeconds = arg2;
28530 }
28531
28532
28533 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
28534   float jresult ;
28535   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
28536   float result;
28537
28538   arg1 = (Dali::TimePeriod *)jarg1;
28539   result = (float) ((arg1)->delaySeconds);
28540   jresult = result;
28541   return jresult;
28542 }
28543
28544
28545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
28546   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
28547   float arg2 ;
28548
28549   arg1 = (Dali::TimePeriod *)jarg1;
28550   arg2 = (float)jarg2;
28551   if (arg1) (arg1)->durationSeconds = arg2;
28552 }
28553
28554
28555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
28556   float jresult ;
28557   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
28558   float result;
28559
28560   arg1 = (Dali::TimePeriod *)jarg1;
28561   result = (float) ((arg1)->durationSeconds);
28562   jresult = result;
28563   return jresult;
28564 }
28565
28566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
28567   int jresult ;
28568   int result;
28569
28570   result = (int)Dali::LinearConstrainer::Property::VALUE;
28571   jresult = (int)result;
28572   return jresult;
28573 }
28574
28575
28576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
28577   int jresult ;
28578   int result;
28579
28580   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
28581   jresult = (int)result;
28582   return jresult;
28583 }
28584
28585
28586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
28587   void * jresult ;
28588   Dali::LinearConstrainer::Property *result = 0 ;
28589
28590   {
28591     try {
28592       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
28593     } CALL_CATCH_EXCEPTION(0);
28594   }
28595
28596   jresult = (void *)result;
28597   return jresult;
28598 }
28599
28600
28601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
28602   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
28603
28604   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
28605   {
28606     try {
28607       delete arg1;
28608     } CALL_CATCH_EXCEPTION();
28609   }
28610
28611 }
28612
28613
28614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
28615   void * jresult ;
28616   Dali::LinearConstrainer result;
28617
28618   {
28619     try {
28620       result = Dali::LinearConstrainer::New();
28621     } CALL_CATCH_EXCEPTION(0);
28622   }
28623
28624   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
28625   return jresult;
28626 }
28627
28628
28629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
28630   void * jresult ;
28631   Dali::BaseHandle arg1 ;
28632   Dali::BaseHandle *argp1 ;
28633   Dali::LinearConstrainer result;
28634
28635   argp1 = (Dali::BaseHandle *)jarg1;
28636   if (!argp1) {
28637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28638     return 0;
28639   }
28640   arg1 = *argp1;
28641   {
28642     try {
28643       result = Dali::LinearConstrainer::DownCast(arg1);
28644     } CALL_CATCH_EXCEPTION(0);
28645   }
28646
28647   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
28648   return jresult;
28649 }
28650
28651
28652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
28653   void * jresult ;
28654   Dali::LinearConstrainer *result = 0 ;
28655
28656   {
28657     try {
28658       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
28659     } CALL_CATCH_EXCEPTION(0);
28660   }
28661
28662   jresult = (void *)result;
28663   return jresult;
28664 }
28665
28666
28667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
28668   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
28669
28670   arg1 = (Dali::LinearConstrainer *)jarg1;
28671   {
28672     try {
28673       delete arg1;
28674     } CALL_CATCH_EXCEPTION();
28675   }
28676
28677 }
28678
28679
28680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
28681   void * jresult ;
28682   Dali::LinearConstrainer *arg1 = 0 ;
28683   Dali::LinearConstrainer *result = 0 ;
28684
28685   arg1 = (Dali::LinearConstrainer *)jarg1;
28686   if (!arg1) {
28687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
28688     return 0;
28689   }
28690   {
28691     try {
28692       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
28693     } CALL_CATCH_EXCEPTION(0);
28694   }
28695
28696   jresult = (void *)result;
28697   return jresult;
28698 }
28699
28700
28701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
28702   void * jresult ;
28703   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
28704   Dali::LinearConstrainer *arg2 = 0 ;
28705   Dali::LinearConstrainer *result = 0 ;
28706
28707   arg1 = (Dali::LinearConstrainer *)jarg1;
28708   arg2 = (Dali::LinearConstrainer *)jarg2;
28709   if (!arg2) {
28710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
28711     return 0;
28712   }
28713   {
28714     try {
28715       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
28716     } CALL_CATCH_EXCEPTION(0);
28717   }
28718
28719   jresult = (void *)result;
28720   return jresult;
28721 }
28722
28723
28724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
28725   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
28726   SwigValueWrapper< Dali::Property > arg2 ;
28727   SwigValueWrapper< Dali::Property > arg3 ;
28728   Dali::Vector2 *arg4 = 0 ;
28729   Dali::Vector2 *arg5 = 0 ;
28730   Dali::Property *argp2 ;
28731   Dali::Property *argp3 ;
28732
28733   arg1 = (Dali::LinearConstrainer *)jarg1;
28734   argp2 = (Dali::Property *)jarg2;
28735   if (!argp2) {
28736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
28737     return ;
28738   }
28739   arg2 = *argp2;
28740   argp3 = (Dali::Property *)jarg3;
28741   if (!argp3) {
28742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
28743     return ;
28744   }
28745   arg3 = *argp3;
28746   arg4 = (Dali::Vector2 *)jarg4;
28747   if (!arg4) {
28748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
28749     return ;
28750   }
28751   arg5 = (Dali::Vector2 *)jarg5;
28752   if (!arg5) {
28753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
28754     return ;
28755   }
28756   {
28757     try {
28758       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
28759     } CALL_CATCH_EXCEPTION();
28760   }
28761
28762 }
28763
28764
28765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
28766   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
28767   SwigValueWrapper< Dali::Property > arg2 ;
28768   SwigValueWrapper< Dali::Property > arg3 ;
28769   Dali::Vector2 *arg4 = 0 ;
28770   Dali::Property *argp2 ;
28771   Dali::Property *argp3 ;
28772
28773   arg1 = (Dali::LinearConstrainer *)jarg1;
28774   argp2 = (Dali::Property *)jarg2;
28775   if (!argp2) {
28776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
28777     return ;
28778   }
28779   arg2 = *argp2;
28780   argp3 = (Dali::Property *)jarg3;
28781   if (!argp3) {
28782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
28783     return ;
28784   }
28785   arg3 = *argp3;
28786   arg4 = (Dali::Vector2 *)jarg4;
28787   if (!arg4) {
28788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
28789     return ;
28790   }
28791   {
28792     try {
28793       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
28794     } CALL_CATCH_EXCEPTION();
28795   }
28796
28797 }
28798
28799
28800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
28801   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
28802   Dali::Handle *arg2 = 0 ;
28803
28804   arg1 = (Dali::LinearConstrainer *)jarg1;
28805   arg2 = (Dali::Handle *)jarg2;
28806   if (!arg2) {
28807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
28808     return ;
28809   }
28810   {
28811     try {
28812       (arg1)->Remove(*arg2);
28813     } CALL_CATCH_EXCEPTION();
28814   }
28815
28816 }
28817
28818
28819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
28820   int jresult ;
28821   int result;
28822
28823   result = (int)Dali::PathConstrainer::Property::FORWARD;
28824   jresult = (int)result;
28825   return jresult;
28826 }
28827
28828
28829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
28830   int jresult ;
28831   int result;
28832
28833   result = (int)Dali::PathConstrainer::Property::POINTS;
28834   jresult = (int)result;
28835   return jresult;
28836 }
28837
28838
28839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
28840   int jresult ;
28841   int result;
28842
28843   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
28844   jresult = (int)result;
28845   return jresult;
28846 }
28847
28848
28849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
28850   void * jresult ;
28851   Dali::PathConstrainer::Property *result = 0 ;
28852
28853   {
28854     try {
28855       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
28856     } CALL_CATCH_EXCEPTION(0);
28857   }
28858
28859   jresult = (void *)result;
28860   return jresult;
28861 }
28862
28863
28864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
28865   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
28866
28867   arg1 = (Dali::PathConstrainer::Property *)jarg1;
28868   {
28869     try {
28870       delete arg1;
28871     } CALL_CATCH_EXCEPTION();
28872   }
28873
28874 }
28875
28876
28877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
28878   void * jresult ;
28879   Dali::PathConstrainer result;
28880
28881   {
28882     try {
28883       result = Dali::PathConstrainer::New();
28884     } CALL_CATCH_EXCEPTION(0);
28885   }
28886
28887   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
28888   return jresult;
28889 }
28890
28891
28892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
28893   void * jresult ;
28894   Dali::BaseHandle arg1 ;
28895   Dali::BaseHandle *argp1 ;
28896   Dali::PathConstrainer result;
28897
28898   argp1 = (Dali::BaseHandle *)jarg1;
28899   if (!argp1) {
28900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28901     return 0;
28902   }
28903   arg1 = *argp1;
28904   {
28905     try {
28906       result = Dali::PathConstrainer::DownCast(arg1);
28907     } CALL_CATCH_EXCEPTION(0);
28908   }
28909
28910   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
28911   return jresult;
28912 }
28913
28914
28915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
28916   void * jresult ;
28917   Dali::PathConstrainer *result = 0 ;
28918
28919   {
28920     try {
28921       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
28922     } CALL_CATCH_EXCEPTION(0);
28923   }
28924
28925   jresult = (void *)result;
28926   return jresult;
28927 }
28928
28929
28930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
28931   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
28932
28933   arg1 = (Dali::PathConstrainer *)jarg1;
28934   {
28935     try {
28936       delete arg1;
28937     } CALL_CATCH_EXCEPTION();
28938   }
28939
28940 }
28941
28942
28943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
28944   void * jresult ;
28945   Dali::PathConstrainer *arg1 = 0 ;
28946   Dali::PathConstrainer *result = 0 ;
28947
28948   arg1 = (Dali::PathConstrainer *)jarg1;
28949   if (!arg1) {
28950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
28951     return 0;
28952   }
28953   {
28954     try {
28955       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
28956     } CALL_CATCH_EXCEPTION(0);
28957   }
28958
28959   jresult = (void *)result;
28960   return jresult;
28961 }
28962
28963
28964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
28965   void * jresult ;
28966   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
28967   Dali::PathConstrainer *arg2 = 0 ;
28968   Dali::PathConstrainer *result = 0 ;
28969
28970   arg1 = (Dali::PathConstrainer *)jarg1;
28971   arg2 = (Dali::PathConstrainer *)jarg2;
28972   if (!arg2) {
28973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
28974     return 0;
28975   }
28976   {
28977     try {
28978       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
28979     } CALL_CATCH_EXCEPTION(0);
28980   }
28981
28982   jresult = (void *)result;
28983   return jresult;
28984 }
28985
28986
28987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
28988   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
28989   SwigValueWrapper< Dali::Property > arg2 ;
28990   SwigValueWrapper< Dali::Property > arg3 ;
28991   Dali::Vector2 *arg4 = 0 ;
28992   Dali::Vector2 *arg5 = 0 ;
28993   Dali::Property *argp2 ;
28994   Dali::Property *argp3 ;
28995
28996   arg1 = (Dali::PathConstrainer *)jarg1;
28997   argp2 = (Dali::Property *)jarg2;
28998   if (!argp2) {
28999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
29000     return ;
29001   }
29002   arg2 = *argp2;
29003   argp3 = (Dali::Property *)jarg3;
29004   if (!argp3) {
29005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
29006     return ;
29007   }
29008   arg3 = *argp3;
29009   arg4 = (Dali::Vector2 *)jarg4;
29010   if (!arg4) {
29011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29012     return ;
29013   }
29014   arg5 = (Dali::Vector2 *)jarg5;
29015   if (!arg5) {
29016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29017     return ;
29018   }
29019   {
29020     try {
29021       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
29022     } CALL_CATCH_EXCEPTION();
29023   }
29024
29025 }
29026
29027
29028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
29029   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
29030   SwigValueWrapper< Dali::Property > arg2 ;
29031   SwigValueWrapper< Dali::Property > arg3 ;
29032   Dali::Vector2 *arg4 = 0 ;
29033   Dali::Property *argp2 ;
29034   Dali::Property *argp3 ;
29035
29036   arg1 = (Dali::PathConstrainer *)jarg1;
29037   argp2 = (Dali::Property *)jarg2;
29038   if (!argp2) {
29039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
29040     return ;
29041   }
29042   arg2 = *argp2;
29043   argp3 = (Dali::Property *)jarg3;
29044   if (!argp3) {
29045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
29046     return ;
29047   }
29048   arg3 = *argp3;
29049   arg4 = (Dali::Vector2 *)jarg4;
29050   if (!arg4) {
29051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29052     return ;
29053   }
29054   {
29055     try {
29056       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
29057     } CALL_CATCH_EXCEPTION();
29058   }
29059
29060 }
29061
29062
29063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
29064   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
29065   Dali::Handle *arg2 = 0 ;
29066
29067   arg1 = (Dali::PathConstrainer *)jarg1;
29068   arg2 = (Dali::Handle *)jarg2;
29069   if (!arg2) {
29070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
29071     return ;
29072   }
29073   {
29074     try {
29075       (arg1)->Remove(*arg2);
29076     } CALL_CATCH_EXCEPTION();
29077   }
29078
29079 }
29080
29081
29082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
29083   int jresult ;
29084   Dali::FittingMode::Type result;
29085
29086   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
29087   jresult = (int)result;
29088   return jresult;
29089 }
29090
29091
29092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
29093   int jresult ;
29094   Dali::SamplingMode::Type result;
29095
29096   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
29097   jresult = (int)result;
29098   return jresult;
29099 }
29100
29101
29102 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageInterface_CreateResource(void * jarg1) {
29103   bool jresult ;
29104   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
29105   bool result;
29106
29107   arg1 = (Dali::NativeImageInterface *)jarg1;
29108   {
29109     try {
29110       result = (bool)(arg1)->CreateResource();
29111     } CALL_CATCH_EXCEPTION(0);
29112   }
29113
29114   jresult = result;
29115   return jresult;
29116 }
29117
29118
29119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_DestroyResource(void * jarg1) {
29120   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
29121
29122   arg1 = (Dali::NativeImageInterface *)jarg1;
29123   {
29124     try {
29125       (arg1)->DestroyResource();
29126     } CALL_CATCH_EXCEPTION();
29127   }
29128
29129 }
29130
29131
29132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
29133   unsigned int jresult ;
29134   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
29135   unsigned int result;
29136
29137   arg1 = (Dali::NativeImageInterface *)jarg1;
29138   {
29139     try {
29140       result = (unsigned int)(arg1)->TargetTexture();
29141     } CALL_CATCH_EXCEPTION(0);
29142   }
29143
29144   jresult = result;
29145   return jresult;
29146 }
29147
29148
29149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
29150   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
29151
29152   arg1 = (Dali::NativeImageInterface *)jarg1;
29153   {
29154     try {
29155       (arg1)->PrepareTexture();
29156     } CALL_CATCH_EXCEPTION();
29157   }
29158
29159 }
29160
29161
29162 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
29163   unsigned int jresult ;
29164   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
29165   unsigned int result;
29166
29167   arg1 = (Dali::NativeImageInterface *)jarg1;
29168   {
29169     try {
29170       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
29171     } CALL_CATCH_EXCEPTION(0);
29172   }
29173
29174   jresult = result;
29175   return jresult;
29176 }
29177
29178
29179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
29180   unsigned int jresult ;
29181   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
29182   unsigned int result;
29183
29184   arg1 = (Dali::NativeImageInterface *)jarg1;
29185   {
29186     try {
29187       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
29188     } CALL_CATCH_EXCEPTION(0);
29189   }
29190
29191   jresult = result;
29192   return jresult;
29193 }
29194
29195
29196 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
29197   bool jresult ;
29198   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
29199   bool result;
29200
29201   arg1 = (Dali::NativeImageInterface *)jarg1;
29202   {
29203     try {
29204       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
29205     } CALL_CATCH_EXCEPTION(0);
29206   }
29207
29208   jresult = result;
29209   return jresult;
29210 }
29211
29212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
29213   int jresult ;
29214   int result;
29215
29216   result = (int)Dali::CameraActor::Property::TYPE;
29217   jresult = (int)result;
29218   return jresult;
29219 }
29220
29221
29222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
29223   int jresult ;
29224   int result;
29225
29226   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
29227   jresult = (int)result;
29228   return jresult;
29229 }
29230
29231
29232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
29233   int jresult ;
29234   int result;
29235
29236   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
29237   jresult = (int)result;
29238   return jresult;
29239 }
29240
29241
29242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
29243   int jresult ;
29244   int result;
29245
29246   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
29247   jresult = (int)result;
29248   return jresult;
29249 }
29250
29251
29252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
29253   int jresult ;
29254   int result;
29255
29256   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
29257   jresult = (int)result;
29258   return jresult;
29259 }
29260
29261
29262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
29263   int jresult ;
29264   int result;
29265
29266   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
29267   jresult = (int)result;
29268   return jresult;
29269 }
29270
29271
29272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
29273   int jresult ;
29274   int result;
29275
29276   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
29277   jresult = (int)result;
29278   return jresult;
29279 }
29280
29281
29282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
29283   int jresult ;
29284   int result;
29285
29286   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
29287   jresult = (int)result;
29288   return jresult;
29289 }
29290
29291
29292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
29293   int jresult ;
29294   int result;
29295
29296   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
29297   jresult = (int)result;
29298   return jresult;
29299 }
29300
29301
29302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
29303   int jresult ;
29304   int result;
29305
29306   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
29307   jresult = (int)result;
29308   return jresult;
29309 }
29310
29311
29312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
29313   int jresult ;
29314   int result;
29315
29316   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
29317   jresult = (int)result;
29318   return jresult;
29319 }
29320
29321
29322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
29323   int jresult ;
29324   int result;
29325
29326   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
29327   jresult = (int)result;
29328   return jresult;
29329 }
29330
29331
29332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
29333   int jresult ;
29334   int result;
29335
29336   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
29337   jresult = (int)result;
29338   return jresult;
29339 }
29340
29341
29342 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
29343   int jresult ;
29344   int result;
29345
29346   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
29347   jresult = (int)result;
29348   return jresult;
29349 }
29350
29351
29352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
29353   void * jresult ;
29354   Dali::CameraActor::Property *result = 0 ;
29355
29356   {
29357     try {
29358       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
29359     } CALL_CATCH_EXCEPTION(0);
29360   }
29361
29362   jresult = (void *)result;
29363   return jresult;
29364 }
29365
29366
29367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
29368   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
29369
29370   arg1 = (Dali::CameraActor::Property *)jarg1;
29371   {
29372     try {
29373       delete arg1;
29374     } CALL_CATCH_EXCEPTION();
29375   }
29376
29377 }
29378
29379
29380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
29381   void * jresult ;
29382   Dali::CameraActor *result = 0 ;
29383
29384   {
29385     try {
29386       result = (Dali::CameraActor *)new Dali::CameraActor();
29387     } CALL_CATCH_EXCEPTION(0);
29388   }
29389
29390   jresult = (void *)result;
29391   return jresult;
29392 }
29393
29394
29395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
29396   void * jresult ;
29397   Dali::CameraActor result;
29398
29399   {
29400     try {
29401       result = Dali::CameraActor::New();
29402     } CALL_CATCH_EXCEPTION(0);
29403   }
29404
29405   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
29406   return jresult;
29407 }
29408
29409
29410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
29411   void * jresult ;
29412   Dali::Size *arg1 = 0 ;
29413   Dali::CameraActor result;
29414
29415   arg1 = (Dali::Size *)jarg1;
29416   if (!arg1) {
29417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
29418     return 0;
29419   }
29420   {
29421     try {
29422       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
29423     } CALL_CATCH_EXCEPTION(0);
29424   }
29425
29426   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
29427   return jresult;
29428 }
29429
29430
29431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
29432   void * jresult ;
29433   Dali::BaseHandle arg1 ;
29434   Dali::BaseHandle *argp1 ;
29435   Dali::CameraActor result;
29436
29437   argp1 = (Dali::BaseHandle *)jarg1;
29438   if (!argp1) {
29439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29440     return 0;
29441   }
29442   arg1 = *argp1;
29443   {
29444     try {
29445       result = Dali::CameraActor::DownCast(arg1);
29446     } CALL_CATCH_EXCEPTION(0);
29447   }
29448
29449   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
29450   return jresult;
29451 }
29452
29453
29454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
29455   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29456
29457   arg1 = (Dali::CameraActor *)jarg1;
29458   {
29459     try {
29460       delete arg1;
29461     } CALL_CATCH_EXCEPTION();
29462   }
29463
29464 }
29465
29466
29467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
29468   void * jresult ;
29469   Dali::CameraActor *arg1 = 0 ;
29470   Dali::CameraActor *result = 0 ;
29471
29472   arg1 = (Dali::CameraActor *)jarg1;
29473   if (!arg1) {
29474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
29475     return 0;
29476   }
29477   {
29478     try {
29479       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
29480     } CALL_CATCH_EXCEPTION(0);
29481   }
29482
29483   jresult = (void *)result;
29484   return jresult;
29485 }
29486
29487
29488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
29489   void * jresult ;
29490   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29491   Dali::CameraActor *arg2 = 0 ;
29492   Dali::CameraActor *result = 0 ;
29493
29494   arg1 = (Dali::CameraActor *)jarg1;
29495   arg2 = (Dali::CameraActor *)jarg2;
29496   if (!arg2) {
29497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
29498     return 0;
29499   }
29500   {
29501     try {
29502       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
29503     } CALL_CATCH_EXCEPTION(0);
29504   }
29505
29506   jresult = (void *)result;
29507   return jresult;
29508 }
29509
29510
29511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
29512   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29513   Dali::Camera::Type arg2 ;
29514
29515   arg1 = (Dali::CameraActor *)jarg1;
29516   arg2 = (Dali::Camera::Type)jarg2;
29517   {
29518     try {
29519       (arg1)->SetType(arg2);
29520     } CALL_CATCH_EXCEPTION();
29521   }
29522
29523 }
29524
29525
29526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
29527   int jresult ;
29528   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29529   Dali::Camera::Type result;
29530
29531   arg1 = (Dali::CameraActor *)jarg1;
29532   {
29533     try {
29534       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
29535     } CALL_CATCH_EXCEPTION(0);
29536   }
29537
29538   jresult = (int)result;
29539   return jresult;
29540 }
29541
29542
29543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
29544   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29545   Dali::Camera::ProjectionMode arg2 ;
29546
29547   arg1 = (Dali::CameraActor *)jarg1;
29548   arg2 = (Dali::Camera::ProjectionMode)jarg2;
29549   {
29550     try {
29551       (arg1)->SetProjectionMode(arg2);
29552     } CALL_CATCH_EXCEPTION();
29553   }
29554
29555 }
29556
29557
29558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
29559   int jresult ;
29560   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29561   Dali::Camera::ProjectionMode result;
29562
29563   arg1 = (Dali::CameraActor *)jarg1;
29564   {
29565     try {
29566       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
29567     } CALL_CATCH_EXCEPTION(0);
29568   }
29569
29570   jresult = (int)result;
29571   return jresult;
29572 }
29573
29574
29575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
29576   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29577   float arg2 ;
29578
29579   arg1 = (Dali::CameraActor *)jarg1;
29580   arg2 = (float)jarg2;
29581   {
29582     try {
29583       (arg1)->SetFieldOfView(arg2);
29584     } CALL_CATCH_EXCEPTION();
29585   }
29586
29587 }
29588
29589
29590 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
29591   float jresult ;
29592   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29593   float result;
29594
29595   arg1 = (Dali::CameraActor *)jarg1;
29596   {
29597     try {
29598       result = (float)(arg1)->GetFieldOfView();
29599     } CALL_CATCH_EXCEPTION(0);
29600   }
29601
29602   jresult = result;
29603   return jresult;
29604 }
29605
29606
29607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
29608   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29609   float arg2 ;
29610
29611   arg1 = (Dali::CameraActor *)jarg1;
29612   arg2 = (float)jarg2;
29613   {
29614     try {
29615       (arg1)->SetAspectRatio(arg2);
29616     } CALL_CATCH_EXCEPTION();
29617   }
29618
29619 }
29620
29621
29622 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
29623   float jresult ;
29624   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29625   float result;
29626
29627   arg1 = (Dali::CameraActor *)jarg1;
29628   {
29629     try {
29630       result = (float)(arg1)->GetAspectRatio();
29631     } CALL_CATCH_EXCEPTION(0);
29632   }
29633
29634   jresult = result;
29635   return jresult;
29636 }
29637
29638
29639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
29640   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29641   float arg2 ;
29642
29643   arg1 = (Dali::CameraActor *)jarg1;
29644   arg2 = (float)jarg2;
29645   {
29646     try {
29647       (arg1)->SetNearClippingPlane(arg2);
29648     } CALL_CATCH_EXCEPTION();
29649   }
29650
29651 }
29652
29653
29654 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
29655   float jresult ;
29656   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29657   float result;
29658
29659   arg1 = (Dali::CameraActor *)jarg1;
29660   {
29661     try {
29662       result = (float)(arg1)->GetNearClippingPlane();
29663     } CALL_CATCH_EXCEPTION(0);
29664   }
29665
29666   jresult = result;
29667   return jresult;
29668 }
29669
29670
29671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
29672   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29673   float arg2 ;
29674
29675   arg1 = (Dali::CameraActor *)jarg1;
29676   arg2 = (float)jarg2;
29677   {
29678     try {
29679       (arg1)->SetFarClippingPlane(arg2);
29680     } CALL_CATCH_EXCEPTION();
29681   }
29682
29683 }
29684
29685
29686 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
29687   float jresult ;
29688   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29689   float result;
29690
29691   arg1 = (Dali::CameraActor *)jarg1;
29692   {
29693     try {
29694       result = (float)(arg1)->GetFarClippingPlane();
29695     } CALL_CATCH_EXCEPTION(0);
29696   }
29697
29698   jresult = result;
29699   return jresult;
29700 }
29701
29702
29703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
29704   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29705   Dali::Vector3 *arg2 = 0 ;
29706
29707   arg1 = (Dali::CameraActor *)jarg1;
29708   arg2 = (Dali::Vector3 *)jarg2;
29709   if (!arg2) {
29710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29711     return ;
29712   }
29713   {
29714     try {
29715       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
29716     } CALL_CATCH_EXCEPTION();
29717   }
29718
29719 }
29720
29721
29722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
29723   void * jresult ;
29724   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29725   Dali::Vector3 result;
29726
29727   arg1 = (Dali::CameraActor *)jarg1;
29728   {
29729     try {
29730       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
29731     } CALL_CATCH_EXCEPTION(0);
29732   }
29733
29734   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29735   return jresult;
29736 }
29737
29738
29739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, bool jarg2) {
29740   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29741   bool arg2 ;
29742
29743   arg1 = (Dali::CameraActor *)jarg1;
29744   arg2 = jarg2 ? true : false;
29745   {
29746     try {
29747       (arg1)->SetInvertYAxis(arg2);
29748     } CALL_CATCH_EXCEPTION();
29749   }
29750
29751 }
29752
29753
29754 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
29755   bool jresult ;
29756   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29757   bool result;
29758
29759   arg1 = (Dali::CameraActor *)jarg1;
29760   {
29761     try {
29762       result = (bool)(arg1)->GetInvertYAxis();
29763     } CALL_CATCH_EXCEPTION(0);
29764   }
29765
29766   jresult = result;
29767   return jresult;
29768 }
29769
29770
29771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
29772   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29773   Dali::Size *arg2 = 0 ;
29774
29775   arg1 = (Dali::CameraActor *)jarg1;
29776   arg2 = (Dali::Size *)jarg2;
29777   if (!arg2) {
29778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
29779     return ;
29780   }
29781   {
29782     try {
29783       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
29784     } CALL_CATCH_EXCEPTION();
29785   }
29786
29787 }
29788
29789
29790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
29791   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29792   Dali::Size *arg2 = 0 ;
29793
29794   arg1 = (Dali::CameraActor *)jarg1;
29795   arg2 = (Dali::Size *)jarg2;
29796   if (!arg2) {
29797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
29798     return ;
29799   }
29800   {
29801     try {
29802       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
29803     } CALL_CATCH_EXCEPTION();
29804   }
29805
29806 }
29807
29808
29809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
29810   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29811   float arg2 ;
29812   float arg3 ;
29813   float arg4 ;
29814   float arg5 ;
29815   float arg6 ;
29816   float arg7 ;
29817
29818   arg1 = (Dali::CameraActor *)jarg1;
29819   arg2 = (float)jarg2;
29820   arg3 = (float)jarg3;
29821   arg4 = (float)jarg4;
29822   arg5 = (float)jarg5;
29823   arg6 = (float)jarg6;
29824   arg7 = (float)jarg7;
29825   {
29826     try {
29827       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
29828     } CALL_CATCH_EXCEPTION();
29829   }
29830
29831 }
29832
29833
29834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
29835   void * jresult ;
29836   std::pair< std::string,Dali::Property::Value > *result = 0 ;
29837
29838   {
29839     try {
29840       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
29841     } CALL_CATCH_EXCEPTION(0);
29842   }
29843
29844   jresult = (void *)result;
29845   return jresult;
29846 }
29847
29848
29849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
29850   void * jresult ;
29851   std::string arg1 ;
29852   Dali::Property::Value arg2 ;
29853   Dali::Property::Value *argp2 ;
29854   std::pair< std::string,Dali::Property::Value > *result = 0 ;
29855
29856   if (!jarg1) {
29857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29858     return 0;
29859   }
29860   (&arg1)->assign(jarg1);
29861   argp2 = (Dali::Property::Value *)jarg2;
29862   if (!argp2) {
29863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
29864     return 0;
29865   }
29866   arg2 = *argp2;
29867   {
29868     try {
29869       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
29870     } CALL_CATCH_EXCEPTION(0);
29871   }
29872
29873   jresult = (void *)result;
29874   return jresult;
29875 }
29876
29877
29878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
29879   void * jresult ;
29880   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
29881   std::pair< std::string,Dali::Property::Value > *result = 0 ;
29882
29883   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
29884   if (!arg1) {
29885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
29886     return 0;
29887   }
29888   {
29889     try {
29890       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);
29891     } CALL_CATCH_EXCEPTION(0);
29892   }
29893
29894   jresult = (void *)result;
29895   return jresult;
29896 }
29897
29898
29899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
29900   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
29901   std::string *arg2 = 0 ;
29902
29903   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
29904   if (!jarg2) {
29905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29906     return ;
29907   }
29908   std::string arg2_str(jarg2);
29909   arg2 = &arg2_str;
29910   if (arg1) (arg1)->first = *arg2;
29911
29912   //argout typemap for const std::string&
29913
29914 }
29915
29916
29917 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
29918   char * jresult ;
29919   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
29920   std::string *result = 0 ;
29921
29922   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
29923   result = (std::string *) & ((arg1)->first);
29924   jresult = SWIG_csharp_string_callback(result->c_str());
29925   return jresult;
29926 }
29927
29928
29929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
29930   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
29931   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
29932
29933   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
29934   arg2 = (Dali::Property::Value *)jarg2;
29935   if (arg1) (arg1)->second = *arg2;
29936 }
29937
29938
29939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
29940   void * jresult ;
29941   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
29942   Dali::Property::Value *result = 0 ;
29943
29944   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
29945   result = (Dali::Property::Value *)& ((arg1)->second);
29946   jresult = (void *)result;
29947   return jresult;
29948 }
29949
29950
29951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
29952   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
29953
29954   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
29955   {
29956     try {
29957       delete arg1;
29958     } CALL_CATCH_EXCEPTION();
29959   }
29960
29961 }
29962
29963
29964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
29965   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29966
29967   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29968   {
29969     try {
29970       (arg1)->clear();
29971     } CALL_CATCH_EXCEPTION();
29972   }
29973
29974 }
29975
29976
29977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
29978   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29979   Dali::TouchPoint *arg2 = 0 ;
29980
29981   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29982   arg2 = (Dali::TouchPoint *)jarg2;
29983   if (!arg2) {
29984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
29985     return ;
29986   }
29987   {
29988     try {
29989       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
29990     } CALL_CATCH_EXCEPTION();
29991   }
29992
29993 }
29994
29995
29996 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
29997   unsigned long jresult ;
29998   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29999   std::vector< Dali::TouchPoint >::size_type result;
30000
30001   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30002   {
30003     try {
30004       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
30005     } CALL_CATCH_EXCEPTION(0);
30006   }
30007
30008   jresult = (unsigned long)result;
30009   return jresult;
30010 }
30011
30012
30013 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
30014   unsigned long jresult ;
30015   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30016   std::vector< Dali::TouchPoint >::size_type result;
30017
30018   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30019   {
30020     try {
30021       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
30022     } CALL_CATCH_EXCEPTION(0);
30023   }
30024
30025   jresult = (unsigned long)result;
30026   return jresult;
30027 }
30028
30029
30030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
30031   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30032   std::vector< Dali::TouchPoint >::size_type arg2 ;
30033
30034   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30035   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
30036   {
30037     try {
30038       (arg1)->reserve(arg2);
30039     } CALL_CATCH_EXCEPTION();
30040   }
30041
30042 }
30043
30044
30045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
30046   void * jresult ;
30047   std::vector< Dali::TouchPoint > *result = 0 ;
30048
30049   {
30050     try {
30051       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
30052     } CALL_CATCH_EXCEPTION(0);
30053   }
30054
30055   jresult = (void *)result;
30056   return jresult;
30057 }
30058
30059
30060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
30061   void * jresult ;
30062   std::vector< Dali::TouchPoint > *arg1 = 0 ;
30063   std::vector< Dali::TouchPoint > *result = 0 ;
30064
30065   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30066   if (!arg1) {
30067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
30068     return 0;
30069   }
30070   {
30071     try {
30072       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
30073     } CALL_CATCH_EXCEPTION(0);
30074   }
30075
30076   jresult = (void *)result;
30077   return jresult;
30078 }
30079
30080
30081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
30082   void * jresult ;
30083   int arg1 ;
30084   std::vector< Dali::TouchPoint > *result = 0 ;
30085
30086   arg1 = (int)jarg1;
30087   {
30088     try {
30089       try {
30090         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
30091       }
30092       catch(std::out_of_range &_e) {
30093         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
30094         return 0;
30095       }
30096
30097     } CALL_CATCH_EXCEPTION(0);
30098   }
30099
30100   jresult = (void *)result;
30101   return jresult;
30102 }
30103
30104
30105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
30106   void * jresult ;
30107   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30108   int arg2 ;
30109   SwigValueWrapper< Dali::TouchPoint > result;
30110
30111   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30112   arg2 = (int)jarg2;
30113   {
30114     try {
30115       try {
30116         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
30117       }
30118       catch(std::out_of_range &_e) {
30119         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
30120         return 0;
30121       }
30122
30123     } CALL_CATCH_EXCEPTION(0);
30124   }
30125
30126   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
30127   return jresult;
30128 }
30129
30130
30131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
30132   void * jresult ;
30133   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30134   int arg2 ;
30135   Dali::TouchPoint *result = 0 ;
30136
30137   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30138   arg2 = (int)jarg2;
30139   {
30140     try {
30141       try {
30142         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
30143       }
30144       catch(std::out_of_range &_e) {
30145         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
30146         return 0;
30147       }
30148
30149     } CALL_CATCH_EXCEPTION(0);
30150   }
30151
30152   jresult = (void *)result;
30153   return jresult;
30154 }
30155
30156
30157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
30158   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30159   int arg2 ;
30160   Dali::TouchPoint *arg3 = 0 ;
30161
30162   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30163   arg2 = (int)jarg2;
30164   arg3 = (Dali::TouchPoint *)jarg3;
30165   if (!arg3) {
30166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
30167     return ;
30168   }
30169   {
30170     try {
30171       try {
30172         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
30173       }
30174       catch(std::out_of_range &_e) {
30175         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
30176         return ;
30177       }
30178
30179     } CALL_CATCH_EXCEPTION();
30180   }
30181
30182 }
30183
30184
30185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
30186   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30187   std::vector< Dali::TouchPoint > *arg2 = 0 ;
30188
30189   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30190   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
30191   if (!arg2) {
30192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
30193     return ;
30194   }
30195   {
30196     try {
30197       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
30198     } CALL_CATCH_EXCEPTION();
30199   }
30200
30201 }
30202
30203
30204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
30205   void * jresult ;
30206   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30207   int arg2 ;
30208   int arg3 ;
30209   std::vector< Dali::TouchPoint > *result = 0 ;
30210
30211   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30212   arg2 = (int)jarg2;
30213   arg3 = (int)jarg3;
30214   {
30215     try {
30216       try {
30217         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
30218       }
30219       catch(std::out_of_range &_e) {
30220         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
30221         return 0;
30222       }
30223       catch(std::invalid_argument &_e) {
30224         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
30225         return 0;
30226       }
30227
30228     } CALL_CATCH_EXCEPTION(0);
30229   }
30230
30231   jresult = (void *)result;
30232   return jresult;
30233 }
30234
30235
30236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
30237   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30238   int arg2 ;
30239   Dali::TouchPoint *arg3 = 0 ;
30240
30241   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30242   arg2 = (int)jarg2;
30243   arg3 = (Dali::TouchPoint *)jarg3;
30244   if (!arg3) {
30245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
30246     return ;
30247   }
30248   {
30249     try {
30250       try {
30251         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
30252       }
30253       catch(std::out_of_range &_e) {
30254         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
30255         return ;
30256       }
30257
30258     } CALL_CATCH_EXCEPTION();
30259   }
30260
30261 }
30262
30263
30264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
30265   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30266   int arg2 ;
30267   std::vector< Dali::TouchPoint > *arg3 = 0 ;
30268
30269   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30270   arg2 = (int)jarg2;
30271   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
30272   if (!arg3) {
30273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
30274     return ;
30275   }
30276   {
30277     try {
30278       try {
30279         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
30280       }
30281       catch(std::out_of_range &_e) {
30282         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
30283         return ;
30284       }
30285
30286     } CALL_CATCH_EXCEPTION();
30287   }
30288
30289 }
30290
30291
30292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
30293   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30294   int arg2 ;
30295
30296   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30297   arg2 = (int)jarg2;
30298   {
30299     try {
30300       try {
30301         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
30302       }
30303       catch(std::out_of_range &_e) {
30304         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
30305         return ;
30306       }
30307
30308     } CALL_CATCH_EXCEPTION();
30309   }
30310
30311 }
30312
30313
30314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
30315   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30316   int arg2 ;
30317   int arg3 ;
30318
30319   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30320   arg2 = (int)jarg2;
30321   arg3 = (int)jarg3;
30322   {
30323     try {
30324       try {
30325         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
30326       }
30327       catch(std::out_of_range &_e) {
30328         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
30329         return ;
30330       }
30331       catch(std::invalid_argument &_e) {
30332         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
30333         return ;
30334       }
30335
30336     } CALL_CATCH_EXCEPTION();
30337   }
30338
30339 }
30340
30341
30342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
30343   void * jresult ;
30344   Dali::TouchPoint *arg1 = 0 ;
30345   int arg2 ;
30346   std::vector< Dali::TouchPoint > *result = 0 ;
30347
30348   arg1 = (Dali::TouchPoint *)jarg1;
30349   if (!arg1) {
30350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
30351     return 0;
30352   }
30353   arg2 = (int)jarg2;
30354   {
30355     try {
30356       try {
30357         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
30358       }
30359       catch(std::out_of_range &_e) {
30360         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
30361         return 0;
30362       }
30363
30364     } CALL_CATCH_EXCEPTION(0);
30365   }
30366
30367   jresult = (void *)result;
30368   return jresult;
30369 }
30370
30371
30372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
30373   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30374
30375   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30376   {
30377     try {
30378       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
30379     } CALL_CATCH_EXCEPTION();
30380   }
30381
30382 }
30383
30384
30385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
30386   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30387   int arg2 ;
30388   int arg3 ;
30389
30390   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30391   arg2 = (int)jarg2;
30392   arg3 = (int)jarg3;
30393   {
30394     try {
30395       try {
30396         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
30397       }
30398       catch(std::out_of_range &_e) {
30399         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
30400         return ;
30401       }
30402       catch(std::invalid_argument &_e) {
30403         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
30404         return ;
30405       }
30406
30407     } CALL_CATCH_EXCEPTION();
30408   }
30409
30410 }
30411
30412
30413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
30414   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30415   int arg2 ;
30416   std::vector< Dali::TouchPoint > *arg3 = 0 ;
30417
30418   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30419   arg2 = (int)jarg2;
30420   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
30421   if (!arg3) {
30422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
30423     return ;
30424   }
30425   {
30426     try {
30427       try {
30428         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
30429       }
30430       catch(std::out_of_range &_e) {
30431         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
30432         return ;
30433       }
30434
30435     } CALL_CATCH_EXCEPTION();
30436   }
30437
30438 }
30439
30440
30441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
30442   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30443
30444   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30445   {
30446     try {
30447       delete arg1;
30448     } CALL_CATCH_EXCEPTION();
30449   }
30450
30451 }
30452
30453
30454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
30455   void * jresult ;
30456   Dali::Rect< int > *result = 0 ;
30457
30458   {
30459     try {
30460       result = (Dali::Rect< int > *)new Dali::Rect< int >();
30461     } CALL_CATCH_EXCEPTION(0);
30462   }
30463
30464   jresult = (void *)result;
30465   return jresult;
30466 }
30467
30468
30469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
30470   void * jresult ;
30471   int arg1 ;
30472   int arg2 ;
30473   int arg3 ;
30474   int arg4 ;
30475   Dali::Rect< int > *result = 0 ;
30476
30477   arg1 = (int)jarg1;
30478   arg2 = (int)jarg2;
30479   arg3 = (int)jarg3;
30480   arg4 = (int)jarg4;
30481   {
30482     try {
30483       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
30484     } CALL_CATCH_EXCEPTION(0);
30485   }
30486
30487   jresult = (void *)result;
30488   return jresult;
30489 }
30490
30491
30492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
30493   void * jresult ;
30494   Dali::Rect< int > *arg1 = 0 ;
30495   Dali::Rect< int > *result = 0 ;
30496
30497   arg1 = (Dali::Rect< int > *)jarg1;
30498   if (!arg1) {
30499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
30500     return 0;
30501   }
30502   {
30503     try {
30504       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
30505     } CALL_CATCH_EXCEPTION(0);
30506   }
30507
30508   jresult = (void *)result;
30509   return jresult;
30510 }
30511
30512
30513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
30514   void * jresult ;
30515   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30516   Dali::Rect< int > *arg2 = 0 ;
30517   Dali::Rect< int > *result = 0 ;
30518
30519   arg1 = (Dali::Rect< int > *)jarg1;
30520   arg2 = (Dali::Rect< int > *)jarg2;
30521   if (!arg2) {
30522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
30523     return 0;
30524   }
30525   {
30526     try {
30527       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
30528     } CALL_CATCH_EXCEPTION(0);
30529   }
30530
30531   jresult = (void *)result;
30532   return jresult;
30533 }
30534
30535
30536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
30537   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30538   int arg2 ;
30539   int arg3 ;
30540   int arg4 ;
30541   int arg5 ;
30542
30543   arg1 = (Dali::Rect< int > *)jarg1;
30544   arg2 = (int)jarg2;
30545   arg3 = (int)jarg3;
30546   arg4 = (int)jarg4;
30547   arg5 = (int)jarg5;
30548   {
30549     try {
30550       (arg1)->Set(arg2,arg3,arg4,arg5);
30551     } CALL_CATCH_EXCEPTION();
30552   }
30553
30554 }
30555
30556
30557 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
30558   bool jresult ;
30559   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30560   bool result;
30561
30562   arg1 = (Dali::Rect< int > *)jarg1;
30563   {
30564     try {
30565       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
30566     } CALL_CATCH_EXCEPTION(0);
30567   }
30568
30569   jresult = result;
30570   return jresult;
30571 }
30572
30573
30574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
30575   int jresult ;
30576   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30577   int result;
30578
30579   arg1 = (Dali::Rect< int > *)jarg1;
30580   {
30581     try {
30582       result = (int)((Dali::Rect< int > const *)arg1)->Left();
30583     } CALL_CATCH_EXCEPTION(0);
30584   }
30585
30586   jresult = result;
30587   return jresult;
30588 }
30589
30590
30591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
30592   int jresult ;
30593   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30594   int result;
30595
30596   arg1 = (Dali::Rect< int > *)jarg1;
30597   {
30598     try {
30599       result = (int)((Dali::Rect< int > const *)arg1)->Right();
30600     } CALL_CATCH_EXCEPTION(0);
30601   }
30602
30603   jresult = result;
30604   return jresult;
30605 }
30606
30607
30608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
30609   int jresult ;
30610   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30611   int result;
30612
30613   arg1 = (Dali::Rect< int > *)jarg1;
30614   {
30615     try {
30616       result = (int)((Dali::Rect< int > const *)arg1)->Top();
30617     } CALL_CATCH_EXCEPTION(0);
30618   }
30619
30620   jresult = result;
30621   return jresult;
30622 }
30623
30624
30625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
30626   int jresult ;
30627   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30628   int result;
30629
30630   arg1 = (Dali::Rect< int > *)jarg1;
30631   {
30632     try {
30633       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
30634     } CALL_CATCH_EXCEPTION(0);
30635   }
30636
30637   jresult = result;
30638   return jresult;
30639 }
30640
30641
30642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
30643   int jresult ;
30644   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30645   int result;
30646
30647   arg1 = (Dali::Rect< int > *)jarg1;
30648   {
30649     try {
30650       result = (int)((Dali::Rect< int > const *)arg1)->Area();
30651     } CALL_CATCH_EXCEPTION(0);
30652   }
30653
30654   jresult = result;
30655   return jresult;
30656 }
30657
30658
30659 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
30660   bool jresult ;
30661   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30662   Dali::Rect< int > *arg2 = 0 ;
30663   bool result;
30664
30665   arg1 = (Dali::Rect< int > *)jarg1;
30666   arg2 = (Dali::Rect< int > *)jarg2;
30667   if (!arg2) {
30668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
30669     return 0;
30670   }
30671   {
30672     try {
30673       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
30674     } CALL_CATCH_EXCEPTION(0);
30675   }
30676
30677   jresult = result;
30678   return jresult;
30679 }
30680
30681
30682 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
30683   bool jresult ;
30684   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30685   Dali::Rect< int > *arg2 = 0 ;
30686   bool result;
30687
30688   arg1 = (Dali::Rect< int > *)jarg1;
30689   arg2 = (Dali::Rect< int > *)jarg2;
30690   if (!arg2) {
30691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
30692     return 0;
30693   }
30694   {
30695     try {
30696       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
30697     } CALL_CATCH_EXCEPTION(0);
30698   }
30699
30700   jresult = result;
30701   return jresult;
30702 }
30703
30704
30705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
30706   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30707   int arg2 ;
30708
30709   arg1 = (Dali::Rect< int > *)jarg1;
30710   arg2 = (int)jarg2;
30711   if (arg1) (arg1)->x = arg2;
30712 }
30713
30714
30715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
30716   int jresult ;
30717   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30718   int result;
30719
30720   arg1 = (Dali::Rect< int > *)jarg1;
30721   result = (int) ((arg1)->x);
30722   jresult = result;
30723   return jresult;
30724 }
30725
30726
30727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
30728   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30729   int arg2 ;
30730
30731   arg1 = (Dali::Rect< int > *)jarg1;
30732   arg2 = (int)jarg2;
30733   if (arg1) (arg1)->left = arg2;
30734 }
30735
30736
30737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
30738   int jresult ;
30739   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30740   int result;
30741
30742   arg1 = (Dali::Rect< int > *)jarg1;
30743   result = (int) ((arg1)->left);
30744   jresult = result;
30745   return jresult;
30746 }
30747
30748
30749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
30750   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30751   int arg2 ;
30752
30753   arg1 = (Dali::Rect< int > *)jarg1;
30754   arg2 = (int)jarg2;
30755   if (arg1) (arg1)->y = arg2;
30756 }
30757
30758
30759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
30760   int jresult ;
30761   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30762   int result;
30763
30764   arg1 = (Dali::Rect< int > *)jarg1;
30765   result = (int) ((arg1)->y);
30766   jresult = result;
30767   return jresult;
30768 }
30769
30770
30771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
30772   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30773   int arg2 ;
30774
30775   arg1 = (Dali::Rect< int > *)jarg1;
30776   arg2 = (int)jarg2;
30777   if (arg1) (arg1)->right = arg2;
30778 }
30779
30780
30781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
30782   int jresult ;
30783   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30784   int result;
30785
30786   arg1 = (Dali::Rect< int > *)jarg1;
30787   result = (int) ((arg1)->right);
30788   jresult = result;
30789   return jresult;
30790 }
30791
30792
30793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
30794   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30795   int arg2 ;
30796
30797   arg1 = (Dali::Rect< int > *)jarg1;
30798   arg2 = (int)jarg2;
30799   if (arg1) (arg1)->width = arg2;
30800 }
30801
30802
30803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
30804   int jresult ;
30805   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30806   int result;
30807
30808   arg1 = (Dali::Rect< int > *)jarg1;
30809   result = (int) ((arg1)->width);
30810   jresult = result;
30811   return jresult;
30812 }
30813
30814
30815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
30816   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30817   int arg2 ;
30818
30819   arg1 = (Dali::Rect< int > *)jarg1;
30820   arg2 = (int)jarg2;
30821   if (arg1) (arg1)->bottom = arg2;
30822 }
30823
30824
30825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
30826   int jresult ;
30827   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30828   int result;
30829
30830   arg1 = (Dali::Rect< int > *)jarg1;
30831   result = (int) ((arg1)->bottom);
30832   jresult = result;
30833   return jresult;
30834 }
30835
30836
30837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
30838   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30839   int arg2 ;
30840
30841   arg1 = (Dali::Rect< int > *)jarg1;
30842   arg2 = (int)jarg2;
30843   if (arg1) (arg1)->height = arg2;
30844 }
30845
30846
30847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
30848   int jresult ;
30849   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30850   int result;
30851
30852   arg1 = (Dali::Rect< int > *)jarg1;
30853   result = (int) ((arg1)->height);
30854   jresult = result;
30855   return jresult;
30856 }
30857
30858
30859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
30860   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30861   int arg2 ;
30862
30863   arg1 = (Dali::Rect< int > *)jarg1;
30864   arg2 = (int)jarg2;
30865   if (arg1) (arg1)->top = arg2;
30866 }
30867
30868
30869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
30870   int jresult ;
30871   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30872   int result;
30873
30874   arg1 = (Dali::Rect< int > *)jarg1;
30875   result = (int) ((arg1)->top);
30876   jresult = result;
30877   return jresult;
30878 }
30879
30880
30881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
30882   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30883
30884   arg1 = (Dali::Rect< int > *)jarg1;
30885   {
30886     try {
30887       delete arg1;
30888     } CALL_CATCH_EXCEPTION();
30889   }
30890
30891 }
30892
30893
30894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
30895   void * jresult ;
30896   Dali::Rect< float > *result = 0 ;
30897
30898   {
30899     try {
30900       result = (Dali::Rect< float > *)new Dali::Rect< float >();
30901     } CALL_CATCH_EXCEPTION(0);
30902   }
30903
30904   jresult = (void *)result;
30905   return jresult;
30906 }
30907
30908
30909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
30910   void * jresult ;
30911   float arg1 ;
30912   float arg2 ;
30913   float arg3 ;
30914   float arg4 ;
30915   Dali::Rect< float > *result = 0 ;
30916
30917   arg1 = (float)jarg1;
30918   arg2 = (float)jarg2;
30919   arg3 = (float)jarg4;
30920   arg4 = (float)jarg3;
30921   {
30922     try {
30923       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
30924     } CALL_CATCH_EXCEPTION(0);
30925   }
30926
30927   jresult = (void *)result;
30928   return jresult;
30929 }
30930
30931
30932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
30933   void * jresult ;
30934   Dali::Rect< float > *arg1 = 0 ;
30935   Dali::Rect< float > *result = 0 ;
30936
30937   arg1 = (Dali::Rect< float > *)jarg1;
30938   if (!arg1) {
30939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
30940     return 0;
30941   }
30942   {
30943     try {
30944       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
30945     } CALL_CATCH_EXCEPTION(0);
30946   }
30947
30948   jresult = (void *)result;
30949   return jresult;
30950 }
30951
30952
30953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
30954   void * jresult ;
30955   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
30956   Dali::Rect< float > *arg2 = 0 ;
30957   Dali::Rect< float > *result = 0 ;
30958
30959   arg1 = (Dali::Rect< float > *)jarg1;
30960   arg2 = (Dali::Rect< float > *)jarg2;
30961   if (!arg2) {
30962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
30963     return 0;
30964   }
30965   {
30966     try {
30967       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
30968     } CALL_CATCH_EXCEPTION(0);
30969   }
30970
30971   jresult = (void *)result;
30972   return jresult;
30973 }
30974
30975
30976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
30977   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
30978   float arg2 ;
30979   float arg3 ;
30980   float arg4 ;
30981   float arg5 ;
30982
30983   arg1 = (Dali::Rect< float > *)jarg1;
30984   arg2 = (float)jarg2;
30985   arg3 = (float)jarg3;
30986   arg4 = (float)jarg5;
30987   arg5 = (float)jarg4;
30988   {
30989     try {
30990       (arg1)->Set(arg2,arg3,arg4,arg5);
30991     } CALL_CATCH_EXCEPTION();
30992   }
30993
30994 }
30995
30996
30997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
30998   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
30999   float arg2 ;
31000
31001   arg1 = (Dali::Rect< float > *)jarg1;
31002   arg2 = (float)jarg2;
31003   if (arg1) (arg1)->left = arg2;
31004 }
31005
31006
31007 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
31008   float jresult ;
31009   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31010   float result;
31011
31012   arg1 = (Dali::Rect< float > *)jarg1;
31013   result = (float) ((arg1)->left);
31014   jresult = result;
31015   return jresult;
31016 }
31017
31018
31019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
31020   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31021   float arg2 ;
31022
31023   arg1 = (Dali::Rect< float > *)jarg1;
31024   arg2 = (float)jarg2;
31025   if (arg1) (arg1)->left = arg2;
31026 }
31027
31028
31029 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
31030   float jresult ;
31031   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31032   float result;
31033
31034   arg1 = (Dali::Rect< float > *)jarg1;
31035   result = (float) ((arg1)->left);
31036   jresult = result;
31037   return jresult;
31038 }
31039
31040
31041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
31042   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31043   float arg2 ;
31044
31045   arg1 = (Dali::Rect< float > *)jarg1;
31046   arg2 = (float)jarg2;
31047   if (arg1) (arg1)->right = arg2;
31048 }
31049
31050
31051 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
31052   float jresult ;
31053   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31054   float result;
31055
31056   arg1 = (Dali::Rect< float > *)jarg1;
31057   result = (float) ((arg1)->right);
31058   jresult = result;
31059   return jresult;
31060 }
31061
31062
31063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
31064   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31065   float arg2 ;
31066
31067   arg1 = (Dali::Rect< float > *)jarg1;
31068   arg2 = (float)jarg2;
31069   if (arg1) (arg1)->right = arg2;
31070 }
31071
31072
31073 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
31074   float jresult ;
31075   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31076   float result;
31077
31078   arg1 = (Dali::Rect< float > *)jarg1;
31079   result = (float) ((arg1)->right);
31080   jresult = result;
31081   return jresult;
31082 }
31083
31084
31085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
31086   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31087   float arg2 ;
31088
31089   arg1 = (Dali::Rect< float > *)jarg1;
31090   arg2 = (float)jarg2;
31091   if (arg1) (arg1)->bottom = arg2;
31092 }
31093
31094
31095 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
31096   float jresult ;
31097   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31098   float result;
31099
31100   arg1 = (Dali::Rect< float > *)jarg1;
31101   result = (float) ((arg1)->bottom);
31102   jresult = result;
31103   return jresult;
31104 }
31105
31106
31107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
31108   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31109   float arg2 ;
31110
31111   arg1 = (Dali::Rect< float > *)jarg1;
31112   arg2 = (float)jarg2;
31113   if (arg1) (arg1)->top = arg2;
31114 }
31115
31116
31117 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
31118   float jresult ;
31119   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31120   float result;
31121
31122   arg1 = (Dali::Rect< float > *)jarg1;
31123   result = (float) ((arg1)->top);
31124   jresult = result;
31125   return jresult;
31126 }
31127
31128
31129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
31130   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31131
31132   arg1 = (Dali::Rect< float > *)jarg1;
31133   {
31134     try {
31135       delete arg1;
31136     } CALL_CATCH_EXCEPTION();
31137   }
31138
31139 }
31140
31141
31142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
31143   int jresult ;
31144   int result;
31145
31146   result = (int)Dali::Vector< int >::BaseType;
31147   jresult = (int)result;
31148   return jresult;
31149 }
31150
31151
31152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
31153   void * jresult ;
31154   Dali::Vector< int > *result = 0 ;
31155
31156   {
31157     try {
31158       result = (Dali::Vector< int > *)new Dali::Vector< int >();
31159     } CALL_CATCH_EXCEPTION(0);
31160   }
31161
31162   jresult = (void *)result;
31163   return jresult;
31164 }
31165
31166
31167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
31168   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31169
31170   arg1 = (Dali::Vector< int > *)jarg1;
31171   {
31172     try {
31173       delete arg1;
31174     } CALL_CATCH_EXCEPTION();
31175   }
31176
31177 }
31178
31179
31180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
31181   void * jresult ;
31182   Dali::Vector< int > *arg1 = 0 ;
31183   Dali::Vector< int > *result = 0 ;
31184
31185   arg1 = (Dali::Vector< int > *)jarg1;
31186   if (!arg1) {
31187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
31188     return 0;
31189   }
31190   {
31191     try {
31192       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
31193     } CALL_CATCH_EXCEPTION(0);
31194   }
31195
31196   jresult = (void *)result;
31197   return jresult;
31198 }
31199
31200
31201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
31202   void * jresult ;
31203   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31204   Dali::Vector< int > *arg2 = 0 ;
31205   Dali::Vector< int > *result = 0 ;
31206
31207   arg1 = (Dali::Vector< int > *)jarg1;
31208   arg2 = (Dali::Vector< int > *)jarg2;
31209   if (!arg2) {
31210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
31211     return 0;
31212   }
31213   {
31214     try {
31215       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
31216     } CALL_CATCH_EXCEPTION(0);
31217   }
31218
31219   jresult = (void *)result;
31220   return jresult;
31221 }
31222
31223
31224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
31225   void * jresult ;
31226   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31227   Dali::Vector< int >::Iterator result;
31228
31229   arg1 = (Dali::Vector< int > *)jarg1;
31230   {
31231     try {
31232       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
31233     } CALL_CATCH_EXCEPTION(0);
31234   }
31235
31236   jresult = (void *)result;
31237   return jresult;
31238 }
31239
31240
31241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
31242   void * jresult ;
31243   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31244   Dali::Vector< int >::Iterator result;
31245
31246   arg1 = (Dali::Vector< int > *)jarg1;
31247   {
31248     try {
31249       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
31250     } CALL_CATCH_EXCEPTION(0);
31251   }
31252
31253   jresult = (void *)result;
31254   return jresult;
31255 }
31256
31257
31258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
31259   void * jresult ;
31260   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31261   Dali::Vector< int >::SizeType arg2 ;
31262   Dali::Vector< int >::ItemType *result = 0 ;
31263
31264   arg1 = (Dali::Vector< int > *)jarg1;
31265   arg2 = (Dali::Vector< int >::SizeType)jarg2;
31266   {
31267     try {
31268       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
31269     } CALL_CATCH_EXCEPTION(0);
31270   }
31271
31272   jresult = (void *)result;
31273   return jresult;
31274 }
31275
31276
31277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
31278   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31279   Dali::Vector< int >::ItemType *arg2 = 0 ;
31280   Dali::Vector< int >::ItemType temp2 ;
31281
31282   arg1 = (Dali::Vector< int > *)jarg1;
31283   temp2 = (Dali::Vector< int >::ItemType)jarg2;
31284   arg2 = &temp2;
31285   {
31286     try {
31287       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
31288     } CALL_CATCH_EXCEPTION();
31289   }
31290
31291 }
31292
31293
31294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
31295   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31296   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
31297   Dali::Vector< int >::ItemType *arg3 = 0 ;
31298   Dali::Vector< int >::ItemType temp3 ;
31299
31300   arg1 = (Dali::Vector< int > *)jarg1;
31301   arg2 = (Dali::Vector< int >::Iterator)jarg2;
31302   temp3 = (Dali::Vector< int >::ItemType)jarg3;
31303   arg3 = &temp3;
31304   {
31305     try {
31306       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
31307     } CALL_CATCH_EXCEPTION();
31308   }
31309
31310 }
31311
31312
31313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
31314   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31315   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
31316   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
31317   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
31318
31319   arg1 = (Dali::Vector< int > *)jarg1;
31320   arg2 = (Dali::Vector< int >::Iterator)jarg2;
31321   arg3 = (Dali::Vector< int >::Iterator)jarg3;
31322   arg4 = (Dali::Vector< int >::Iterator)jarg4;
31323   {
31324     try {
31325       (arg1)->Insert(arg2,arg3,arg4);
31326     } CALL_CATCH_EXCEPTION();
31327   }
31328
31329 }
31330
31331
31332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
31333   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31334   Dali::Vector< int >::SizeType arg2 ;
31335
31336   arg1 = (Dali::Vector< int > *)jarg1;
31337   arg2 = (Dali::Vector< int >::SizeType)jarg2;
31338   {
31339     try {
31340       (arg1)->Reserve(arg2);
31341     } CALL_CATCH_EXCEPTION();
31342   }
31343
31344 }
31345
31346
31347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
31348   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31349   Dali::Vector< int >::SizeType arg2 ;
31350
31351   arg1 = (Dali::Vector< int > *)jarg1;
31352   arg2 = (Dali::Vector< int >::SizeType)jarg2;
31353   {
31354     try {
31355       (arg1)->Resize(arg2);
31356     } CALL_CATCH_EXCEPTION();
31357   }
31358
31359 }
31360
31361
31362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
31363   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31364   Dali::Vector< int >::SizeType arg2 ;
31365   Dali::Vector< int >::ItemType *arg3 = 0 ;
31366   Dali::Vector< int >::ItemType temp3 ;
31367
31368   arg1 = (Dali::Vector< int > *)jarg1;
31369   arg2 = (Dali::Vector< int >::SizeType)jarg2;
31370   temp3 = (Dali::Vector< int >::ItemType)jarg3;
31371   arg3 = &temp3;
31372   {
31373     try {
31374       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
31375     } CALL_CATCH_EXCEPTION();
31376   }
31377
31378 }
31379
31380
31381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
31382   void * jresult ;
31383   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31384   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
31385   Dali::Vector< int >::Iterator result;
31386
31387   arg1 = (Dali::Vector< int > *)jarg1;
31388   arg2 = (Dali::Vector< int >::Iterator)jarg2;
31389   {
31390     try {
31391       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
31392     } CALL_CATCH_EXCEPTION(0);
31393   }
31394
31395   jresult = (void *)result;
31396   return jresult;
31397 }
31398
31399
31400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
31401   void * jresult ;
31402   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31403   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
31404   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
31405   Dali::Vector< int >::Iterator result;
31406
31407   arg1 = (Dali::Vector< int > *)jarg1;
31408   arg2 = (Dali::Vector< int >::Iterator)jarg2;
31409   arg3 = (Dali::Vector< int >::Iterator)jarg3;
31410   {
31411     try {
31412       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
31413     } CALL_CATCH_EXCEPTION(0);
31414   }
31415
31416   jresult = (void *)result;
31417   return jresult;
31418 }
31419
31420
31421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
31422   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31423   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
31424
31425   arg1 = (Dali::Vector< int > *)jarg1;
31426   arg2 = (Dali::Vector< int >::Iterator)jarg2;
31427   {
31428     try {
31429       (arg1)->Remove(arg2);
31430     } CALL_CATCH_EXCEPTION();
31431   }
31432
31433 }
31434
31435
31436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
31437   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31438   Dali::Vector< int > *arg2 = 0 ;
31439
31440   arg1 = (Dali::Vector< int > *)jarg1;
31441   arg2 = (Dali::Vector< int > *)jarg2;
31442   if (!arg2) {
31443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
31444     return ;
31445   }
31446   {
31447     try {
31448       (arg1)->Swap(*arg2);
31449     } CALL_CATCH_EXCEPTION();
31450   }
31451
31452 }
31453
31454
31455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
31456   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31457
31458   arg1 = (Dali::Vector< int > *)jarg1;
31459   {
31460     try {
31461       (arg1)->Clear();
31462     } CALL_CATCH_EXCEPTION();
31463   }
31464
31465 }
31466
31467
31468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
31469   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31470
31471   arg1 = (Dali::Vector< int > *)jarg1;
31472   {
31473     try {
31474       (arg1)->Release();
31475     } CALL_CATCH_EXCEPTION();
31476   }
31477
31478 }
31479
31480
31481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
31482   int jresult ;
31483   int result;
31484
31485   result = (int)Dali::Vector< float >::BaseType;
31486   jresult = (int)result;
31487   return jresult;
31488 }
31489
31490
31491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
31492   void * jresult ;
31493   Dali::Vector< float > *result = 0 ;
31494
31495   {
31496     try {
31497       result = (Dali::Vector< float > *)new Dali::Vector< float >();
31498     } CALL_CATCH_EXCEPTION(0);
31499   }
31500
31501   jresult = (void *)result;
31502   return jresult;
31503 }
31504
31505
31506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
31507   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31508
31509   arg1 = (Dali::Vector< float > *)jarg1;
31510   {
31511     try {
31512       delete arg1;
31513     } CALL_CATCH_EXCEPTION();
31514   }
31515
31516 }
31517
31518
31519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
31520   void * jresult ;
31521   Dali::Vector< float > *arg1 = 0 ;
31522   Dali::Vector< float > *result = 0 ;
31523
31524   arg1 = (Dali::Vector< float > *)jarg1;
31525   if (!arg1) {
31526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
31527     return 0;
31528   }
31529   {
31530     try {
31531       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
31532     } CALL_CATCH_EXCEPTION(0);
31533   }
31534
31535   jresult = (void *)result;
31536   return jresult;
31537 }
31538
31539
31540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
31541   void * jresult ;
31542   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31543   Dali::Vector< float > *arg2 = 0 ;
31544   Dali::Vector< float > *result = 0 ;
31545
31546   arg1 = (Dali::Vector< float > *)jarg1;
31547   arg2 = (Dali::Vector< float > *)jarg2;
31548   if (!arg2) {
31549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
31550     return 0;
31551   }
31552   {
31553     try {
31554       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
31555     } CALL_CATCH_EXCEPTION(0);
31556   }
31557
31558   jresult = (void *)result;
31559   return jresult;
31560 }
31561
31562
31563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
31564   void * jresult ;
31565   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31566   Dali::Vector< float >::Iterator result;
31567
31568   arg1 = (Dali::Vector< float > *)jarg1;
31569   {
31570     try {
31571       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
31572     } CALL_CATCH_EXCEPTION(0);
31573   }
31574
31575   jresult = (void *)result;
31576   return jresult;
31577 }
31578
31579
31580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
31581   void * jresult ;
31582   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31583   Dali::Vector< float >::Iterator result;
31584
31585   arg1 = (Dali::Vector< float > *)jarg1;
31586   {
31587     try {
31588       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
31589     } CALL_CATCH_EXCEPTION(0);
31590   }
31591
31592   jresult = (void *)result;
31593   return jresult;
31594 }
31595
31596
31597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
31598   void * jresult ;
31599   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31600   Dali::Vector< float >::SizeType arg2 ;
31601   Dali::Vector< float >::ItemType *result = 0 ;
31602
31603   arg1 = (Dali::Vector< float > *)jarg1;
31604   arg2 = (Dali::Vector< float >::SizeType)jarg2;
31605   {
31606     try {
31607       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
31608     } CALL_CATCH_EXCEPTION(0);
31609   }
31610
31611   jresult = (void *)result;
31612   return jresult;
31613 }
31614
31615
31616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
31617   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31618   Dali::Vector< float >::ItemType *arg2 = 0 ;
31619   Dali::Vector< float >::ItemType temp2 ;
31620
31621   arg1 = (Dali::Vector< float > *)jarg1;
31622   temp2 = (Dali::Vector< float >::ItemType)jarg2;
31623   arg2 = &temp2;
31624   {
31625     try {
31626       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
31627     } CALL_CATCH_EXCEPTION();
31628   }
31629
31630 }
31631
31632
31633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
31634   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31635   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
31636   Dali::Vector< float >::ItemType *arg3 = 0 ;
31637   Dali::Vector< float >::ItemType temp3 ;
31638
31639   arg1 = (Dali::Vector< float > *)jarg1;
31640   arg2 = (Dali::Vector< float >::Iterator)jarg2;
31641   temp3 = (Dali::Vector< float >::ItemType)jarg3;
31642   arg3 = &temp3;
31643   {
31644     try {
31645       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
31646     } CALL_CATCH_EXCEPTION();
31647   }
31648
31649 }
31650
31651
31652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
31653   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31654   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
31655   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
31656   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
31657
31658   arg1 = (Dali::Vector< float > *)jarg1;
31659   arg2 = (Dali::Vector< float >::Iterator)jarg2;
31660   arg3 = (Dali::Vector< float >::Iterator)jarg3;
31661   arg4 = (Dali::Vector< float >::Iterator)jarg4;
31662   {
31663     try {
31664       (arg1)->Insert(arg2,arg3,arg4);
31665     } CALL_CATCH_EXCEPTION();
31666   }
31667
31668 }
31669
31670
31671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
31672   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31673   Dali::Vector< float >::SizeType arg2 ;
31674
31675   arg1 = (Dali::Vector< float > *)jarg1;
31676   arg2 = (Dali::Vector< float >::SizeType)jarg2;
31677   {
31678     try {
31679       (arg1)->Reserve(arg2);
31680     } CALL_CATCH_EXCEPTION();
31681   }
31682
31683 }
31684
31685 //// ========================= end of part 2 =============================
31686
31687 //// ========================== start part 3 ===============================
31688
31689
31690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
31691   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31692   Dali::Vector< float >::SizeType arg2 ;
31693
31694   arg1 = (Dali::Vector< float > *)jarg1;
31695   arg2 = (Dali::Vector< float >::SizeType)jarg2;
31696   {
31697     try {
31698       (arg1)->Resize(arg2);
31699     } CALL_CATCH_EXCEPTION();
31700   }
31701
31702 }
31703
31704
31705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
31706   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31707   Dali::Vector< float >::SizeType arg2 ;
31708   Dali::Vector< float >::ItemType *arg3 = 0 ;
31709   Dali::Vector< float >::ItemType temp3 ;
31710
31711   arg1 = (Dali::Vector< float > *)jarg1;
31712   arg2 = (Dali::Vector< float >::SizeType)jarg2;
31713   temp3 = (Dali::Vector< float >::ItemType)jarg3;
31714   arg3 = &temp3;
31715   {
31716     try {
31717       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
31718     } CALL_CATCH_EXCEPTION();
31719   }
31720
31721 }
31722
31723
31724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
31725   void * jresult ;
31726   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31727   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
31728   Dali::Vector< float >::Iterator result;
31729
31730   arg1 = (Dali::Vector< float > *)jarg1;
31731   arg2 = (Dali::Vector< float >::Iterator)jarg2;
31732   {
31733     try {
31734       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
31735     } CALL_CATCH_EXCEPTION(0);
31736   }
31737
31738   jresult = (void *)result;
31739   return jresult;
31740 }
31741
31742
31743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
31744   void * jresult ;
31745   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31746   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
31747   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
31748   Dali::Vector< float >::Iterator result;
31749
31750   arg1 = (Dali::Vector< float > *)jarg1;
31751   arg2 = (Dali::Vector< float >::Iterator)jarg2;
31752   arg3 = (Dali::Vector< float >::Iterator)jarg3;
31753   {
31754     try {
31755       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
31756     } CALL_CATCH_EXCEPTION(0);
31757   }
31758
31759   jresult = (void *)result;
31760   return jresult;
31761 }
31762
31763
31764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
31765   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31766   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
31767
31768   arg1 = (Dali::Vector< float > *)jarg1;
31769   arg2 = (Dali::Vector< float >::Iterator)jarg2;
31770   {
31771     try {
31772       (arg1)->Remove(arg2);
31773     } CALL_CATCH_EXCEPTION();
31774   }
31775
31776 }
31777
31778
31779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
31780   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31781   Dali::Vector< float > *arg2 = 0 ;
31782
31783   arg1 = (Dali::Vector< float > *)jarg1;
31784   arg2 = (Dali::Vector< float > *)jarg2;
31785   if (!arg2) {
31786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
31787     return ;
31788   }
31789   {
31790     try {
31791       (arg1)->Swap(*arg2);
31792     } CALL_CATCH_EXCEPTION();
31793   }
31794
31795 }
31796
31797
31798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
31799   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31800
31801   arg1 = (Dali::Vector< float > *)jarg1;
31802   {
31803     try {
31804       (arg1)->Clear();
31805     } CALL_CATCH_EXCEPTION();
31806   }
31807
31808 }
31809
31810
31811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
31812   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31813
31814   arg1 = (Dali::Vector< float > *)jarg1;
31815   {
31816     try {
31817       (arg1)->Release();
31818     } CALL_CATCH_EXCEPTION();
31819   }
31820
31821 }
31822
31823
31824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
31825   int jresult ;
31826   int result;
31827
31828   result = (int)Dali::Vector< unsigned char >::BaseType;
31829   jresult = (int)result;
31830   return jresult;
31831 }
31832
31833
31834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
31835   void * jresult ;
31836   Dali::Vector< unsigned char > *result = 0 ;
31837
31838   {
31839     try {
31840       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
31841     } CALL_CATCH_EXCEPTION(0);
31842   }
31843
31844   jresult = (void *)result;
31845   return jresult;
31846 }
31847
31848
31849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
31850   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
31851
31852   arg1 = (Dali::Vector< unsigned char > *)jarg1;
31853   {
31854     try {
31855       delete arg1;
31856     } CALL_CATCH_EXCEPTION();
31857   }
31858
31859 }
31860
31861
31862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
31863   void * jresult ;
31864   Dali::Vector< unsigned char > *arg1 = 0 ;
31865   Dali::Vector< unsigned char > *result = 0 ;
31866
31867   arg1 = (Dali::Vector< unsigned char > *)jarg1;
31868   if (!arg1) {
31869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
31870     return 0;
31871   }
31872   {
31873     try {
31874       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
31875     } CALL_CATCH_EXCEPTION(0);
31876   }
31877
31878   jresult = (void *)result;
31879   return jresult;
31880 }
31881
31882
31883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
31884   void * jresult ;
31885   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
31886   Dali::Vector< unsigned char > *arg2 = 0 ;
31887   Dali::Vector< unsigned char > *result = 0 ;
31888
31889   arg1 = (Dali::Vector< unsigned char > *)jarg1;
31890   arg2 = (Dali::Vector< unsigned char > *)jarg2;
31891   if (!arg2) {
31892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
31893     return 0;
31894   }
31895   {
31896     try {
31897       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
31898     } CALL_CATCH_EXCEPTION(0);
31899   }
31900
31901   jresult = (void *)result;
31902   return jresult;
31903 }
31904
31905
31906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
31907   void * jresult ;
31908   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
31909   Dali::Vector< unsigned char >::Iterator result;
31910
31911   arg1 = (Dali::Vector< unsigned char > *)jarg1;
31912   {
31913     try {
31914       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
31915     } CALL_CATCH_EXCEPTION(0);
31916   }
31917
31918   jresult = (void *)result;
31919   return jresult;
31920 }
31921
31922
31923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
31924   void * jresult ;
31925   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
31926   Dali::Vector< unsigned char >::Iterator result;
31927
31928   arg1 = (Dali::Vector< unsigned char > *)jarg1;
31929   {
31930     try {
31931       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
31932     } CALL_CATCH_EXCEPTION(0);
31933   }
31934
31935   jresult = (void *)result;
31936   return jresult;
31937 }
31938
31939
31940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
31941   void * jresult ;
31942   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
31943   Dali::Vector< unsigned char >::SizeType arg2 ;
31944   Dali::Vector< unsigned char >::ItemType *result = 0 ;
31945
31946   arg1 = (Dali::Vector< unsigned char > *)jarg1;
31947   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
31948   {
31949     try {
31950       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
31951     } CALL_CATCH_EXCEPTION(0);
31952   }
31953
31954   jresult = (void *)result;
31955   return jresult;
31956 }
31957
31958
31959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
31960   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
31961   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
31962   Dali::Vector< unsigned char >::ItemType temp2 ;
31963
31964   arg1 = (Dali::Vector< unsigned char > *)jarg1;
31965   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
31966   arg2 = &temp2;
31967   {
31968     try {
31969       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
31970     } CALL_CATCH_EXCEPTION();
31971   }
31972
31973 }
31974
31975
31976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
31977   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
31978   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
31979   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
31980   Dali::Vector< unsigned char >::ItemType temp3 ;
31981
31982   arg1 = (Dali::Vector< unsigned char > *)jarg1;
31983   arg2 = jarg2;
31984   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
31985   arg3 = &temp3;
31986   {
31987     try {
31988       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
31989     } CALL_CATCH_EXCEPTION();
31990   }
31991
31992
31993
31994 }
31995
31996
31997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
31998   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
31999   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
32000   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
32001   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
32002
32003   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32004   arg2 = jarg2;
32005   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
32006   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
32007   {
32008     try {
32009       (arg1)->Insert(arg2,arg3,arg4);
32010     } CALL_CATCH_EXCEPTION();
32011   }
32012
32013
32014
32015 }
32016
32017
32018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
32019   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32020   Dali::Vector< unsigned char >::SizeType arg2 ;
32021
32022   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32023   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
32024   {
32025     try {
32026       (arg1)->Reserve(arg2);
32027     } CALL_CATCH_EXCEPTION();
32028   }
32029
32030 }
32031
32032
32033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
32034   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32035   Dali::Vector< unsigned char >::SizeType arg2 ;
32036
32037   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32038   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
32039   {
32040     try {
32041       (arg1)->Resize(arg2);
32042     } CALL_CATCH_EXCEPTION();
32043   }
32044
32045 }
32046
32047
32048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
32049   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32050   Dali::Vector< unsigned char >::SizeType arg2 ;
32051   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
32052   Dali::Vector< unsigned char >::ItemType temp3 ;
32053
32054   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32055   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
32056   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
32057   arg3 = &temp3;
32058   {
32059     try {
32060       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
32061     } CALL_CATCH_EXCEPTION();
32062   }
32063
32064 }
32065
32066
32067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
32068   void * jresult ;
32069   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32070   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
32071   Dali::Vector< unsigned char >::Iterator result;
32072
32073   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32074   arg2 = jarg2;
32075   {
32076     try {
32077       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
32078     } CALL_CATCH_EXCEPTION(0);
32079   }
32080
32081   jresult = (void *)result;
32082
32083
32084   return jresult;
32085 }
32086
32087
32088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
32089   void * jresult ;
32090   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32091   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
32092   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
32093   Dali::Vector< unsigned char >::Iterator result;
32094
32095   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32096   arg2 = jarg2;
32097   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
32098   {
32099     try {
32100       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
32101     } CALL_CATCH_EXCEPTION(0);
32102   }
32103
32104   jresult = (void *)result;
32105
32106
32107   return jresult;
32108 }
32109
32110
32111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
32112   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32113   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
32114
32115   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32116   arg2 = jarg2;
32117   {
32118     try {
32119       (arg1)->Remove(arg2);
32120     } CALL_CATCH_EXCEPTION();
32121   }
32122
32123
32124
32125 }
32126
32127
32128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
32129   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32130   Dali::Vector< unsigned char > *arg2 = 0 ;
32131
32132   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32133   arg2 = (Dali::Vector< unsigned char > *)jarg2;
32134   if (!arg2) {
32135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
32136     return ;
32137   }
32138   {
32139     try {
32140       (arg1)->Swap(*arg2);
32141     } CALL_CATCH_EXCEPTION();
32142   }
32143
32144 }
32145
32146
32147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
32148   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32149
32150   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32151   {
32152     try {
32153       (arg1)->Clear();
32154     } CALL_CATCH_EXCEPTION();
32155   }
32156
32157 }
32158
32159
32160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
32161   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32162
32163   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32164   {
32165     try {
32166       (arg1)->Release();
32167     } CALL_CATCH_EXCEPTION();
32168   }
32169
32170 }
32171
32172
32173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
32174   int jresult ;
32175   int result;
32176
32177   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
32178   jresult = (int)result;
32179   return jresult;
32180 }
32181
32182
32183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
32184   void * jresult ;
32185   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
32186
32187   {
32188     try {
32189       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
32190     } CALL_CATCH_EXCEPTION(0);
32191   }
32192
32193   jresult = (void *)result;
32194   return jresult;
32195 }
32196
32197
32198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
32199   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32200
32201   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32202   {
32203     try {
32204       delete arg1;
32205     } CALL_CATCH_EXCEPTION();
32206   }
32207
32208 }
32209
32210
32211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
32212   void * jresult ;
32213   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
32214   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
32215
32216   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32217   if (!arg1) {
32218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
32219     return 0;
32220   }
32221   {
32222     try {
32223       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
32224     } CALL_CATCH_EXCEPTION(0);
32225   }
32226
32227   jresult = (void *)result;
32228   return jresult;
32229 }
32230
32231
32232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
32233   void * jresult ;
32234   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32235   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
32236   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
32237
32238   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32239   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
32240   if (!arg2) {
32241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
32242     return 0;
32243   }
32244   {
32245     try {
32246       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
32247     } CALL_CATCH_EXCEPTION(0);
32248   }
32249
32250   jresult = (void *)result;
32251   return jresult;
32252 }
32253
32254
32255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
32256   void * jresult ;
32257   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32258   Dali::Vector< Dali::Uint16Pair >::Iterator result;
32259
32260   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32261   {
32262     try {
32263       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
32264     } CALL_CATCH_EXCEPTION(0);
32265   }
32266
32267   jresult = (void *)result;
32268   return jresult;
32269 }
32270
32271
32272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
32273   void * jresult ;
32274   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32275   Dali::Vector< Dali::Uint16Pair >::Iterator result;
32276
32277   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32278   {
32279     try {
32280       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
32281     } CALL_CATCH_EXCEPTION(0);
32282   }
32283
32284   jresult = (void *)result;
32285   return jresult;
32286 }
32287
32288
32289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
32290   void * jresult ;
32291   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32292   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
32293   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
32294
32295   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32296   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
32297   {
32298     try {
32299       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
32300     } CALL_CATCH_EXCEPTION(0);
32301   }
32302
32303   jresult = (void *)result;
32304   return jresult;
32305 }
32306
32307
32308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
32309   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32310   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
32311
32312   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32313   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
32314   if (!arg2) {
32315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
32316     return ;
32317   }
32318   {
32319     try {
32320       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
32321     } CALL_CATCH_EXCEPTION();
32322   }
32323
32324 }
32325
32326
32327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
32328   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32329   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
32330   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
32331
32332   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32333   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
32334   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
32335   if (!arg3) {
32336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
32337     return ;
32338   }
32339   {
32340     try {
32341       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
32342     } CALL_CATCH_EXCEPTION();
32343   }
32344
32345 }
32346
32347
32348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
32349   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32350   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
32351   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
32352   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
32353
32354   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32355   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
32356   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
32357   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
32358   {
32359     try {
32360       (arg1)->Insert(arg2,arg3,arg4);
32361     } CALL_CATCH_EXCEPTION();
32362   }
32363
32364 }
32365
32366
32367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
32368   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32369   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
32370
32371   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32372   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
32373   {
32374     try {
32375       (arg1)->Reserve(arg2);
32376     } CALL_CATCH_EXCEPTION();
32377   }
32378
32379 }
32380
32381
32382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
32383   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32384   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
32385
32386   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32387   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
32388   {
32389     try {
32390       (arg1)->Resize(arg2);
32391     } CALL_CATCH_EXCEPTION();
32392   }
32393
32394 }
32395
32396
32397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
32398   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32399   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
32400   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
32401
32402   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32403   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
32404   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
32405   if (!arg3) {
32406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
32407     return ;
32408   }
32409   {
32410     try {
32411       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
32412     } CALL_CATCH_EXCEPTION();
32413   }
32414
32415 }
32416
32417
32418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
32419   void * jresult ;
32420   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32421   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
32422   Dali::Vector< Dali::Uint16Pair >::Iterator result;
32423
32424   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32425   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
32426   {
32427     try {
32428       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
32429     } CALL_CATCH_EXCEPTION(0);
32430   }
32431
32432   jresult = (void *)result;
32433   return jresult;
32434 }
32435
32436
32437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
32438   void * jresult ;
32439   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32440   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
32441   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
32442   Dali::Vector< Dali::Uint16Pair >::Iterator result;
32443
32444   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32445   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
32446   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
32447   {
32448     try {
32449       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
32450     } CALL_CATCH_EXCEPTION(0);
32451   }
32452
32453   jresult = (void *)result;
32454   return jresult;
32455 }
32456
32457
32458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
32459   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32460   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
32461
32462   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32463   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
32464   {
32465     try {
32466       (arg1)->Remove(arg2);
32467     } CALL_CATCH_EXCEPTION();
32468   }
32469
32470 }
32471
32472
32473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
32474   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32475   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
32476
32477   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32478   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
32479   if (!arg2) {
32480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
32481     return ;
32482   }
32483   {
32484     try {
32485       (arg1)->Swap(*arg2);
32486     } CALL_CATCH_EXCEPTION();
32487   }
32488
32489 }
32490
32491
32492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
32493   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32494
32495   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32496   {
32497     try {
32498       (arg1)->Clear();
32499     } CALL_CATCH_EXCEPTION();
32500   }
32501
32502 }
32503
32504
32505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
32506   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32507
32508   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32509   {
32510     try {
32511       (arg1)->Release();
32512     } CALL_CATCH_EXCEPTION();
32513   }
32514
32515 }
32516
32517
32518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
32519   void * jresult ;
32520   Dali::Signal< void () > *result = 0 ;
32521
32522   {
32523     try {
32524       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
32525     } CALL_CATCH_EXCEPTION(0);
32526   }
32527
32528   jresult = (void *)result;
32529   return jresult;
32530 }
32531
32532
32533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
32534   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
32535
32536   arg1 = (Dali::Signal< void () > *)jarg1;
32537   {
32538     try {
32539       delete arg1;
32540     } CALL_CATCH_EXCEPTION();
32541   }
32542
32543 }
32544
32545
32546 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
32547   bool jresult ;
32548   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
32549   bool result;
32550
32551   arg1 = (Dali::Signal< void () > *)jarg1;
32552   {
32553     try {
32554       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
32555     } CALL_CATCH_EXCEPTION(0);
32556   }
32557
32558   jresult = result;
32559   return jresult;
32560 }
32561
32562
32563 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
32564   unsigned long jresult ;
32565   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
32566   std::size_t result;
32567
32568   arg1 = (Dali::Signal< void () > *)jarg1;
32569   {
32570     try {
32571       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
32572     } CALL_CATCH_EXCEPTION(0);
32573   }
32574
32575   jresult = (unsigned long)result;
32576   return jresult;
32577 }
32578
32579
32580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
32581   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
32582   void (*arg2)() = (void (*)()) 0 ;
32583
32584   arg1 = (Dali::Signal< void () > *)jarg1;
32585   arg2 = (void (*)())jarg2;
32586   {
32587     try {
32588       (arg1)->Connect(arg2);
32589     } CALL_CATCH_EXCEPTION();
32590   }
32591
32592 }
32593
32594
32595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
32596   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
32597   void (*arg2)() = (void (*)()) 0 ;
32598
32599   arg1 = (Dali::Signal< void () > *)jarg1;
32600   arg2 = (void (*)())jarg2;
32601   {
32602     try {
32603       (arg1)->Disconnect(arg2);
32604     } CALL_CATCH_EXCEPTION();
32605   }
32606
32607 }
32608
32609
32610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
32611   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
32612   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
32613   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
32614
32615   arg1 = (Dali::Signal< void () > *)jarg1;
32616   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
32617   arg3 = (Dali::FunctorDelegate *)jarg3;
32618   {
32619     try {
32620       (arg1)->Connect(arg2,arg3);
32621     } CALL_CATCH_EXCEPTION();
32622   }
32623
32624 }
32625
32626
32627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
32628   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
32629
32630   arg1 = (Dali::Signal< void () > *)jarg1;
32631   {
32632     try {
32633       (arg1)->Emit();
32634     } CALL_CATCH_EXCEPTION();
32635   }
32636
32637 }
32638
32639
32640 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
32641   bool jresult ;
32642   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
32643   bool result;
32644
32645   arg1 = (Dali::Signal< void (float) > *)jarg1;
32646   {
32647     try {
32648       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
32649     } CALL_CATCH_EXCEPTION(0);
32650   }
32651
32652   jresult = result;
32653   return jresult;
32654 }
32655
32656
32657 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
32658   unsigned long jresult ;
32659   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
32660   std::size_t result;
32661
32662   arg1 = (Dali::Signal< void (float) > *)jarg1;
32663   {
32664     try {
32665       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
32666     } CALL_CATCH_EXCEPTION(0);
32667   }
32668
32669   jresult = (unsigned long)result;
32670   return jresult;
32671 }
32672
32673
32674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
32675   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
32676   void (*arg2)(float) = (void (*)(float)) 0 ;
32677
32678   arg1 = (Dali::Signal< void (float) > *)jarg1;
32679   arg2 = (void (*)(float))jarg2;
32680   {
32681     try {
32682       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
32683     } CALL_CATCH_EXCEPTION();
32684   }
32685
32686 }
32687
32688
32689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
32690   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
32691   void (*arg2)(float) = (void (*)(float)) 0 ;
32692
32693   arg1 = (Dali::Signal< void (float) > *)jarg1;
32694   arg2 = (void (*)(float))jarg2;
32695   {
32696     try {
32697       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
32698     } CALL_CATCH_EXCEPTION();
32699   }
32700
32701 }
32702
32703
32704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
32705   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
32706   float arg2 ;
32707
32708   arg1 = (Dali::Signal< void (float) > *)jarg1;
32709   arg2 = (float)jarg2;
32710   {
32711     try {
32712       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
32713     } CALL_CATCH_EXCEPTION();
32714   }
32715
32716 }
32717
32718
32719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
32720   void * jresult ;
32721   Dali::Signal< void (float) > *result = 0 ;
32722
32723   {
32724     try {
32725       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
32726     } CALL_CATCH_EXCEPTION(0);
32727   }
32728
32729   jresult = (void *)result;
32730   return jresult;
32731 }
32732
32733
32734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
32735   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
32736
32737   arg1 = (Dali::Signal< void (float) > *)jarg1;
32738   {
32739     try {
32740       delete arg1;
32741     } CALL_CATCH_EXCEPTION();
32742   }
32743
32744 }
32745
32746
32747 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
32748   bool jresult ;
32749   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
32750   bool result;
32751
32752   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
32753   {
32754     try {
32755       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
32756     } CALL_CATCH_EXCEPTION(0);
32757   }
32758
32759   jresult = result;
32760   return jresult;
32761 }
32762
32763
32764 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
32765   unsigned long jresult ;
32766   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
32767   std::size_t result;
32768
32769   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
32770   {
32771     try {
32772       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
32773     } CALL_CATCH_EXCEPTION(0);
32774   }
32775
32776   jresult = (unsigned long)result;
32777   return jresult;
32778 }
32779
32780
32781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
32782   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
32783   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
32784
32785   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
32786   arg2 = (void (*)(Dali::BaseHandle))jarg2;
32787   {
32788     try {
32789       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
32790     } CALL_CATCH_EXCEPTION();
32791   }
32792
32793 }
32794
32795
32796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
32797   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
32798   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
32799
32800   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
32801   arg2 = (void (*)(Dali::BaseHandle))jarg2;
32802   {
32803     try {
32804       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
32805     } CALL_CATCH_EXCEPTION();
32806   }
32807
32808 }
32809
32810
32811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
32812   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
32813   Dali::BaseHandle arg2 ;
32814   Dali::BaseHandle *argp2 ;
32815
32816   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
32817   argp2 = (Dali::BaseHandle *)jarg2;
32818   if (!argp2) {
32819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32820     return ;
32821   }
32822   arg2 = *argp2;
32823   {
32824     try {
32825       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
32826     } CALL_CATCH_EXCEPTION();
32827   }
32828
32829 }
32830
32831
32832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
32833   void * jresult ;
32834   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
32835
32836   {
32837     try {
32838       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
32839     } CALL_CATCH_EXCEPTION(0);
32840   }
32841
32842   jresult = (void *)result;
32843   return jresult;
32844 }
32845
32846
32847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
32848   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
32849
32850   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
32851   {
32852     try {
32853       delete arg1;
32854     } CALL_CATCH_EXCEPTION();
32855   }
32856
32857 }
32858
32859
32860 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
32861   bool jresult ;
32862   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
32863   bool result;
32864
32865   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
32866   {
32867     try {
32868       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
32869     } CALL_CATCH_EXCEPTION(0);
32870   }
32871
32872   jresult = result;
32873   return jresult;
32874 }
32875
32876
32877 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
32878   unsigned long jresult ;
32879   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
32880   std::size_t result;
32881
32882   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
32883   {
32884     try {
32885       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
32886     } CALL_CATCH_EXCEPTION(0);
32887   }
32888
32889   jresult = (unsigned long)result;
32890   return jresult;
32891 }
32892
32893
32894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
32895   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
32896   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
32897
32898   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
32899   arg2 = (void (*)(Dali::RefObject const *))jarg2;
32900   {
32901     try {
32902       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
32903     } CALL_CATCH_EXCEPTION();
32904   }
32905
32906 }
32907
32908
32909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
32910   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
32911   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
32912
32913   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
32914   arg2 = (void (*)(Dali::RefObject const *))jarg2;
32915   {
32916     try {
32917       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
32918     } CALL_CATCH_EXCEPTION();
32919   }
32920
32921 }
32922
32923
32924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
32925   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
32926   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
32927
32928   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
32929   arg2 = (Dali::RefObject *)jarg2;
32930   {
32931     try {
32932       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
32933     } CALL_CATCH_EXCEPTION();
32934   }
32935
32936 }
32937
32938
32939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
32940   void * jresult ;
32941   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
32942
32943   {
32944     try {
32945       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
32946     } CALL_CATCH_EXCEPTION(0);
32947   }
32948
32949   jresult = (void *)result;
32950   return jresult;
32951 }
32952
32953
32954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
32955   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
32956
32957   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
32958   {
32959     try {
32960       delete arg1;
32961     } CALL_CATCH_EXCEPTION();
32962   }
32963
32964 }
32965
32966
32967 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
32968   bool jresult ;
32969   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
32970   bool result;
32971
32972   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
32973   {
32974     try {
32975       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
32976     } CALL_CATCH_EXCEPTION(0);
32977   }
32978
32979   jresult = result;
32980   return jresult;
32981 }
32982
32983
32984 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
32985   unsigned long jresult ;
32986   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
32987   std::size_t result;
32988
32989   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
32990   {
32991     try {
32992       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
32993     } CALL_CATCH_EXCEPTION(0);
32994   }
32995
32996   jresult = (unsigned long)result;
32997   return jresult;
32998 }
32999
33000
33001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
33002   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
33003   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
33004
33005   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
33006   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
33007   {
33008     try {
33009       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
33010     } CALL_CATCH_EXCEPTION();
33011   }
33012
33013 }
33014
33015
33016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
33017   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
33018   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
33019
33020   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
33021   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
33022   {
33023     try {
33024       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
33025     } CALL_CATCH_EXCEPTION();
33026   }
33027
33028 }
33029
33030
33031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
33032   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
33033   Dali::PropertyNotification *arg2 = 0 ;
33034
33035   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
33036   arg2 = (Dali::PropertyNotification *)jarg2;
33037   if (!arg2) {
33038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
33039     return ;
33040   }
33041   {
33042     try {
33043       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
33044     } CALL_CATCH_EXCEPTION();
33045   }
33046
33047 }
33048
33049
33050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
33051   void * jresult ;
33052   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
33053
33054   {
33055     try {
33056       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
33057     } CALL_CATCH_EXCEPTION(0);
33058   }
33059
33060   jresult = (void *)result;
33061   return jresult;
33062 }
33063
33064
33065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
33066   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
33067
33068   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
33069   {
33070     try {
33071       delete arg1;
33072     } CALL_CATCH_EXCEPTION();
33073   }
33074
33075 }
33076
33077
33078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
33079   void * jresult ;
33080   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
33081
33082   {
33083     try {
33084       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
33085     } CALL_CATCH_EXCEPTION(0);
33086   }
33087
33088   jresult = (void *)result;
33089   return jresult;
33090 }
33091
33092
33093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
33094   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
33095
33096   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
33097   {
33098     try {
33099       delete arg1;
33100     } CALL_CATCH_EXCEPTION();
33101   }
33102
33103 }
33104
33105
33106 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
33107   bool jresult ;
33108   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
33109   bool result;
33110
33111   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
33112   {
33113     try {
33114       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);
33115     } CALL_CATCH_EXCEPTION(0);
33116   }
33117
33118   jresult = result;
33119   return jresult;
33120 }
33121
33122
33123 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
33124   unsigned long jresult ;
33125   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
33126   std::size_t result;
33127
33128   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
33129   {
33130     try {
33131       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);
33132     } CALL_CATCH_EXCEPTION(0);
33133   }
33134
33135   jresult = (unsigned long)result;
33136   return jresult;
33137 }
33138
33139
33140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
33141   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
33142   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
33143
33144   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
33145   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
33146   {
33147     try {
33148       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
33149     } CALL_CATCH_EXCEPTION();
33150   }
33151
33152 }
33153
33154
33155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
33156   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
33157   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
33158
33159   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
33160   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
33161   {
33162     try {
33163       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
33164     } CALL_CATCH_EXCEPTION();
33165   }
33166
33167 }
33168
33169
33170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
33171   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
33172   Dali::Actor arg2 ;
33173   Dali::LongPressGesture *arg3 = 0 ;
33174   Dali::Actor *argp2 ;
33175
33176   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
33177   argp2 = (Dali::Actor *)jarg2;
33178   if (!argp2) {
33179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33180     return ;
33181   }
33182   arg2 = *argp2;
33183   arg3 = (Dali::LongPressGesture *)jarg3;
33184   if (!arg3) {
33185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
33186     return ;
33187   }
33188   {
33189     try {
33190       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
33191     } CALL_CATCH_EXCEPTION();
33192   }
33193
33194 }
33195
33196
33197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
33198   void * jresult ;
33199   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
33200
33201   {
33202     try {
33203       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
33204     } CALL_CATCH_EXCEPTION(0);
33205   }
33206
33207   jresult = (void *)result;
33208   return jresult;
33209 }
33210
33211
33212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
33213   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
33214
33215   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
33216   {
33217     try {
33218       delete arg1;
33219     } CALL_CATCH_EXCEPTION();
33220   }
33221
33222 }
33223
33224
33225 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
33226   bool jresult ;
33227   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
33228   bool result;
33229
33230   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
33231   {
33232     try {
33233       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);
33234     } CALL_CATCH_EXCEPTION(0);
33235   }
33236
33237   jresult = result;
33238   return jresult;
33239 }
33240
33241
33242 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
33243   unsigned long jresult ;
33244   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
33245   std::size_t result;
33246
33247   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
33248   {
33249     try {
33250       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);
33251     } CALL_CATCH_EXCEPTION(0);
33252   }
33253
33254   jresult = (unsigned long)result;
33255   return jresult;
33256 }
33257
33258
33259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
33260   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
33261   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
33262
33263   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
33264   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
33265   {
33266     try {
33267       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
33268     } CALL_CATCH_EXCEPTION();
33269   }
33270
33271 }
33272
33273
33274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
33275   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
33276   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
33277
33278   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
33279   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
33280   {
33281     try {
33282       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
33283     } CALL_CATCH_EXCEPTION();
33284   }
33285
33286 }
33287
33288
33289 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
33290   bool jresult ;
33291   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
33292   Dali::Actor arg2 ;
33293   Dali::TouchEvent *arg3 = 0 ;
33294   Dali::Actor *argp2 ;
33295   bool result;
33296
33297   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
33298   argp2 = (Dali::Actor *)jarg2;
33299   if (!argp2) {
33300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33301     return 0;
33302   }
33303   arg2 = *argp2;
33304   arg3 = (Dali::TouchEvent *)jarg3;
33305   if (!arg3) {
33306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
33307     return 0;
33308   }
33309   {
33310     try {
33311       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchEvent const &)*arg3);
33312     } CALL_CATCH_EXCEPTION(0);
33313   }
33314
33315   jresult = result;
33316   return jresult;
33317 }
33318
33319
33320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
33321   void * jresult ;
33322   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *result = 0 ;
33323
33324   {
33325     try {
33326       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) >();
33327     } CALL_CATCH_EXCEPTION(0);
33328   }
33329
33330   jresult = (void *)result;
33331   return jresult;
33332 }
33333
33334
33335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
33336   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
33337
33338   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
33339   {
33340     try {
33341       delete arg1;
33342     } CALL_CATCH_EXCEPTION();
33343   }
33344
33345 }
33346
33347
33348 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
33349   bool jresult ;
33350   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
33351   bool result;
33352
33353   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
33354   {
33355     try {
33356       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);
33357     } CALL_CATCH_EXCEPTION(0);
33358   }
33359
33360   jresult = result;
33361   return jresult;
33362 }
33363
33364
33365 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
33366   unsigned long jresult ;
33367   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
33368   std::size_t result;
33369
33370   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
33371   {
33372     try {
33373       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);
33374     } CALL_CATCH_EXCEPTION(0);
33375   }
33376
33377   jresult = (unsigned long)result;
33378   return jresult;
33379 }
33380
33381
33382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
33383   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
33384   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
33385
33386   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
33387   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
33388   {
33389     try {
33390       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
33391     } CALL_CATCH_EXCEPTION();
33392   }
33393
33394 }
33395
33396
33397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
33398   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
33399   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
33400
33401   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
33402   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
33403   {
33404     try {
33405       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
33406     } CALL_CATCH_EXCEPTION();
33407   }
33408
33409 }
33410
33411
33412 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
33413   bool jresult ;
33414   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
33415   Dali::Actor arg2 ;
33416   Dali::HoverEvent *arg3 = 0 ;
33417   Dali::Actor *argp2 ;
33418   bool result;
33419
33420   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
33421   argp2 = (Dali::Actor *)jarg2;
33422   if (!argp2) {
33423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33424     return 0;
33425   }
33426   arg2 = *argp2;
33427   arg3 = (Dali::HoverEvent *)jarg3;
33428   if (!arg3) {
33429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
33430     return 0;
33431   }
33432   {
33433     try {
33434       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
33435     } CALL_CATCH_EXCEPTION(0);
33436   }
33437
33438   jresult = result;
33439   return jresult;
33440 }
33441
33442
33443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
33444   void * jresult ;
33445   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
33446
33447   {
33448     try {
33449       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
33450     } CALL_CATCH_EXCEPTION(0);
33451   }
33452
33453   jresult = (void *)result;
33454   return jresult;
33455 }
33456
33457
33458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
33459   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
33460
33461   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
33462   {
33463     try {
33464       delete arg1;
33465     } CALL_CATCH_EXCEPTION();
33466   }
33467
33468 }
33469
33470
33471 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
33472   bool jresult ;
33473   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
33474   bool result;
33475
33476   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
33477   {
33478     try {
33479       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);
33480     } CALL_CATCH_EXCEPTION(0);
33481   }
33482
33483   jresult = result;
33484   return jresult;
33485 }
33486
33487
33488 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
33489   unsigned long jresult ;
33490   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
33491   std::size_t result;
33492
33493   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
33494   {
33495     try {
33496       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);
33497     } CALL_CATCH_EXCEPTION(0);
33498   }
33499
33500   jresult = (unsigned long)result;
33501   return jresult;
33502 }
33503
33504
33505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
33506   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
33507   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
33508
33509   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
33510   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
33511   {
33512     try {
33513       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
33514     } CALL_CATCH_EXCEPTION();
33515   }
33516
33517 }
33518
33519
33520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
33521   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
33522   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
33523
33524   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
33525   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
33526   {
33527     try {
33528       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
33529     } CALL_CATCH_EXCEPTION();
33530   }
33531
33532 }
33533
33534
33535 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
33536   bool jresult ;
33537   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
33538   Dali::Actor arg2 ;
33539   Dali::WheelEvent *arg3 = 0 ;
33540   Dali::Actor *argp2 ;
33541   bool result;
33542
33543   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
33544   argp2 = (Dali::Actor *)jarg2;
33545   if (!argp2) {
33546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33547     return 0;
33548   }
33549   arg2 = *argp2;
33550   arg3 = (Dali::WheelEvent *)jarg3;
33551   if (!arg3) {
33552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
33553     return 0;
33554   }
33555   {
33556     try {
33557       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
33558     } CALL_CATCH_EXCEPTION(0);
33559   }
33560
33561   jresult = result;
33562   return jresult;
33563 }
33564
33565
33566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
33567   void * jresult ;
33568   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
33569
33570   {
33571     try {
33572       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
33573     } CALL_CATCH_EXCEPTION(0);
33574   }
33575
33576   jresult = (void *)result;
33577   return jresult;
33578 }
33579
33580
33581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
33582   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
33583
33584   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
33585   {
33586     try {
33587       delete arg1;
33588     } CALL_CATCH_EXCEPTION();
33589   }
33590
33591 }
33592
33593
33594 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
33595   bool jresult ;
33596   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
33597   bool result;
33598
33599   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
33600   {
33601     try {
33602       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
33603     } CALL_CATCH_EXCEPTION(0);
33604   }
33605
33606   jresult = result;
33607   return jresult;
33608 }
33609
33610
33611 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
33612   unsigned long jresult ;
33613   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
33614   std::size_t result;
33615
33616   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
33617   {
33618     try {
33619       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
33620     } CALL_CATCH_EXCEPTION(0);
33621   }
33622
33623   jresult = (unsigned long)result;
33624   return jresult;
33625 }
33626
33627
33628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
33629   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
33630   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
33631
33632   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
33633   arg2 = (void (*)(Dali::Actor))jarg2;
33634   {
33635     try {
33636       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
33637     } CALL_CATCH_EXCEPTION();
33638   }
33639
33640 }
33641
33642
33643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
33644   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
33645   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
33646
33647   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
33648   arg2 = (void (*)(Dali::Actor))jarg2;
33649   {
33650     try {
33651       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
33652     } CALL_CATCH_EXCEPTION();
33653   }
33654
33655 }
33656
33657
33658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
33659   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
33660   Dali::Actor arg2 ;
33661   Dali::Actor *argp2 ;
33662
33663   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
33664   argp2 = (Dali::Actor *)jarg2;
33665   if (!argp2) {
33666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33667     return ;
33668   }
33669   arg2 = *argp2;
33670   {
33671     try {
33672       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
33673     } CALL_CATCH_EXCEPTION();
33674   }
33675
33676 }
33677
33678
33679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
33680   void * jresult ;
33681   Dali::Signal< void (Dali::Actor) > *result = 0 ;
33682
33683   {
33684     try {
33685       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
33686     } CALL_CATCH_EXCEPTION(0);
33687   }
33688
33689   jresult = (void *)result;
33690   return jresult;
33691 }
33692
33693
33694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
33695   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
33696
33697   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
33698   {
33699     try {
33700       delete arg1;
33701     } CALL_CATCH_EXCEPTION();
33702   }
33703
33704 }
33705
33706
33707 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
33708   bool jresult ;
33709   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
33710   bool result;
33711
33712   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
33713   {
33714     try {
33715       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
33716     } CALL_CATCH_EXCEPTION(0);
33717   }
33718
33719   jresult = result;
33720   return jresult;
33721 }
33722
33723
33724 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
33725   unsigned long jresult ;
33726   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
33727   std::size_t result;
33728
33729   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
33730   {
33731     try {
33732       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
33733     } CALL_CATCH_EXCEPTION(0);
33734   }
33735
33736   jresult = (unsigned long)result;
33737   return jresult;
33738 }
33739
33740
33741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
33742   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
33743   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
33744
33745   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
33746   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
33747   {
33748     try {
33749       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
33750     } CALL_CATCH_EXCEPTION();
33751   }
33752
33753 }
33754
33755
33756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
33757   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
33758   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
33759
33760   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
33761   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
33762   {
33763     try {
33764       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
33765     } CALL_CATCH_EXCEPTION();
33766   }
33767
33768 }
33769
33770
33771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
33772   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
33773   Dali::KeyEvent *arg2 = 0 ;
33774
33775   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
33776   arg2 = (Dali::KeyEvent *)jarg2;
33777   if (!arg2) {
33778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
33779     return ;
33780   }
33781   {
33782     try {
33783       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
33784     } CALL_CATCH_EXCEPTION();
33785   }
33786
33787 }
33788
33789
33790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
33791   void * jresult ;
33792   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
33793
33794   {
33795     try {
33796       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
33797     } CALL_CATCH_EXCEPTION(0);
33798   }
33799
33800   jresult = (void *)result;
33801   return jresult;
33802 }
33803
33804
33805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
33806   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
33807
33808   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
33809   {
33810     try {
33811       delete arg1;
33812     } CALL_CATCH_EXCEPTION();
33813   }
33814
33815 }
33816
33817
33818 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
33819   bool jresult ;
33820   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
33821   bool result;
33822
33823   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
33824   {
33825     try {
33826       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
33827     } CALL_CATCH_EXCEPTION(0);
33828   }
33829
33830   jresult = result;
33831   return jresult;
33832 }
33833
33834
33835 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
33836   unsigned long jresult ;
33837   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
33838   std::size_t result;
33839
33840   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
33841   {
33842     try {
33843       result = Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
33844     } CALL_CATCH_EXCEPTION(0);
33845   }
33846
33847   jresult = (unsigned long)result;
33848   return jresult;
33849 }
33850
33851
33852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
33853   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
33854   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
33855
33856   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
33857   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
33858   {
33859     try {
33860       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
33861     } CALL_CATCH_EXCEPTION();
33862   }
33863
33864 }
33865
33866
33867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
33868   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
33869   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
33870
33871   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
33872   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
33873   {
33874     try {
33875       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
33876     } CALL_CATCH_EXCEPTION();
33877   }
33878
33879 }
33880
33881
33882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
33883   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
33884   Dali::TouchEvent *arg2 = 0 ;
33885
33886   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
33887   arg2 = (Dali::TouchEvent *)jarg2;
33888   if (!arg2) {
33889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
33890     return ;
33891   }
33892   {
33893     try {
33894       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchEvent const &)*arg2);
33895     } CALL_CATCH_EXCEPTION();
33896   }
33897
33898 }
33899
33900
33901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
33902   void * jresult ;
33903   Dali::Signal< void (Dali::TouchEvent const &) > *result = 0 ;
33904
33905   {
33906     try {
33907       result = (Dali::Signal< void (Dali::TouchEvent const &) > *)new Dali::Signal< void (Dali::TouchEvent const &) >();
33908     } CALL_CATCH_EXCEPTION(0);
33909   }
33910
33911   jresult = (void *)result;
33912   return jresult;
33913 }
33914
33915
33916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
33917   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
33918
33919   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
33920   {
33921     try {
33922       delete arg1;
33923     } CALL_CATCH_EXCEPTION();
33924   }
33925
33926 }
33927
33928
33929 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
33930   bool jresult ;
33931   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
33932   bool result;
33933
33934   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
33935   {
33936     try {
33937       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
33938     } CALL_CATCH_EXCEPTION(0);
33939   }
33940
33941   jresult = result;
33942   return jresult;
33943 }
33944
33945
33946 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
33947   unsigned long jresult ;
33948   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
33949   std::size_t result;
33950
33951   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
33952   {
33953     try {
33954       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
33955     } CALL_CATCH_EXCEPTION(0);
33956   }
33957
33958   jresult = (unsigned long)result;
33959   return jresult;
33960 }
33961
33962
33963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
33964   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
33965   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
33966
33967   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
33968   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
33969   {
33970     try {
33971       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
33972     } CALL_CATCH_EXCEPTION();
33973   }
33974
33975 }
33976
33977
33978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
33979   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
33980   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
33981
33982   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
33983   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
33984   {
33985     try {
33986       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
33987     } CALL_CATCH_EXCEPTION();
33988   }
33989
33990 }
33991
33992
33993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
33994   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
33995   Dali::WheelEvent *arg2 = 0 ;
33996
33997   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
33998   arg2 = (Dali::WheelEvent *)jarg2;
33999   if (!arg2) {
34000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34001     return ;
34002   }
34003   {
34004     try {
34005       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
34006     } CALL_CATCH_EXCEPTION();
34007   }
34008
34009 }
34010
34011
34012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
34013   void * jresult ;
34014   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
34015
34016   {
34017     try {
34018       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
34019     } CALL_CATCH_EXCEPTION(0);
34020   }
34021
34022   jresult = (void *)result;
34023   return jresult;
34024 }
34025
34026
34027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
34028   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
34029
34030   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
34031   {
34032     try {
34033       delete arg1;
34034     } CALL_CATCH_EXCEPTION();
34035   }
34036
34037 }
34038
34039
34040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
34041   void * jresult ;
34042   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
34043
34044   {
34045     try {
34046       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
34047     } CALL_CATCH_EXCEPTION(0);
34048   }
34049
34050   jresult = (void *)result;
34051   return jresult;
34052 }
34053
34054
34055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
34056   void * jresult ;
34057   Dali::Radian arg1 ;
34058   Dali::Radian arg2 ;
34059   Dali::Radian *argp1 ;
34060   Dali::Radian *argp2 ;
34061   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
34062
34063   argp1 = (Dali::Radian *)jarg1;
34064   if (!argp1) {
34065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
34066     return 0;
34067   }
34068   arg1 = *argp1;
34069   argp2 = (Dali::Radian *)jarg2;
34070   if (!argp2) {
34071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
34072     return 0;
34073   }
34074   arg2 = *argp2;
34075   {
34076     try {
34077       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
34078     } CALL_CATCH_EXCEPTION(0);
34079   }
34080
34081   jresult = (void *)result;
34082   return jresult;
34083 }
34084
34085
34086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
34087   void * jresult ;
34088   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
34089   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
34090
34091   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
34092   if (!arg1) {
34093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
34094     return 0;
34095   }
34096   {
34097     try {
34098       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
34099     } CALL_CATCH_EXCEPTION(0);
34100   }
34101
34102   jresult = (void *)result;
34103   return jresult;
34104 }
34105
34106
34107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
34108   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
34109   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
34110
34111   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
34112   arg2 = (Dali::Radian *)jarg2;
34113   if (arg1) (arg1)->first = *arg2;
34114 }
34115
34116
34117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
34118   void * jresult ;
34119   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
34120   Dali::Radian *result = 0 ;
34121
34122   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
34123   result = (Dali::Radian *)& ((arg1)->first);
34124   jresult = (void *)result;
34125   return jresult;
34126 }
34127
34128
34129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
34130   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
34131   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
34132
34133   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
34134   arg2 = (Dali::Radian *)jarg2;
34135   if (arg1) (arg1)->second = *arg2;
34136 }
34137
34138
34139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
34140   void * jresult ;
34141   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
34142   Dali::Radian *result = 0 ;
34143
34144   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
34145   result = (Dali::Radian *)& ((arg1)->second);
34146   jresult = (void *)result;
34147   return jresult;
34148 }
34149
34150
34151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
34152   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
34153
34154   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
34155   {
34156     try {
34157       delete arg1;
34158     } CALL_CATCH_EXCEPTION();
34159   }
34160
34161 }
34162
34163
34164 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
34165   bool jresult ;
34166   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
34167   bool result;
34168
34169   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
34170   {
34171     try {
34172       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);
34173     } CALL_CATCH_EXCEPTION(0);
34174   }
34175
34176   jresult = result;
34177   return jresult;
34178 }
34179
34180
34181 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
34182   unsigned long jresult ;
34183   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
34184   std::size_t result;
34185
34186   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
34187   {
34188     try {
34189       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);
34190     } CALL_CATCH_EXCEPTION(0);
34191   }
34192
34193   jresult = (unsigned long)result;
34194   return jresult;
34195 }
34196
34197
34198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
34199   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
34200   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
34201
34202   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
34203   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
34204   {
34205     try {
34206       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
34207     } CALL_CATCH_EXCEPTION();
34208   }
34209
34210 }
34211
34212
34213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
34214   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
34215   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
34216
34217   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
34218   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
34219   {
34220     try {
34221       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
34222     } CALL_CATCH_EXCEPTION();
34223   }
34224
34225 }
34226
34227
34228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
34229   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
34230   Dali::Actor arg2 ;
34231   Dali::PanGesture *arg3 = 0 ;
34232   Dali::Actor *argp2 ;
34233
34234   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
34235   argp2 = (Dali::Actor *)jarg2;
34236   if (!argp2) {
34237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34238     return ;
34239   }
34240   arg2 = *argp2;
34241   arg3 = (Dali::PanGesture *)jarg3;
34242   if (!arg3) {
34243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
34244     return ;
34245   }
34246   {
34247     try {
34248       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
34249     } CALL_CATCH_EXCEPTION();
34250   }
34251
34252 }
34253
34254
34255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
34256   void * jresult ;
34257   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
34258
34259   {
34260     try {
34261       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
34262     } CALL_CATCH_EXCEPTION(0);
34263   }
34264
34265   jresult = (void *)result;
34266   return jresult;
34267 }
34268
34269
34270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
34271   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
34272
34273   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
34274   {
34275     try {
34276       delete arg1;
34277     } CALL_CATCH_EXCEPTION();
34278   }
34279
34280 }
34281
34282
34283 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
34284   bool jresult ;
34285   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
34286   bool result;
34287
34288   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
34289   {
34290     try {
34291       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);
34292     } CALL_CATCH_EXCEPTION(0);
34293   }
34294
34295   jresult = result;
34296   return jresult;
34297 }
34298
34299
34300 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
34301   unsigned long jresult ;
34302   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
34303   std::size_t result;
34304
34305   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
34306   {
34307     try {
34308       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);
34309     } CALL_CATCH_EXCEPTION(0);
34310   }
34311
34312   jresult = (unsigned long)result;
34313   return jresult;
34314 }
34315
34316
34317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
34318   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
34319   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
34320
34321   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
34322   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
34323   {
34324     try {
34325       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
34326     } CALL_CATCH_EXCEPTION();
34327   }
34328
34329 }
34330
34331
34332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
34333   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
34334   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
34335
34336   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
34337   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
34338   {
34339     try {
34340       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
34341     } CALL_CATCH_EXCEPTION();
34342   }
34343
34344 }
34345
34346
34347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
34348   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
34349   Dali::Actor arg2 ;
34350   Dali::PinchGesture *arg3 = 0 ;
34351   Dali::Actor *argp2 ;
34352
34353   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
34354   argp2 = (Dali::Actor *)jarg2;
34355   if (!argp2) {
34356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34357     return ;
34358   }
34359   arg2 = *argp2;
34360   arg3 = (Dali::PinchGesture *)jarg3;
34361   if (!arg3) {
34362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
34363     return ;
34364   }
34365   {
34366     try {
34367       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
34368     } CALL_CATCH_EXCEPTION();
34369   }
34370
34371 }
34372
34373
34374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
34375   void * jresult ;
34376   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
34377
34378   {
34379     try {
34380       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
34381     } CALL_CATCH_EXCEPTION(0);
34382   }
34383
34384   jresult = (void *)result;
34385   return jresult;
34386 }
34387
34388
34389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
34390   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
34391
34392   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
34393   {
34394     try {
34395       delete arg1;
34396     } CALL_CATCH_EXCEPTION();
34397   }
34398
34399 }
34400
34401
34402 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
34403   bool jresult ;
34404   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
34405   bool result;
34406
34407   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
34408   {
34409     try {
34410       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);
34411     } CALL_CATCH_EXCEPTION(0);
34412   }
34413
34414   jresult = result;
34415   return jresult;
34416 }
34417
34418
34419 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
34420   unsigned long jresult ;
34421   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
34422   std::size_t result;
34423
34424   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
34425   {
34426     try {
34427       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);
34428     } CALL_CATCH_EXCEPTION(0);
34429   }
34430
34431   jresult = (unsigned long)result;
34432   return jresult;
34433 }
34434
34435
34436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
34437   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
34438   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
34439
34440   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
34441   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
34442   {
34443     try {
34444       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
34445     } CALL_CATCH_EXCEPTION();
34446   }
34447
34448 }
34449
34450
34451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
34452   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
34453   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
34454
34455   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
34456   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
34457   {
34458     try {
34459       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
34460     } CALL_CATCH_EXCEPTION();
34461   }
34462
34463 }
34464
34465
34466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
34467   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
34468   Dali::Actor arg2 ;
34469   Dali::TapGesture *arg3 = 0 ;
34470   Dali::Actor *argp2 ;
34471
34472   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
34473   argp2 = (Dali::Actor *)jarg2;
34474   if (!argp2) {
34475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34476     return ;
34477   }
34478   arg2 = *argp2;
34479   arg3 = (Dali::TapGesture *)jarg3;
34480   if (!arg3) {
34481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
34482     return ;
34483   }
34484   {
34485     try {
34486       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
34487     } CALL_CATCH_EXCEPTION();
34488   }
34489
34490 }
34491
34492
34493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
34494   void * jresult ;
34495   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
34496
34497   {
34498     try {
34499       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
34500     } CALL_CATCH_EXCEPTION(0);
34501   }
34502
34503   jresult = (void *)result;
34504   return jresult;
34505 }
34506
34507
34508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
34509   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
34510
34511   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
34512   {
34513     try {
34514       delete arg1;
34515     } CALL_CATCH_EXCEPTION();
34516   }
34517
34518 }
34519
34520
34521 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
34522   bool jresult ;
34523   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
34524   bool result = false;
34525
34526   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
34527   {
34528     try {
34529       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);
34530     } CALL_CATCH_EXCEPTION(0);
34531   }
34532   jresult = result;
34533   return jresult;
34534 }
34535
34536 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
34537   unsigned long jresult ;
34538   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
34539   std::size_t result = 0;
34540
34541   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
34542   {
34543     try {
34544       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);
34545     }CALL_CATCH_EXCEPTION(0);
34546   }
34547   jresult = (unsigned long)result;
34548   return jresult;
34549 }
34550
34551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
34552   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
34553   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
34554
34555   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
34556   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
34557   {
34558     try {
34559       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
34560     } CALL_CATCH_EXCEPTION();
34561   }
34562 }
34563
34564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
34565   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
34566   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
34567
34568   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
34569   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
34570   {
34571     try {
34572       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
34573     } CALL_CATCH_EXCEPTION();
34574   }
34575 }
34576
34577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
34578   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
34579   Dali::Actor arg2 ;
34580   //bool arg3 ;
34581   Dali::LayoutDirection::Type arg4 ;
34582   Dali::Actor *argp2 ;
34583
34584   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
34585   argp2 = (Dali::Actor *)jarg2;
34586   if (!argp2) {
34587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34588     return ;
34589   }
34590   arg2 = *argp2;
34591   //arg3 = jarg3 ? true : false;
34592   arg4 = (Dali::LayoutDirection::Type)jarg4;
34593   {
34594     try {
34595       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
34596     } CALL_CATCH_EXCEPTION();
34597   }
34598 }
34599
34600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
34601   void * jresult ;
34602   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
34603
34604   {
34605     try {
34606       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
34607     } CALL_CATCH_EXCEPTION(0);
34608   }
34609   jresult = (void *)result;
34610   return jresult;
34611 }
34612
34613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
34614   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
34615
34616   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
34617   {
34618     try {
34619       delete arg1;
34620     } CALL_CATCH_EXCEPTION();
34621   }
34622 }
34623
34624
34625 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
34626   bool jresult ;
34627   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
34628   bool result = false;
34629
34630   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
34631   {
34632     try {
34633       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);
34634     } CALL_CATCH_EXCEPTION(0);
34635   }
34636   jresult = result;
34637   return jresult;
34638 }
34639
34640
34641 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
34642   unsigned long jresult ;
34643   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
34644   std::size_t result;
34645
34646   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
34647   {
34648     try {
34649       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);
34650     } CALL_CATCH_EXCEPTION(0);
34651   }
34652
34653   jresult = (unsigned long)result;
34654   return jresult;
34655 }
34656
34657
34658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
34659   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
34660   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
34661
34662   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
34663   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
34664   {
34665     try {
34666       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
34667     } CALL_CATCH_EXCEPTION();
34668   }
34669
34670 }
34671
34672
34673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
34674   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
34675   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
34676
34677   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
34678   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
34679   {
34680     try {
34681       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
34682     } CALL_CATCH_EXCEPTION();
34683   }
34684
34685 }
34686
34687
34688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, bool jarg3, int jarg4) {
34689   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
34690   Dali::Actor arg2 ;
34691   bool arg3 ;
34692   Dali::DevelActor::VisibilityChange::Type arg4 ;
34693   Dali::Actor *argp2 ;
34694
34695   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
34696   argp2 = (Dali::Actor *)jarg2;
34697   if (!argp2) {
34698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34699     return ;
34700   }
34701   arg2 = *argp2;
34702   arg3 = jarg3 ? true : false;
34703   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
34704   {
34705     try {
34706       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
34707     } CALL_CATCH_EXCEPTION();
34708   }
34709
34710 }
34711
34712
34713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
34714   void * jresult ;
34715   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
34716
34717   {
34718     try {
34719       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
34720     } CALL_CATCH_EXCEPTION(0);
34721   }
34722
34723   jresult = (void *)result;
34724   return jresult;
34725 }
34726
34727
34728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
34729   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
34730
34731   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
34732   {
34733     try {
34734       delete arg1;
34735     } CALL_CATCH_EXCEPTION();
34736   }
34737
34738 }
34739
34740
34741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
34742   void * jresult ;
34743   Dali::Timer *result = 0 ;
34744
34745   {
34746     try {
34747       result = (Dali::Timer *)new Dali::Timer();
34748     } CALL_CATCH_EXCEPTION(0);
34749   }
34750
34751   jresult = (void *)result;
34752   return jresult;
34753 }
34754
34755
34756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
34757   void * jresult ;
34758   unsigned int arg1 ;
34759   Dali::Timer result;
34760
34761   arg1 = (unsigned int)jarg1;
34762   {
34763     try {
34764       result = Dali::Timer::New(arg1);
34765     } CALL_CATCH_EXCEPTION(0);
34766   }
34767
34768   jresult = new Dali::Timer((const Dali::Timer &)result);
34769   return jresult;
34770 }
34771
34772
34773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
34774   void * jresult ;
34775   Dali::Timer *arg1 = 0 ;
34776   Dali::Timer *result = 0 ;
34777
34778   arg1 = (Dali::Timer *)jarg1;
34779   if (!arg1) {
34780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
34781     return 0;
34782   }
34783   {
34784     try {
34785       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
34786     } CALL_CATCH_EXCEPTION(0);
34787   }
34788
34789   jresult = (void *)result;
34790   return jresult;
34791 }
34792
34793
34794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
34795   void * jresult ;
34796   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
34797   Dali::Timer *arg2 = 0 ;
34798   Dali::Timer *result = 0 ;
34799
34800   arg1 = (Dali::Timer *)jarg1;
34801   arg2 = (Dali::Timer *)jarg2;
34802   if (!arg2) {
34803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
34804     return 0;
34805   }
34806   {
34807     try {
34808       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
34809     } CALL_CATCH_EXCEPTION(0);
34810   }
34811
34812   jresult = (void *)result;
34813   return jresult;
34814 }
34815
34816
34817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
34818   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
34819
34820   arg1 = (Dali::Timer *)jarg1;
34821   {
34822     try {
34823       delete arg1;
34824     } CALL_CATCH_EXCEPTION();
34825   }
34826
34827 }
34828
34829
34830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
34831   void * jresult ;
34832   Dali::BaseHandle arg1 ;
34833   Dali::BaseHandle *argp1 ;
34834   Dali::Timer result;
34835
34836   argp1 = (Dali::BaseHandle *)jarg1;
34837   if (!argp1) {
34838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
34839     return 0;
34840   }
34841   arg1 = *argp1;
34842   {
34843     try {
34844       result = Dali::Timer::DownCast(arg1);
34845     } CALL_CATCH_EXCEPTION(0);
34846   }
34847
34848   jresult = new Dali::Timer((const Dali::Timer &)result);
34849   return jresult;
34850 }
34851
34852
34853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
34854   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
34855
34856   arg1 = (Dali::Timer *)jarg1;
34857   {
34858     try {
34859       (arg1)->Start();
34860     } CALL_CATCH_EXCEPTION();
34861   }
34862
34863 }
34864
34865
34866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
34867   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
34868
34869   arg1 = (Dali::Timer *)jarg1;
34870   {
34871     try {
34872       (arg1)->Stop();
34873     } CALL_CATCH_EXCEPTION();
34874   }
34875
34876 }
34877
34878
34879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
34880   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
34881   unsigned int arg2 ;
34882
34883   arg1 = (Dali::Timer *)jarg1;
34884   arg2 = (unsigned int)jarg2;
34885   {
34886     try {
34887       (arg1)->SetInterval(arg2);
34888     } CALL_CATCH_EXCEPTION();
34889   }
34890
34891 }
34892
34893
34894 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
34895   unsigned int jresult ;
34896   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
34897   unsigned int result;
34898
34899   arg1 = (Dali::Timer *)jarg1;
34900   {
34901     try {
34902       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
34903     } CALL_CATCH_EXCEPTION(0);
34904   }
34905
34906   jresult = result;
34907   return jresult;
34908 }
34909
34910
34911 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
34912   bool jresult ;
34913   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
34914   bool result;
34915
34916   arg1 = (Dali::Timer *)jarg1;
34917   {
34918     try {
34919       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
34920     } CALL_CATCH_EXCEPTION(0);
34921   }
34922
34923   jresult = result;
34924   return jresult;
34925 }
34926
34927
34928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
34929   void * jresult ;
34930   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
34931   Dali::Timer::TimerSignalType *result = 0 ;
34932
34933   arg1 = (Dali::Timer *)jarg1;
34934   {
34935     try {
34936       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
34937     } CALL_CATCH_EXCEPTION(0);
34938   }
34939
34940   jresult = (void *)result;
34941   return jresult;
34942 }
34943
34944
34945 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
34946   bool jresult ;
34947   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
34948   bool result;
34949
34950   arg1 = (Dali::Signal< bool () > *)jarg1;
34951   {
34952     try {
34953       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
34954     } CALL_CATCH_EXCEPTION(0);
34955   }
34956
34957   jresult = result;
34958   return jresult;
34959 }
34960
34961
34962 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
34963   unsigned long jresult ;
34964   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
34965   std::size_t result;
34966
34967   arg1 = (Dali::Signal< bool () > *)jarg1;
34968   {
34969     try {
34970       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
34971     } CALL_CATCH_EXCEPTION(0);
34972   }
34973
34974   jresult = (unsigned long)result;
34975   return jresult;
34976 }
34977
34978
34979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
34980   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
34981   bool (*arg2)() = (bool (*)()) 0 ;
34982
34983   arg1 = (Dali::Signal< bool () > *)jarg1;
34984   arg2 = (bool (*)())jarg2;
34985   {
34986     try {
34987       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
34988     } CALL_CATCH_EXCEPTION();
34989   }
34990
34991 }
34992
34993
34994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
34995   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
34996   bool (*arg2)() = (bool (*)()) 0 ;
34997
34998   arg1 = (Dali::Signal< bool () > *)jarg1;
34999   arg2 = (bool (*)())jarg2;
35000   {
35001     try {
35002       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
35003     } CALL_CATCH_EXCEPTION();
35004   }
35005
35006 }
35007
35008
35009 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
35010   bool jresult ;
35011   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
35012   bool result;
35013
35014   arg1 = (Dali::Signal< bool () > *)jarg1;
35015   {
35016     try {
35017       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
35018     } CALL_CATCH_EXCEPTION(0);
35019   }
35020
35021   jresult = result;
35022   return jresult;
35023 }
35024
35025
35026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
35027   void * jresult ;
35028   Dali::Signal< bool () > *result = 0 ;
35029
35030   {
35031     try {
35032       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
35033     } CALL_CATCH_EXCEPTION(0);
35034   }
35035
35036   jresult = (void *)result;
35037   return jresult;
35038 }
35039
35040
35041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
35042   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
35043
35044   arg1 = (Dali::Signal< bool () > *)jarg1;
35045   {
35046     try {
35047       delete arg1;
35048     } CALL_CATCH_EXCEPTION();
35049   }
35050
35051 }
35052
35053
35054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
35055   int jresult ;
35056   int result;
35057
35058   {
35059     try {
35060       result = (int)Dali::Toolkit::Visual::Property::TYPE;
35061     } CALL_CATCH_EXCEPTION(0);
35062   }
35063
35064   jresult = (int)result;
35065   return jresult;
35066 }
35067
35068
35069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
35070   int jresult ;
35071   int result;
35072
35073   {
35074     try {
35075       result = (int)Dali::Toolkit::Visual::Property::SHADER;
35076     } CALL_CATCH_EXCEPTION(0);
35077   }
35078
35079   jresult = (int)result;
35080   return jresult;
35081 }
35082
35083
35084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
35085   int jresult ;
35086   int result;
35087
35088   {
35089     try {
35090       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
35091     } CALL_CATCH_EXCEPTION(0);
35092   }
35093
35094   jresult = (int)result;
35095   return jresult;
35096 }
35097
35098
35099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
35100   int jresult ;
35101   int result;
35102
35103   {
35104     try {
35105       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
35106     } CALL_CATCH_EXCEPTION(0);
35107   }
35108
35109   jresult = (int)result;
35110   return jresult;
35111 }
35112
35113
35114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
35115   int jresult ;
35116   int result;
35117
35118   {
35119     try {
35120       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
35121     } CALL_CATCH_EXCEPTION(0);
35122   }
35123
35124   jresult = (int)result;
35125   return jresult;
35126 }
35127
35128
35129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
35130   int jresult ;
35131   int result;
35132
35133   {
35134     try {
35135       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
35136     } CALL_CATCH_EXCEPTION(0);
35137   }
35138
35139   jresult = (int)result;
35140   return jresult;
35141 }
35142
35143
35144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
35145   int jresult ;
35146   int result;
35147
35148   {
35149     try {
35150       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
35151     } CALL_CATCH_EXCEPTION(0);
35152   }
35153
35154   jresult = (int)result;
35155   return jresult;
35156 }
35157
35158
35159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
35160   int jresult ;
35161   int result;
35162
35163   {
35164     try {
35165       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
35166     } CALL_CATCH_EXCEPTION(0);
35167   }
35168
35169   jresult = (int)result;
35170   return jresult;
35171 }
35172
35173
35174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
35175   int jresult ;
35176   int result;
35177
35178   {
35179     try {
35180       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
35181     } CALL_CATCH_EXCEPTION(0);
35182   }
35183
35184   jresult = (int)result;
35185   return jresult;
35186 }
35187
35188
35189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
35190   int jresult ;
35191   int result;
35192
35193   {
35194     try {
35195       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
35196     } CALL_CATCH_EXCEPTION(0);
35197   }
35198
35199   jresult = (int)result;
35200   return jresult;
35201 }
35202
35203
35204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
35205   int jresult ;
35206   int result;
35207
35208   {
35209     try {
35210       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
35211     } CALL_CATCH_EXCEPTION(0);
35212   }
35213
35214   jresult = (int)result;
35215   return jresult;
35216 }
35217
35218
35219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
35220   int jresult ;
35221   int result;
35222
35223   {
35224     try {
35225       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
35226     } CALL_CATCH_EXCEPTION(0);
35227   }
35228
35229   jresult = (int)result;
35230   return jresult;
35231 }
35232
35233
35234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
35235   int jresult ;
35236   int result;
35237
35238   {
35239     try {
35240       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
35241     } CALL_CATCH_EXCEPTION(0);
35242   }
35243
35244   jresult = (int)result;
35245   return jresult;
35246 }
35247
35248
35249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
35250   int jresult ;
35251   int result;
35252
35253   {
35254     try {
35255       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
35256     } CALL_CATCH_EXCEPTION(0);
35257   }
35258
35259   jresult = (int)result;
35260   return jresult;
35261 }
35262
35263
35264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
35265   int jresult ;
35266   int result;
35267
35268   {
35269     try {
35270       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
35271     } CALL_CATCH_EXCEPTION(0);
35272   }
35273
35274   jresult = (int)result;
35275   return jresult;
35276 }
35277
35278
35279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
35280   int jresult ;
35281   int result;
35282
35283   {
35284     try {
35285       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
35286     } CALL_CATCH_EXCEPTION(0);
35287   }
35288
35289   jresult = (int)result;
35290   return jresult;
35291 }
35292
35293
35294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
35295   int jresult ;
35296   int result;
35297
35298   {
35299     try {
35300       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
35301     } CALL_CATCH_EXCEPTION(0);
35302   }
35303
35304   jresult = (int)result;
35305   return jresult;
35306 }
35307
35308
35309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
35310   int jresult ;
35311   int result;
35312
35313   {
35314     try {
35315       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
35316     } CALL_CATCH_EXCEPTION(0);
35317   }
35318
35319   jresult = (int)result;
35320   return jresult;
35321 }
35322
35323
35324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
35325   int jresult ;
35326   int result;
35327
35328   {
35329     try {
35330       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
35331     } CALL_CATCH_EXCEPTION(0);
35332   }
35333
35334   jresult = (int)result;
35335   return jresult;
35336 }
35337
35338
35339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
35340   int jresult ;
35341   int result;
35342
35343   {
35344     try {
35345       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
35346     } CALL_CATCH_EXCEPTION(0);
35347   }
35348
35349   jresult = (int)result;
35350   return jresult;
35351 }
35352
35353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
35354   int jresult ;
35355   int result;
35356
35357   {
35358     try {
35359       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
35360     } CALL_CATCH_EXCEPTION(0);
35361   }
35362
35363   jresult = (int)result;
35364   return jresult;
35365 }
35366
35367
35368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
35369   int jresult ;
35370   int result;
35371   {
35372     try
35373     {
35374       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
35375     } CALL_CATCH_EXCEPTION(0);
35376   }
35377
35378   jresult = (int)result;
35379   return jresult;
35380 }
35381
35382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
35383   int jresult ;
35384   int result;
35385   {
35386     try
35387     {
35388       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
35389     } CALL_CATCH_EXCEPTION(0);
35390   }
35391
35392   jresult = (int)result;
35393   return jresult;
35394 }
35395
35396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
35397   int jresult ;
35398   int result;
35399   {
35400     try
35401     {
35402       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
35403     } CALL_CATCH_EXCEPTION(0);
35404   }
35405
35406   jresult = (int)result;
35407   return jresult;
35408 }
35409
35410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
35411   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
35412 }
35413
35414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
35415   int jresult ;
35416   int result;
35417   {
35418     try
35419     {
35420       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
35421     } CALL_CATCH_EXCEPTION(0);
35422   }
35423
35424   jresult = (int)result;
35425   return jresult;
35426 }
35427
35428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
35429   int jresult ;
35430   int result;
35431   {
35432     try
35433     {
35434       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
35435     } CALL_CATCH_EXCEPTION(0);
35436   }
35437
35438   jresult = (int)result;
35439   return jresult;
35440 }
35441
35442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
35443   int jresult ;
35444   int result;
35445
35446   {
35447     try {
35448       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
35449     } CALL_CATCH_EXCEPTION(0);
35450   }
35451
35452   jresult = (int)result;
35453   return jresult;
35454 }
35455
35456
35457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
35458   int jresult ;
35459   int result;
35460
35461   {
35462     try {
35463       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
35464     } CALL_CATCH_EXCEPTION(0);
35465   }
35466
35467   jresult = (int)result;
35468   return jresult;
35469 }
35470
35471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
35472   int jresult ;
35473   int result;
35474   {
35475     try
35476     {
35477       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
35478     } CALL_CATCH_EXCEPTION(0);
35479   }
35480
35481   jresult = (int)result;
35482   return jresult;
35483 }
35484
35485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
35486   int jresult ;
35487   int result;
35488   {
35489     try
35490     {
35491       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
35492     } CALL_CATCH_EXCEPTION(0);
35493   }
35494
35495   jresult = (int)result;
35496   return jresult;
35497 }
35498
35499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
35500   int jresult ;
35501   int result;
35502   {
35503     try
35504     {
35505       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
35506     } CALL_CATCH_EXCEPTION(0);
35507   }
35508
35509   jresult = (int)result;
35510   return jresult;
35511 }
35512
35513
35514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
35515   int jresult ;
35516   int result;
35517   {
35518     try
35519     {
35520       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
35521     } CALL_CATCH_EXCEPTION(0);
35522   }
35523
35524   jresult = (int)result;
35525   return jresult;
35526 }
35527
35528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
35529   int jresult ;
35530   int result;
35531   {
35532     try
35533     {
35534       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
35535     } CALL_CATCH_EXCEPTION(0);
35536   }
35537
35538   jresult = (int)result;
35539   return jresult;
35540 }
35541
35542
35543
35544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
35545   int jresult ;
35546   int result;
35547
35548   {
35549     try {
35550       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
35551     } CALL_CATCH_EXCEPTION(0);
35552   }
35553
35554   jresult = (int)result;
35555   return jresult;
35556 }
35557
35558
35559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
35560   int jresult ;
35561   int result;
35562
35563   {
35564     try {
35565       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
35566     } CALL_CATCH_EXCEPTION(0);
35567   }
35568
35569   jresult = (int)result;
35570   return jresult;
35571 }
35572
35573
35574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
35575   int jresult ;
35576   int result;
35577
35578   {
35579     try {
35580       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
35581     } CALL_CATCH_EXCEPTION(0);
35582   }
35583
35584   jresult = (int)result;
35585   return jresult;
35586 }
35587
35588
35589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
35590   int jresult ;
35591   int result;
35592
35593   {
35594     try {
35595       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
35596     } CALL_CATCH_EXCEPTION(0);
35597   }
35598
35599   jresult = (int)result;
35600   return jresult;
35601 }
35602
35603
35604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
35605   int jresult ;
35606   int result;
35607
35608   {
35609     try {
35610       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
35611     } CALL_CATCH_EXCEPTION(0);
35612   }
35613
35614   jresult = (int)result;
35615   return jresult;
35616 }
35617
35618
35619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
35620   int jresult ;
35621   int result;
35622
35623   {
35624     try {
35625       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
35626     } CALL_CATCH_EXCEPTION(0);
35627   }
35628
35629   jresult = (int)result;
35630   return jresult;
35631 }
35632
35633
35634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
35635   int jresult ;
35636   int result;
35637
35638   {
35639     try {
35640       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
35641     } CALL_CATCH_EXCEPTION(0);
35642   }
35643
35644   jresult = (int)result;
35645   return jresult;
35646 }
35647
35648 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
35649   int jresult ;
35650   int result;
35651
35652   {
35653     try {
35654       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
35655     } CALL_CATCH_EXCEPTION(0);
35656   }
35657
35658   jresult = (int)result;
35659   return jresult;
35660 }
35661
35662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
35663   int jresult ;
35664   int result;
35665
35666   {
35667     try {
35668       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
35669     } CALL_CATCH_EXCEPTION(0);
35670   }
35671
35672   jresult = (int)result;
35673   return jresult;
35674 }
35675
35676
35677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
35678   int jresult ;
35679   int result;
35680
35681   {
35682     try {
35683       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
35684     } CALL_CATCH_EXCEPTION(0);
35685   }
35686
35687   jresult = (int)result;
35688   return jresult;
35689 }
35690
35691
35692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
35693   int jresult ;
35694   int result;
35695
35696   {
35697     try {
35698       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
35699     } CALL_CATCH_EXCEPTION(0);
35700   }
35701
35702   jresult = (int)result;
35703   return jresult;
35704 }
35705
35706
35707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
35708   int jresult ;
35709   int result;
35710
35711   {
35712     try {
35713       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
35714     } CALL_CATCH_EXCEPTION(0);
35715   }
35716
35717   jresult = (int)result;
35718   return jresult;
35719 }
35720
35721
35722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
35723   int jresult ;
35724   int result;
35725
35726   {
35727     try {
35728       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
35729     } CALL_CATCH_EXCEPTION(0);
35730   }
35731
35732   jresult = (int)result;
35733   return jresult;
35734 }
35735
35736
35737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
35738   int jresult ;
35739   int result;
35740
35741   {
35742     try {
35743       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
35744     } CALL_CATCH_EXCEPTION(0);
35745   }
35746
35747   jresult = (int)result;
35748   return jresult;
35749 }
35750
35751
35752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
35753   int jresult ;
35754   int result;
35755
35756   {
35757     try {
35758       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
35759     } CALL_CATCH_EXCEPTION(0);
35760   }
35761
35762   jresult = (int)result;
35763   return jresult;
35764 }
35765
35766
35767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
35768   int jresult ;
35769   int result;
35770
35771   {
35772     try {
35773       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
35774     } CALL_CATCH_EXCEPTION(0);
35775   }
35776
35777   jresult = (int)result;
35778   return jresult;
35779 }
35780
35781
35782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
35783   int jresult ;
35784   int result;
35785
35786   {
35787     try {
35788       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
35789     } CALL_CATCH_EXCEPTION(0);
35790   }
35791
35792   jresult = (int)result;
35793   return jresult;
35794 }
35795
35796
35797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
35798   int jresult ;
35799   int result;
35800
35801   {
35802     try {
35803       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
35804     } CALL_CATCH_EXCEPTION(0);
35805   }
35806
35807   jresult = (int)result;
35808   return jresult;
35809 }
35810
35811
35812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
35813   int jresult ;
35814   int result;
35815
35816   {
35817     try {
35818       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
35819     } CALL_CATCH_EXCEPTION(0);
35820   }
35821
35822   jresult = (int)result;
35823   return jresult;
35824 }
35825
35826
35827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
35828   int jresult ;
35829   int result;
35830
35831   {
35832     try {
35833       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
35834     } CALL_CATCH_EXCEPTION(0);
35835   }
35836
35837   jresult = (int)result;
35838   return jresult;
35839 }
35840
35841
35842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
35843   int jresult ;
35844   int result;
35845
35846   {
35847     try {
35848       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
35849     } CALL_CATCH_EXCEPTION(0);
35850   }
35851
35852   jresult = (int)result;
35853   return jresult;
35854 }
35855
35856
35857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
35858   int jresult ;
35859   int result;
35860
35861   {
35862     try {
35863       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
35864     } CALL_CATCH_EXCEPTION(0);
35865   }
35866
35867   jresult = (int)result;
35868   return jresult;
35869 }
35870
35871
35872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
35873   int jresult ;
35874   int result;
35875
35876   {
35877     try {
35878       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
35879     } CALL_CATCH_EXCEPTION(0);
35880   }
35881
35882   jresult = (int)result;
35883   return jresult;
35884 }
35885
35886
35887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
35888   int jresult ;
35889   int result;
35890
35891   {
35892     try {
35893       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
35894     } CALL_CATCH_EXCEPTION(0);
35895   }
35896
35897   jresult = (int)result;
35898   return jresult;
35899 }
35900
35901
35902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
35903   int jresult ;
35904   int result;
35905
35906   {
35907     try {
35908       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
35909     } CALL_CATCH_EXCEPTION(0);
35910   }
35911
35912   jresult = (int)result;
35913   return jresult;
35914 }
35915
35916
35917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
35918   int jresult ;
35919   int result;
35920
35921   {
35922     try {
35923       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
35924     } CALL_CATCH_EXCEPTION(0);
35925   }
35926
35927   jresult = (int)result;
35928   return jresult;
35929 }
35930
35931
35932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
35933   int jresult ;
35934   int result;
35935
35936   {
35937     try {
35938       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
35939     } CALL_CATCH_EXCEPTION(0);
35940   }
35941
35942   jresult = (int)result;
35943   return jresult;
35944 }
35945
35946
35947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
35948   int jresult ;
35949   int result;
35950
35951   {
35952     try {
35953       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
35954     } CALL_CATCH_EXCEPTION(0);
35955   }
35956
35957   jresult = (int)result;
35958   return jresult;
35959 }
35960
35961
35962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
35963   int jresult ;
35964   int result;
35965
35966   {
35967     try {
35968       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
35969     } CALL_CATCH_EXCEPTION(0);
35970   }
35971
35972   jresult = (int)result;
35973   return jresult;
35974 }
35975
35976
35977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
35978   int jresult ;
35979   int result;
35980
35981   {
35982     try {
35983       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
35984     } CALL_CATCH_EXCEPTION(0);
35985   }
35986
35987   jresult = (int)result;
35988   return jresult;
35989 }
35990
35991
35992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
35993   int jresult ;
35994   int result;
35995
35996   {
35997     try {
35998       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
35999     } CALL_CATCH_EXCEPTION(0);
36000   }
36001
36002   jresult = (int)result;
36003   return jresult;
36004 }
36005
36006
36007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
36008   int jresult ;
36009   int result;
36010
36011   {
36012     try {
36013       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
36014     } CALL_CATCH_EXCEPTION(0);
36015   }
36016
36017   jresult = (int)result;
36018   return jresult;
36019 }
36020
36021
36022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
36023   int jresult ;
36024   int result;
36025
36026   {
36027     try {
36028       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
36029     } CALL_CATCH_EXCEPTION(0);
36030   }
36031
36032   jresult = (int)result;
36033   return jresult;
36034 }
36035
36036
36037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
36038   int jresult ;
36039   int result;
36040
36041   {
36042     try {
36043       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
36044     } CALL_CATCH_EXCEPTION(0);
36045   }
36046
36047   jresult = (int)result;
36048   return jresult;
36049 }
36050
36051
36052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
36053   int jresult ;
36054   int result;
36055
36056   {
36057     try {
36058       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
36059     } CALL_CATCH_EXCEPTION(0);
36060   }
36061
36062   jresult = (int)result;
36063   return jresult;
36064 }
36065
36066
36067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
36068   int jresult ;
36069   int result;
36070
36071   {
36072     try {
36073       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
36074     } CALL_CATCH_EXCEPTION(0);
36075   }
36076
36077   jresult = (int)result;
36078   return jresult;
36079 }
36080
36081
36082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
36083   void * jresult ;
36084   Dali::Toolkit::Builder *result = 0 ;
36085
36086   {
36087     try {
36088       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
36089     } CALL_CATCH_EXCEPTION(0);
36090   }
36091
36092   jresult = (void *)result;
36093   return jresult;
36094 }
36095
36096
36097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
36098   void * jresult ;
36099   Dali::Toolkit::Builder result;
36100
36101   {
36102     try {
36103       result = Dali::Toolkit::Builder::New();
36104     } CALL_CATCH_EXCEPTION(0);
36105   }
36106
36107   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
36108   return jresult;
36109 }
36110
36111
36112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
36113   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36114
36115   arg1 = (Dali::Toolkit::Builder *)jarg1;
36116   {
36117     try {
36118       delete arg1;
36119     } CALL_CATCH_EXCEPTION();
36120   }
36121
36122 }
36123
36124
36125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
36126   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36127   std::string *arg2 = 0 ;
36128   Dali::Toolkit::Builder::UIFormat arg3 ;
36129
36130   arg1 = (Dali::Toolkit::Builder *)jarg1;
36131   if (!jarg2) {
36132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36133     return ;
36134   }
36135   std::string arg2_str(jarg2);
36136   arg2 = &arg2_str;
36137   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
36138   {
36139     try {
36140       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
36141     } CALL_CATCH_EXCEPTION();
36142   }
36143
36144
36145   //argout typemap for const std::string&
36146
36147 }
36148
36149
36150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
36151   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36152   std::string *arg2 = 0 ;
36153
36154   arg1 = (Dali::Toolkit::Builder *)jarg1;
36155   if (!jarg2) {
36156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36157     return ;
36158   }
36159   std::string arg2_str(jarg2);
36160   arg2 = &arg2_str;
36161   {
36162     try {
36163       (arg1)->LoadFromString((std::string const &)*arg2);
36164     } CALL_CATCH_EXCEPTION();
36165   }
36166
36167
36168   //argout typemap for const std::string&
36169
36170 }
36171
36172
36173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
36174   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36175   Dali::Property::Map *arg2 = 0 ;
36176
36177   arg1 = (Dali::Toolkit::Builder *)jarg1;
36178   arg2 = (Dali::Property::Map *)jarg2;
36179   if (!arg2) {
36180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
36181     return ;
36182   }
36183   {
36184     try {
36185       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
36186     } CALL_CATCH_EXCEPTION();
36187   }
36188
36189 }
36190
36191
36192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
36193   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36194   std::string *arg2 = 0 ;
36195   Dali::Property::Value *arg3 = 0 ;
36196
36197   arg1 = (Dali::Toolkit::Builder *)jarg1;
36198   if (!jarg2) {
36199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36200     return ;
36201   }
36202   std::string arg2_str(jarg2);
36203   arg2 = &arg2_str;
36204   arg3 = (Dali::Property::Value *)jarg3;
36205   if (!arg3) {
36206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
36207     return ;
36208   }
36209   {
36210     try {
36211       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
36212     } CALL_CATCH_EXCEPTION();
36213   }
36214
36215
36216   //argout typemap for const std::string&
36217
36218 }
36219
36220
36221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
36222   void * jresult ;
36223   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36224   Dali::Property::Map *result = 0 ;
36225
36226   arg1 = (Dali::Toolkit::Builder *)jarg1;
36227   {
36228     try {
36229       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
36230     } CALL_CATCH_EXCEPTION(0);
36231   }
36232
36233   jresult = (void *)result;
36234   return jresult;
36235 }
36236
36237
36238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
36239   void * jresult ;
36240   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36241   std::string *arg2 = 0 ;
36242   Dali::Property::Value *result = 0 ;
36243
36244   arg1 = (Dali::Toolkit::Builder *)jarg1;
36245   if (!jarg2) {
36246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36247     return 0;
36248   }
36249   std::string arg2_str(jarg2);
36250   arg2 = &arg2_str;
36251   {
36252     try {
36253       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
36254     } CALL_CATCH_EXCEPTION(0);
36255   }
36256
36257   jresult = (void *)result;
36258
36259   //argout typemap for const std::string&
36260
36261   return jresult;
36262 }
36263
36264
36265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
36266   void * jresult ;
36267   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36268   std::string *arg2 = 0 ;
36269   Dali::Animation result;
36270
36271   arg1 = (Dali::Toolkit::Builder *)jarg1;
36272   if (!jarg2) {
36273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36274     return 0;
36275   }
36276   std::string arg2_str(jarg2);
36277   arg2 = &arg2_str;
36278   {
36279     try {
36280       result = (arg1)->CreateAnimation((std::string const &)*arg2);
36281     } CALL_CATCH_EXCEPTION(0);
36282   }
36283
36284   jresult = new Dali::Animation((const Dali::Animation &)result);
36285
36286   //argout typemap for const std::string&
36287
36288   return jresult;
36289 }
36290
36291
36292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
36293   void * jresult ;
36294   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36295   std::string *arg2 = 0 ;
36296   Dali::Property::Map *arg3 = 0 ;
36297   Dali::Animation result;
36298
36299   arg1 = (Dali::Toolkit::Builder *)jarg1;
36300   if (!jarg2) {
36301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36302     return 0;
36303   }
36304   std::string arg2_str(jarg2);
36305   arg2 = &arg2_str;
36306   arg3 = (Dali::Property::Map *)jarg3;
36307   if (!arg3) {
36308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
36309     return 0;
36310   }
36311   {
36312     try {
36313       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
36314     } CALL_CATCH_EXCEPTION(0);
36315   }
36316
36317   jresult = new Dali::Animation((const Dali::Animation &)result);
36318
36319   //argout typemap for const std::string&
36320
36321   return jresult;
36322 }
36323
36324
36325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
36326   void * jresult ;
36327   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36328   std::string *arg2 = 0 ;
36329   Dali::Actor arg3 ;
36330   Dali::Actor *argp3 ;
36331   Dali::Animation result;
36332
36333   arg1 = (Dali::Toolkit::Builder *)jarg1;
36334   if (!jarg2) {
36335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36336     return 0;
36337   }
36338   std::string arg2_str(jarg2);
36339   arg2 = &arg2_str;
36340   argp3 = (Dali::Actor *)jarg3;
36341   if (!argp3) {
36342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
36343     return 0;
36344   }
36345   arg3 = *argp3;
36346   {
36347     try {
36348       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
36349     } CALL_CATCH_EXCEPTION(0);
36350   }
36351
36352   jresult = new Dali::Animation((const Dali::Animation &)result);
36353
36354   //argout typemap for const std::string&
36355
36356   return jresult;
36357 }
36358
36359
36360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
36361   void * jresult ;
36362   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36363   std::string *arg2 = 0 ;
36364   Dali::Property::Map *arg3 = 0 ;
36365   Dali::Actor arg4 ;
36366   Dali::Actor *argp4 ;
36367   Dali::Animation result;
36368
36369   arg1 = (Dali::Toolkit::Builder *)jarg1;
36370   if (!jarg2) {
36371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36372     return 0;
36373   }
36374   std::string arg2_str(jarg2);
36375   arg2 = &arg2_str;
36376   arg3 = (Dali::Property::Map *)jarg3;
36377   if (!arg3) {
36378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
36379     return 0;
36380   }
36381   argp4 = (Dali::Actor *)jarg4;
36382   if (!argp4) {
36383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
36384     return 0;
36385   }
36386   arg4 = *argp4;
36387   {
36388     try {
36389       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
36390     } CALL_CATCH_EXCEPTION(0);
36391   }
36392
36393   jresult = new Dali::Animation((const Dali::Animation &)result);
36394
36395   //argout typemap for const std::string&
36396
36397   return jresult;
36398 }
36399
36400
36401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
36402   void * jresult ;
36403   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36404   std::string *arg2 = 0 ;
36405   Dali::BaseHandle result;
36406
36407   arg1 = (Dali::Toolkit::Builder *)jarg1;
36408   if (!jarg2) {
36409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36410     return 0;
36411   }
36412   std::string arg2_str(jarg2);
36413   arg2 = &arg2_str;
36414   {
36415     try {
36416       result = (arg1)->Create((std::string const &)*arg2);
36417     } CALL_CATCH_EXCEPTION(0);
36418   }
36419
36420   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
36421
36422   //argout typemap for const std::string&
36423
36424   return jresult;
36425 }
36426
36427
36428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
36429   void * jresult ;
36430   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36431   std::string *arg2 = 0 ;
36432   Dali::Property::Map *arg3 = 0 ;
36433   Dali::BaseHandle result;
36434
36435   arg1 = (Dali::Toolkit::Builder *)jarg1;
36436   if (!jarg2) {
36437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36438     return 0;
36439   }
36440   std::string arg2_str(jarg2);
36441   arg2 = &arg2_str;
36442   arg3 = (Dali::Property::Map *)jarg3;
36443   if (!arg3) {
36444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
36445     return 0;
36446   }
36447   {
36448     try {
36449       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
36450     } CALL_CATCH_EXCEPTION(0);
36451   }
36452
36453   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
36454
36455   //argout typemap for const std::string&
36456
36457   return jresult;
36458 }
36459
36460
36461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
36462   void * jresult ;
36463   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36464   std::string *arg2 = 0 ;
36465   Dali::BaseHandle result;
36466
36467   arg1 = (Dali::Toolkit::Builder *)jarg1;
36468   if (!jarg2) {
36469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36470     return 0;
36471   }
36472   std::string arg2_str(jarg2);
36473   arg2 = &arg2_str;
36474   {
36475     try {
36476       result = (arg1)->CreateFromJson((std::string const &)*arg2);
36477     } CALL_CATCH_EXCEPTION(0);
36478   }
36479
36480   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
36481
36482   //argout typemap for const std::string&
36483
36484   return jresult;
36485 }
36486
36487
36488 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
36489   bool jresult ;
36490   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36491   std::string *arg2 = 0 ;
36492   Dali::Handle *arg3 = 0 ;
36493   bool result;
36494
36495   arg1 = (Dali::Toolkit::Builder *)jarg1;
36496   if (!jarg2) {
36497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36498     return 0;
36499   }
36500   std::string arg2_str(jarg2);
36501   arg2 = &arg2_str;
36502   arg3 = (Dali::Handle *)jarg3;
36503   if (!arg3) {
36504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
36505     return 0;
36506   }
36507   {
36508     try {
36509       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
36510     } CALL_CATCH_EXCEPTION(0);
36511   }
36512
36513   jresult = result;
36514
36515   //argout typemap for const std::string&
36516
36517   return jresult;
36518 }
36519
36520
36521 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
36522   bool jresult ;
36523   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36524   Dali::Handle *arg2 = 0 ;
36525   std::string *arg3 = 0 ;
36526   bool result;
36527
36528   arg1 = (Dali::Toolkit::Builder *)jarg1;
36529   arg2 = (Dali::Handle *)jarg2;
36530   if (!arg2) {
36531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
36532     return 0;
36533   }
36534   if (!jarg3) {
36535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36536     return 0;
36537   }
36538   std::string arg3_str(jarg3);
36539   arg3 = &arg3_str;
36540   {
36541     try {
36542       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
36543     } CALL_CATCH_EXCEPTION(0);
36544   }
36545
36546   jresult = result;
36547
36548   //argout typemap for const std::string&
36549
36550   return jresult;
36551 }
36552
36553
36554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
36555   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36556   Dali::Actor arg2 ;
36557   Dali::Actor *argp2 ;
36558
36559   arg1 = (Dali::Toolkit::Builder *)jarg1;
36560   argp2 = (Dali::Actor *)jarg2;
36561   if (!argp2) {
36562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
36563     return ;
36564   }
36565   arg2 = *argp2;
36566   {
36567     try {
36568       (arg1)->AddActors(arg2);
36569     } CALL_CATCH_EXCEPTION();
36570   }
36571
36572 }
36573
36574
36575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
36576   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36577   std::string *arg2 = 0 ;
36578   Dali::Actor arg3 ;
36579   Dali::Actor *argp3 ;
36580
36581   arg1 = (Dali::Toolkit::Builder *)jarg1;
36582   if (!jarg2) {
36583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36584     return ;
36585   }
36586   std::string arg2_str(jarg2);
36587   arg2 = &arg2_str;
36588   argp3 = (Dali::Actor *)jarg3;
36589   if (!argp3) {
36590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
36591     return ;
36592   }
36593   arg3 = *argp3;
36594   {
36595     try {
36596       (arg1)->AddActors((std::string const &)*arg2,arg3);
36597     } CALL_CATCH_EXCEPTION();
36598   }
36599
36600
36601   //argout typemap for const std::string&
36602
36603 }
36604
36605
36606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
36607   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36608   std::string *arg2 = 0 ;
36609
36610   arg1 = (Dali::Toolkit::Builder *)jarg1;
36611   if (!jarg2) {
36612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36613     return ;
36614   }
36615   std::string arg2_str(jarg2);
36616   arg2 = &arg2_str;
36617   {
36618     try {
36619       (arg1)->CreateRenderTask((std::string const &)*arg2);
36620     } CALL_CATCH_EXCEPTION();
36621   }
36622
36623
36624   //argout typemap for const std::string&
36625
36626 }
36627
36628
36629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
36630   void * jresult ;
36631   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36632   std::string *arg2 = 0 ;
36633   Dali::Path result;
36634
36635   arg1 = (Dali::Toolkit::Builder *)jarg1;
36636   if (!jarg2) {
36637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36638     return 0;
36639   }
36640   std::string arg2_str(jarg2);
36641   arg2 = &arg2_str;
36642   {
36643     try {
36644       result = (arg1)->GetPath((std::string const &)*arg2);
36645     } CALL_CATCH_EXCEPTION(0);
36646   }
36647
36648   jresult = new Dali::Path((const Dali::Path &)result);
36649
36650   //argout typemap for const std::string&
36651
36652   return jresult;
36653 }
36654
36655
36656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
36657   void * jresult ;
36658   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36659   std::string *arg2 = 0 ;
36660   Dali::PathConstrainer result;
36661
36662   arg1 = (Dali::Toolkit::Builder *)jarg1;
36663   if (!jarg2) {
36664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36665     return 0;
36666   }
36667   std::string arg2_str(jarg2);
36668   arg2 = &arg2_str;
36669   {
36670     try {
36671       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
36672     } CALL_CATCH_EXCEPTION(0);
36673   }
36674
36675   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
36676
36677   //argout typemap for const std::string&
36678
36679   return jresult;
36680 }
36681
36682
36683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
36684   void * jresult ;
36685   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36686   std::string *arg2 = 0 ;
36687   Dali::LinearConstrainer result;
36688
36689   arg1 = (Dali::Toolkit::Builder *)jarg1;
36690   if (!jarg2) {
36691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36692     return 0;
36693   }
36694   std::string arg2_str(jarg2);
36695   arg2 = &arg2_str;
36696   {
36697     try {
36698       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
36699     } CALL_CATCH_EXCEPTION(0);
36700   }
36701
36702   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
36703
36704   //argout typemap for const std::string&
36705
36706   return jresult;
36707 }
36708
36709
36710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
36711   void * jresult ;
36712   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36713   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
36714
36715   arg1 = (Dali::Toolkit::Builder *)jarg1;
36716   {
36717     try {
36718       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
36719     } CALL_CATCH_EXCEPTION(0);
36720   }
36721
36722   jresult = (void *)result;
36723   return jresult;
36724 }
36725
36726
36727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
36728   void * jresult ;
36729   Dali::Toolkit::TransitionData *result = 0 ;
36730
36731   {
36732     try {
36733       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
36734     } CALL_CATCH_EXCEPTION(0);
36735   }
36736
36737   jresult = (void *)result;
36738   return jresult;
36739 }
36740
36741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
36742   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
36743
36744   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
36745   {
36746     try {
36747       delete arg1;
36748     } CALL_CATCH_EXCEPTION();
36749   }
36750
36751 }
36752
36753
36754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
36755   void * jresult ;
36756   Dali::Property::Map *arg1 = 0 ;
36757   Dali::Toolkit::TransitionData result;
36758
36759   arg1 = (Dali::Property::Map *)jarg1;
36760   if (!arg1) {
36761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
36762     return 0;
36763   }
36764   {
36765     try {
36766       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
36767     } CALL_CATCH_EXCEPTION(0);
36768   }
36769
36770   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
36771   return jresult;
36772 }
36773
36774
36775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
36776   void * jresult ;
36777   Dali::Property::Array *arg1 = 0 ;
36778   Dali::Toolkit::TransitionData result;
36779
36780   arg1 = (Dali::Property::Array *)jarg1;
36781   if (!arg1) {
36782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
36783     return 0;
36784   }
36785   {
36786     try {
36787       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
36788     } CALL_CATCH_EXCEPTION(0);
36789   }
36790
36791   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
36792   return jresult;
36793 }
36794
36795
36796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
36797   void * jresult ;
36798   Dali::BaseHandle arg1 ;
36799   Dali::BaseHandle *argp1 ;
36800   Dali::Toolkit::TransitionData result;
36801
36802   argp1 = (Dali::BaseHandle *)jarg1;
36803   if (!argp1) {
36804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36805     return 0;
36806   }
36807   arg1 = *argp1;
36808   {
36809     try {
36810       result = Dali::Toolkit::TransitionData::DownCast(arg1);
36811     } CALL_CATCH_EXCEPTION(0);
36812   }
36813
36814   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
36815   return jresult;
36816 }
36817
36818
36819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
36820   void * jresult ;
36821   Dali::Toolkit::TransitionData *arg1 = 0 ;
36822   Dali::Toolkit::TransitionData *result = 0 ;
36823
36824   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
36825   if (!arg1) {
36826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
36827     return 0;
36828   }
36829   {
36830     try {
36831       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
36832     } CALL_CATCH_EXCEPTION(0);
36833   }
36834
36835   jresult = (void *)result;
36836   return jresult;
36837 }
36838
36839
36840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
36841   void * jresult ;
36842   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
36843   Dali::Toolkit::TransitionData *arg2 = 0 ;
36844   Dali::Toolkit::TransitionData *result = 0 ;
36845
36846   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
36847   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
36848   if (!arg2) {
36849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
36850     return 0;
36851   }
36852   {
36853     try {
36854       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
36855     } CALL_CATCH_EXCEPTION(0);
36856   }
36857
36858   jresult = (void *)result;
36859   return jresult;
36860 }
36861
36862
36863 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
36864   unsigned long jresult ;
36865   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
36866   size_t result;
36867
36868   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
36869   {
36870     try {
36871       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
36872     } CALL_CATCH_EXCEPTION(0);
36873   }
36874
36875   jresult = (unsigned long)result;
36876   return jresult;
36877 }
36878
36879
36880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
36881   void * jresult ;
36882   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
36883   size_t arg2 ;
36884   Dali::Property::Map result;
36885
36886   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
36887   arg2 = (size_t)jarg2;
36888   {
36889     try {
36890       result = (arg1)->GetAnimatorAt(arg2);
36891     } CALL_CATCH_EXCEPTION(0);
36892   }
36893
36894   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
36895   return jresult;
36896 }
36897
36898
36899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
36900   int jresult ;
36901   int result;
36902
36903   {
36904     try {
36905       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
36906     } CALL_CATCH_EXCEPTION(0);
36907   }
36908
36909   jresult = (int)result;
36910   return jresult;
36911 }
36912
36913
36914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
36915   int jresult ;
36916   int result;
36917
36918   {
36919     try {
36920       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
36921     } CALL_CATCH_EXCEPTION(0);
36922   }
36923
36924   jresult = (int)result;
36925   return jresult;
36926 }
36927
36928
36929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
36930   int jresult ;
36931   int result;
36932
36933   {
36934     try {
36935       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
36936     } CALL_CATCH_EXCEPTION(0);
36937   }
36938
36939   jresult = (int)result;
36940   return jresult;
36941 }
36942
36943
36944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
36945   int jresult ;
36946   int result;
36947
36948   {
36949     try {
36950       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
36951     } CALL_CATCH_EXCEPTION(0);
36952   }
36953
36954   jresult = (int)result;
36955   return jresult;
36956 }
36957
36958
36959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
36960   int jresult ;
36961   int result;
36962
36963   {
36964     try {
36965       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
36966     } CALL_CATCH_EXCEPTION(0);
36967   }
36968
36969   jresult = (int)result;
36970   return jresult;
36971 }
36972
36973
36974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
36975   int jresult ;
36976   int result;
36977
36978   {
36979     try {
36980       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
36981     } CALL_CATCH_EXCEPTION(0);
36982   }
36983
36984   jresult = (int)result;
36985   return jresult;
36986 }
36987
36988
36989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
36990   int jresult ;
36991   int result;
36992
36993   {
36994     try {
36995       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
36996     } CALL_CATCH_EXCEPTION(0);
36997   }
36998
36999   jresult = (int)result;
37000   return jresult;
37001 }
37002
37003
37004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
37005   int jresult ;
37006   int result;
37007
37008   {
37009     try {
37010       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
37011     } CALL_CATCH_EXCEPTION(0);
37012   }
37013
37014   jresult = (int)result;
37015   return jresult;
37016 }
37017
37018
37019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
37020   int jresult ;
37021   int result;
37022
37023   {
37024     try {
37025       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
37026     } CALL_CATCH_EXCEPTION(0);
37027   }
37028
37029   jresult = (int)result;
37030   return jresult;
37031 }
37032
37033
37034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
37035   int jresult ;
37036   int result;
37037
37038   {
37039     try {
37040       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
37041     } CALL_CATCH_EXCEPTION(0);
37042   }
37043
37044   jresult = (int)result;
37045   return jresult;
37046 }
37047
37048
37049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
37050   int jresult ;
37051   int result;
37052
37053   {
37054     try {
37055       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
37056     } CALL_CATCH_EXCEPTION(0);
37057   }
37058
37059   jresult = (int)result;
37060   return jresult;
37061 }
37062
37063
37064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
37065   int jresult ;
37066   int result;
37067
37068   {
37069     try {
37070       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
37071     } CALL_CATCH_EXCEPTION(0);
37072   }
37073
37074   jresult = (int)result;
37075   return jresult;
37076 }
37077
37078
37079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
37080   int jresult ;
37081   int result;
37082
37083   {
37084     try {
37085       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
37086     } CALL_CATCH_EXCEPTION(0);
37087   }
37088
37089   jresult = (int)result;
37090   return jresult;
37091 }
37092
37093
37094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
37095   int jresult ;
37096   int result;
37097
37098   {
37099     try {
37100       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
37101     } CALL_CATCH_EXCEPTION(0);
37102   }
37103
37104   jresult = (int)result;
37105   return jresult;
37106 }
37107
37108
37109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
37110   void * jresult ;
37111   Dali::Toolkit::Control result;
37112
37113   {
37114     try {
37115       result = Dali::Toolkit::Internal::Control::New(Dali::Toolkit::Internal::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
37116     } CALL_CATCH_EXCEPTION(0);
37117   }
37118
37119   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
37120   return jresult;
37121 }
37122
37123
37124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
37125   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37126   std::string *arg2 = 0 ;
37127
37128   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37129   if (!jarg2) {
37130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37131     return ;
37132   }
37133   std::string arg2_str(jarg2);
37134   arg2 = &arg2_str;
37135   {
37136     try {
37137       (arg1)->SetStyleName((std::string const &)*arg2);
37138     } CALL_CATCH_EXCEPTION();
37139   }
37140
37141
37142   //argout typemap for const std::string&
37143
37144 }
37145
37146
37147 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
37148   char * jresult ;
37149   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37150   std::string *result = 0 ;
37151
37152   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37153   {
37154     try {
37155       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
37156     } CALL_CATCH_EXCEPTION(0);
37157   }
37158
37159   jresult = SWIG_csharp_string_callback(result->c_str());
37160   return jresult;
37161 }
37162
37163
37164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
37165   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37166   Dali::Vector4 *arg2 = 0 ;
37167
37168   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37169   arg2 = (Dali::Vector4 *)jarg2;
37170   if (!arg2) {
37171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
37172     return ;
37173   }
37174   {
37175     try {
37176       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
37177     } CALL_CATCH_EXCEPTION();
37178   }
37179
37180 }
37181
37182
37183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
37184   void * jresult ;
37185   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
37186   Dali::Vector4 result;
37187
37188   arg1 = (Dali::Handle *)jarg1;
37189   {
37190     try {
37191       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
37192       if (resultMap)
37193       {
37194         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
37195         if(type && type->Get<int>() == Visual::COLOR )
37196         {
37197           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
37198           if (value)
37199           {
37200             result = value->Get<Vector4>();
37201           }
37202         }
37203       }
37204     } CALL_CATCH_EXCEPTION(0);
37205   }
37206
37207   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
37208   return jresult;
37209 }
37210
37211
37212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
37213   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37214   Dali::Property::Map *arg2 = 0 ;
37215
37216   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37217   arg2 = (Dali::Property::Map *)jarg2;
37218   if (!arg2) {
37219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
37220     return ;
37221   }
37222   {
37223     try {
37224       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
37225     } CALL_CATCH_EXCEPTION();
37226   }
37227
37228 }
37229
37230
37231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
37232   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37233
37234   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37235   {
37236     try {
37237       (arg1)->ClearBackground();
37238     } CALL_CATCH_EXCEPTION();
37239   }
37240
37241 }
37242
37243
37244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
37245   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37246   Dali::GestureType::Value arg2 ;
37247
37248   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37249   arg2 = (Dali::GestureType::Value)jarg2;
37250   {
37251     try {
37252       (arg1)->EnableGestureDetection(arg2);
37253     } CALL_CATCH_EXCEPTION();
37254   }
37255
37256 }
37257
37258
37259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
37260   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37261   Dali::GestureType::Value arg2 ;
37262
37263   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37264   arg2 = (Dali::GestureType::Value)jarg2;
37265   {
37266     try {
37267       (arg1)->DisableGestureDetection(arg2);
37268     } CALL_CATCH_EXCEPTION();
37269   }
37270
37271 }
37272
37273
37274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
37275   void * jresult ;
37276   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37277   Dali::PinchGestureDetector result;
37278
37279   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37280   {
37281     try {
37282       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
37283     } CALL_CATCH_EXCEPTION(0);
37284   }
37285
37286   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
37287   return jresult;
37288 }
37289
37290
37291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
37292   void * jresult ;
37293   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37294   Dali::PanGestureDetector result;
37295
37296   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37297   {
37298     try {
37299       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
37300     } CALL_CATCH_EXCEPTION(0);
37301   }
37302
37303   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
37304   return jresult;
37305 }
37306
37307
37308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
37309   void * jresult ;
37310   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37311   Dali::TapGestureDetector result;
37312
37313   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37314   {
37315     try {
37316       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
37317     } CALL_CATCH_EXCEPTION(0);
37318   }
37319
37320   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
37321   return jresult;
37322 }
37323
37324
37325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
37326   void * jresult ;
37327   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37328   Dali::LongPressGestureDetector result;
37329
37330   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37331   {
37332     try {
37333       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
37334     } CALL_CATCH_EXCEPTION(0);
37335   }
37336
37337   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
37338   return jresult;
37339 }
37340
37341
37342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, bool jarg2) {
37343   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37344   bool arg2 ;
37345
37346   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37347   arg2 = jarg2 ? true : false;
37348   {
37349     try {
37350       (arg1)->SetKeyboardNavigationSupport(arg2);
37351     } CALL_CATCH_EXCEPTION();
37352   }
37353
37354 }
37355
37356
37357 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
37358   bool jresult ;
37359   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37360   bool result;
37361
37362   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37363   {
37364     try {
37365       result = (bool)(arg1)->IsKeyboardNavigationSupported();
37366     } CALL_CATCH_EXCEPTION(0);
37367   }
37368
37369   jresult = result;
37370   return jresult;
37371 }
37372
37373
37374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
37375   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37376
37377   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37378   {
37379     try {
37380       (arg1)->SetKeyInputFocus();
37381     } CALL_CATCH_EXCEPTION();
37382   }
37383
37384 }
37385
37386
37387 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
37388   bool jresult ;
37389   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37390   bool result;
37391
37392   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37393   {
37394     try {
37395       result = (bool)(arg1)->HasKeyInputFocus();
37396     } CALL_CATCH_EXCEPTION(0);
37397   }
37398
37399   jresult = result;
37400   return jresult;
37401 }
37402
37403
37404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
37405   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37406
37407   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37408   {
37409     try {
37410       (arg1)->ClearKeyInputFocus();
37411     } CALL_CATCH_EXCEPTION();
37412   }
37413
37414 }
37415
37416
37417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, bool jarg2) {
37418   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37419   bool arg2 ;
37420
37421   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37422   arg2 = jarg2 ? true : false;
37423   {
37424     try {
37425       (arg1)->SetAsKeyboardFocusGroup(arg2);
37426     } CALL_CATCH_EXCEPTION();
37427   }
37428
37429 }
37430
37431
37432 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
37433   bool jresult ;
37434   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37435   bool result;
37436
37437   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37438   {
37439     try {
37440       result = (bool)(arg1)->IsKeyboardFocusGroup();
37441     } CALL_CATCH_EXCEPTION(0);
37442   }
37443
37444   jresult = result;
37445   return jresult;
37446 }
37447
37448
37449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
37450   void * jresult ;
37451   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37452   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
37453
37454   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37455   {
37456     try {
37457       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
37458     } CALL_CATCH_EXCEPTION(0);
37459   }
37460
37461   jresult = (void *)result;
37462   return jresult;
37463 }
37464
37465
37466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
37467   void * jresult ;
37468   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37469   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
37470
37471   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37472   {
37473     try {
37474       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
37475     } CALL_CATCH_EXCEPTION(0);
37476   }
37477
37478   jresult = (void *)result;
37479   return jresult;
37480 }
37481
37482
37483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
37484   void * jresult ;
37485   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37486   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
37487
37488   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37489   {
37490     try {
37491       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
37492     } CALL_CATCH_EXCEPTION(0);
37493   }
37494
37495   jresult = (void *)result;
37496   return jresult;
37497 }
37498
37499
37500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnection(void * jarg1, int jarg2) {
37501   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37502   int arg2 ;
37503   SwigDirector_ViewImpl *darg = 0;
37504
37505   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37506   arg2 = (int)jarg2;
37507   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37508   if(!darg) {
37509     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37510     return;
37511   }
37512   {
37513     try {
37514       if(darg) {
37515         (darg)->OnSceneConnection(arg2);
37516       }
37517     } CALL_CATCH_EXCEPTION();
37518   }
37519
37520 }
37521
37522
37523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
37524   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37525   int arg2 ;
37526   SwigDirector_ViewImpl *darg = 0;
37527
37528   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37529   arg2 = (int)jarg2;
37530   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37531   if(!darg) {
37532     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37533     return;
37534   }
37535   {
37536     try {
37537       if(darg) {
37538         (darg)->OnSceneConnectionSwigPublic(arg2);
37539       }
37540     } CALL_CATCH_EXCEPTION();
37541   }
37542
37543 }
37544
37545
37546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnection(void * jarg1) {
37547   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37548   SwigDirector_ViewImpl *darg = 0;
37549
37550   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37551   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37552   if(!darg) {
37553     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37554     return;
37555   }
37556   {
37557     try {
37558       if(darg) {
37559         (darg)->OnSceneDisconnection();
37560       }
37561     } CALL_CATCH_EXCEPTION();
37562   }
37563
37564 }
37565
37566
37567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnectionSwigExplicitViewImpl(void * jarg1) {
37568   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37569   SwigDirector_ViewImpl *darg = 0;
37570
37571   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37572   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37573   if(!darg) {
37574     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37575     return;
37576   }
37577   {
37578     try {
37579       if(darg) {
37580         (darg)->OnSceneDisconnectionSwigPublic();
37581       }
37582     } CALL_CATCH_EXCEPTION();
37583   }
37584
37585 }
37586
37587
37588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
37589   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37590   Dali::Actor *arg2 = 0 ;
37591   SwigDirector_ViewImpl *darg = 0;
37592
37593   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37594   arg2 = (Dali::Actor *)jarg2;
37595   if (!arg2) {
37596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37597     return ;
37598   }
37599   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37600   if(!darg) {
37601     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37602     return;
37603   }
37604   {
37605     try {
37606       if(darg) {
37607         (darg)->OnChildAdd(*arg2);
37608       }
37609     } CALL_CATCH_EXCEPTION();
37610   }
37611
37612 }
37613
37614
37615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37616   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37617   Dali::Actor *arg2 = 0 ;
37618   SwigDirector_ViewImpl *darg = 0;
37619
37620   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37621   arg2 = (Dali::Actor *)jarg2;
37622   if (!arg2) {
37623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37624     return ;
37625   }
37626   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37627   if(!darg) {
37628     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37629     return;
37630   }
37631   {
37632     try {
37633       if(darg) {
37634           (darg)->OnChildAddSwigPublic(*arg2);
37635       }
37636     } CALL_CATCH_EXCEPTION();
37637   }
37638
37639 }
37640
37641
37642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
37643   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37644   Dali::Actor *arg2 = 0 ;
37645   SwigDirector_ViewImpl *darg = 0;
37646
37647   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37648   arg2 = (Dali::Actor *)jarg2;
37649   if (!arg2) {
37650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37651     return ;
37652   }
37653   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37654   if(!darg) {
37655     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37656     return;
37657   }
37658   {
37659     try {
37660       if(darg) {
37661         (darg)->OnChildRemove(*arg2);
37662       }
37663     } CALL_CATCH_EXCEPTION();
37664   }
37665
37666 }
37667
37668
37669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37670   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37671   Dali::Actor *arg2 = 0 ;
37672   SwigDirector_ViewImpl *darg = 0;
37673
37674   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37675   arg2 = (Dali::Actor *)jarg2;
37676   if (!arg2) {
37677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37678     return ;
37679   }
37680   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37681   if(!darg) {
37682     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37683     return;
37684   }
37685   {
37686     try {
37687       if(darg) {
37688         (darg)->OnChildRemoveSwigPublic(*arg2);
37689       }
37690     } CALL_CATCH_EXCEPTION();
37691   }
37692
37693 }
37694
37695
37696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
37697   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37698   Dali::Property::Index arg2 ;
37699   Dali::Property::Value arg3 ;
37700   Dali::Property::Value *argp3 ;
37701   SwigDirector_ViewImpl *darg = 0;
37702
37703   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37704   arg2 = (Dali::Property::Index)jarg2;
37705   argp3 = (Dali::Property::Value *)jarg3;
37706   if (!argp3) {
37707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37708     return ;
37709   }
37710   arg3 = *argp3;
37711   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37712   if (!darg) {
37713     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37714     return;
37715   }
37716   {
37717     try {
37718       (darg)->OnPropertySet(arg2,arg3);
37719     } CALL_CATCH_EXCEPTION();
37720   }
37721
37722 }
37723
37724
37725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
37726   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37727   Dali::Vector3 *arg2 = 0 ;
37728   SwigDirector_ViewImpl *darg = 0;
37729
37730   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37731   arg2 = (Dali::Vector3 *)jarg2;
37732   if (!arg2) {
37733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
37734     return ;
37735   }
37736   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37737   if (!darg) {
37738     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37739     return;
37740   }
37741   {
37742     try {
37743       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
37744     } CALL_CATCH_EXCEPTION();
37745   }
37746
37747 }
37748
37749
37750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37751   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37752   Dali::Vector3 *arg2 = 0 ;
37753   SwigDirector_ViewImpl *darg = 0;
37754
37755   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37756   arg2 = (Dali::Vector3 *)jarg2;
37757   if (!arg2) {
37758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
37759     return ;
37760   }
37761   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37762   if (!darg) {
37763     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37764     return;
37765   }
37766   {
37767     try {
37768       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
37769     } CALL_CATCH_EXCEPTION();
37770   }
37771
37772 }
37773
37774
37775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
37776   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37777   Dali::Animation *arg2 = 0 ;
37778   Dali::Vector3 *arg3 = 0 ;
37779   SwigDirector_ViewImpl *darg = 0;
37780
37781   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37782   arg2 = (Dali::Animation *)jarg2;
37783   if (!arg2) {
37784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
37785     return ;
37786   }
37787   arg3 = (Dali::Vector3 *)jarg3;
37788   if (!arg3) {
37789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
37790     return ;
37791   }
37792   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37793   if (!darg) {
37794     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37795     return;
37796   }
37797   {
37798     try {
37799       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
37800     } CALL_CATCH_EXCEPTION();
37801   }
37802
37803 }
37804
37805
37806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
37807   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37808   Dali::Animation *arg2 = 0 ;
37809   Dali::Vector3 *arg3 = 0 ;
37810   SwigDirector_ViewImpl *darg = 0;
37811
37812   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37813   arg2 = (Dali::Animation *)jarg2;
37814   if (!arg2) {
37815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
37816     return ;
37817   }
37818   arg3 = (Dali::Vector3 *)jarg3;
37819   if (!arg3) {
37820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
37821     return ;
37822   }
37823   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37824   if (!darg) {
37825     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37826     return;
37827   }
37828   {
37829     try {
37830       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
37831     } CALL_CATCH_EXCEPTION();
37832   }
37833 }
37834
37835 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
37836   bool jresult ;
37837   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37838   Dali::KeyEvent *arg2 = 0 ;
37839   SwigDirector_ViewImpl *darg = 0;
37840   bool result;
37841
37842   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37843   arg2 = (Dali::KeyEvent *)jarg2;
37844   if (!arg2) {
37845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
37846     return 0;
37847   }
37848   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37849   if (!darg) {
37850     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37851     return 0;
37852   }
37853   {
37854     try {
37855       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
37856     } CALL_CATCH_EXCEPTION(0);
37857   }
37858
37859   jresult = result;
37860   return jresult;
37861 }
37862
37863
37864 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37865   bool jresult ;
37866   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37867   Dali::KeyEvent *arg2 = 0 ;
37868   SwigDirector_ViewImpl *darg = 0;
37869   bool result;
37870
37871   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37872   arg2 = (Dali::KeyEvent *)jarg2;
37873   if (!arg2) {
37874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
37875     return 0;
37876   }
37877   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37878   if (!darg) {
37879     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37880     return 0;
37881   }
37882   {
37883     try {
37884       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
37885     } CALL_CATCH_EXCEPTION(0);
37886   }
37887
37888   jresult = result;
37889   return jresult;
37890 }
37891
37892
37893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
37894   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37895   Dali::Vector2 *arg2 = 0 ;
37896   Dali::RelayoutContainer *arg3 = 0 ;
37897   SwigDirector_ViewImpl *darg = 0;
37898
37899   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37900   arg2 = (Dali::Vector2 *)jarg2;
37901   if (!arg2) {
37902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37903     return ;
37904   }
37905   arg3 = (Dali::RelayoutContainer *)jarg3;
37906   if (!arg3) {
37907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
37908     return ;
37909   }
37910   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37911   if (!darg) {
37912     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37913     return;
37914   }
37915   {
37916     try {
37917       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
37918     } CALL_CATCH_EXCEPTION();
37919   }
37920
37921 }
37922
37923
37924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
37925   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37926   Dali::Vector2 *arg2 = 0 ;
37927   Dali::RelayoutContainer *arg3 = 0 ;
37928   SwigDirector_ViewImpl *darg = 0;
37929
37930   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37931   arg2 = (Dali::Vector2 *)jarg2;
37932   if (!arg2) {
37933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37934     return ;
37935   }
37936   arg3 = (Dali::RelayoutContainer *)jarg3;
37937   if (!arg3) {
37938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
37939     return ;
37940   }
37941   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37942   if (!darg) {
37943     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37944     return;
37945   }
37946   {
37947     try {
37948       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
37949     } CALL_CATCH_EXCEPTION();
37950   }
37951
37952 }
37953
37954
37955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
37956   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37957   Dali::ResizePolicy::Type arg2 ;
37958   Dali::Dimension::Type arg3 ;
37959   SwigDirector_ViewImpl *darg = 0;
37960
37961   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37962   arg2 = (Dali::ResizePolicy::Type)jarg2;
37963   arg3 = (Dali::Dimension::Type)jarg3;
37964   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37965   if (!darg) {
37966     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37967     return;
37968   }
37969   {
37970     try {
37971       (darg)->OnSetResizePolicy(arg2,arg3);
37972     } CALL_CATCH_EXCEPTION();
37973   }
37974
37975 }
37976
37977
37978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
37979   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37980   Dali::ResizePolicy::Type arg2 ;
37981   Dali::Dimension::Type arg3 ;
37982   SwigDirector_ViewImpl *darg = 0;
37983
37984   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37985   arg2 = (Dali::ResizePolicy::Type)jarg2;
37986   arg3 = (Dali::Dimension::Type)jarg3;
37987   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37988   if (!darg) {
37989     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37990     return;
37991   }
37992   {
37993     try {
37994       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
37995     } CALL_CATCH_EXCEPTION();
37996   }
37997
37998 }
37999
38000
38001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
38002   void * jresult ;
38003   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38004   SwigDirector_ViewImpl *darg = 0;
38005   Dali::Vector3 result;
38006
38007   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38008   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38009   if (!darg) {
38010     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38011     return 0;
38012   }
38013   {
38014     try {
38015       result = (darg)->GetNaturalSize();
38016     } CALL_CATCH_EXCEPTION(0);
38017   }
38018
38019   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
38020   return jresult;
38021 }
38022
38023
38024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
38025   void * jresult ;
38026   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38027   SwigDirector_ViewImpl *darg = 0;
38028   Dali::Vector3 result;
38029
38030   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38031   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38032   if (!darg) {
38033     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38034     return 0;
38035   }
38036   {
38037     try {
38038       result = (darg)->GetNaturalSizeSwigPublic();
38039     } CALL_CATCH_EXCEPTION(0);
38040   }
38041
38042   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
38043   return jresult;
38044 }
38045
38046
38047 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
38048   float jresult ;
38049   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38050   Dali::Actor *arg2 = 0 ;
38051   Dali::Dimension::Type arg3 ;
38052   SwigDirector_ViewImpl *darg = 0;
38053   float result;
38054
38055   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38056   arg2 = (Dali::Actor *)jarg2;
38057   if (!arg2) {
38058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
38059     return 0;
38060   }
38061   arg3 = (Dali::Dimension::Type)jarg3;
38062   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38063   if (!darg) {
38064     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38065     return 0;
38066   }
38067   {
38068     try {
38069       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
38070     } CALL_CATCH_EXCEPTION(0);
38071   }
38072
38073   jresult = result;
38074   return jresult;
38075 }
38076
38077
38078 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
38079   float jresult ;
38080   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38081   Dali::Actor *arg2 = 0 ;
38082   Dali::Dimension::Type arg3 ;
38083   SwigDirector_ViewImpl *darg = 0;
38084   float result;
38085
38086   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38087   arg2 = (Dali::Actor *)jarg2;
38088   if (!arg2) {
38089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
38090     return 0;
38091   }
38092   arg3 = (Dali::Dimension::Type)jarg3;
38093   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38094   if (!darg) {
38095     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38096     return 0;
38097   }
38098   {
38099     try {
38100       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
38101     } CALL_CATCH_EXCEPTION(0);
38102   }
38103
38104   jresult = result;
38105   return jresult;
38106 }
38107
38108
38109 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
38110   float jresult ;
38111   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38112   float arg2 ;
38113   SwigDirector_ViewImpl *darg = 0;
38114   float result;
38115
38116   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38117   arg2 = (float)jarg2;
38118   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38119   if (!darg) {
38120     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38121     return 0;
38122   }
38123   {
38124     try {
38125       result = (float)(darg)->GetHeightForWidth(arg2);
38126     } CALL_CATCH_EXCEPTION(0);
38127   }
38128
38129   jresult = result;
38130   return jresult;
38131 }
38132
38133
38134 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
38135   float jresult ;
38136   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38137   float arg2 ;
38138   SwigDirector_ViewImpl *darg = 0;
38139   float result;
38140
38141   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38142   arg2 = (float)jarg2;
38143   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38144   if (!darg) {
38145     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38146     return 0;
38147   }
38148   {
38149     try {
38150       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
38151     } CALL_CATCH_EXCEPTION(0);
38152   }
38153
38154   jresult = result;
38155   return jresult;
38156 }
38157
38158
38159 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
38160   float jresult ;
38161   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38162   float arg2 ;
38163   SwigDirector_ViewImpl *darg = 0;
38164   float result;
38165
38166   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38167   arg2 = (float)jarg2;
38168   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38169   if (!darg) {
38170     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38171     return 0;
38172   }
38173   {
38174     try {
38175       result = (float)(darg)->GetWidthForHeight(arg2);
38176     } CALL_CATCH_EXCEPTION(0);
38177   }
38178
38179   jresult = result;
38180   return jresult;
38181 }
38182
38183
38184 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
38185   float jresult ;
38186   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38187   float arg2 ;
38188   SwigDirector_ViewImpl *darg = 0;
38189   float result;
38190
38191   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38192   arg2 = (float)jarg2;
38193   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38194   if (!darg) {
38195     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38196     return 0;
38197   }
38198   {
38199     try {
38200       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
38201     } CALL_CATCH_EXCEPTION(0);
38202   }
38203
38204   jresult = result;
38205   return jresult;
38206 }
38207
38208
38209 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
38210   bool jresult ;
38211   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38212   Dali::Dimension::Type arg2 ;
38213   SwigDirector_ViewImpl *darg = 0;
38214   bool result;
38215
38216   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38217   arg2 = (Dali::Dimension::Type)jarg2;
38218   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38219   if (!darg) {
38220     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38221     return 0;
38222   }
38223   {
38224     try {
38225       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
38226     } CALL_CATCH_EXCEPTION(0);
38227   }
38228
38229   jresult = result;
38230   return jresult;
38231 }
38232
38233
38234 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
38235   bool jresult ;
38236   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38237   Dali::Dimension::Type arg2 ;
38238   SwigDirector_ViewImpl *darg = 0;
38239   bool result;
38240
38241   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38242   arg2 = (Dali::Dimension::Type)jarg2;
38243   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38244   if (!darg) {
38245     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38246     return 0;
38247   }
38248   {
38249     try {
38250       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
38251     } CALL_CATCH_EXCEPTION(0);
38252   }
38253
38254   jresult = result;
38255   return jresult;
38256 }
38257
38258
38259 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
38260   bool jresult ;
38261   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38262   SwigDirector_ViewImpl *darg = 0;
38263   bool result;
38264
38265   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38266   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38267   if (!darg) {
38268     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38269     return 0;
38270   }
38271   {
38272     try {
38273       result = (bool)(darg)->RelayoutDependentOnChildren();
38274     } CALL_CATCH_EXCEPTION(0);
38275   }
38276
38277   jresult = result;
38278   return jresult;
38279 }
38280
38281
38282 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
38283   bool jresult ;
38284   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38285   SwigDirector_ViewImpl *darg = 0;
38286   bool result;
38287
38288   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38289   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38290   if (!darg) {
38291     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38292     return 0;
38293   }
38294   {
38295     try {
38296       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
38297     } CALL_CATCH_EXCEPTION(0);
38298   }
38299
38300   jresult = result;
38301   return jresult;
38302 }
38303
38304
38305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
38306   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38307   Dali::Dimension::Type arg2 ;
38308   SwigDirector_ViewImpl *darg = 0;
38309
38310   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38311   arg2 = (Dali::Dimension::Type)jarg2;
38312   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38313   if (!darg) {
38314     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38315     return;
38316   }
38317   {
38318     try {
38319       (darg)->OnCalculateRelayoutSize(arg2);
38320     } CALL_CATCH_EXCEPTION();
38321   }
38322
38323 }
38324
38325
38326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
38327   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38328   Dali::Dimension::Type arg2 ;
38329   SwigDirector_ViewImpl *darg = 0;
38330
38331   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38332   arg2 = (Dali::Dimension::Type)jarg2;
38333   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38334   if (!darg) {
38335     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38336     return;
38337   }
38338   {
38339     try {
38340       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
38341     } CALL_CATCH_EXCEPTION();
38342   }
38343
38344 }
38345
38346
38347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
38348   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38349   float arg2 ;
38350   Dali::Dimension::Type arg3 ;
38351   SwigDirector_ViewImpl *darg = 0;
38352
38353   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38354   arg2 = (float)jarg2;
38355   arg3 = (Dali::Dimension::Type)jarg3;
38356   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38357   if (!darg) {
38358     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38359     return;
38360   }
38361   {
38362     try {
38363       (darg)->OnLayoutNegotiated(arg2,arg3);
38364     } CALL_CATCH_EXCEPTION();
38365   }
38366
38367 }
38368
38369
38370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
38371   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38372   float arg2 ;
38373   Dali::Dimension::Type arg3 ;
38374   SwigDirector_ViewImpl *darg = 0;
38375
38376   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38377   arg2 = (float)jarg2;
38378   arg3 = (Dali::Dimension::Type)jarg3;
38379   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38380   if (!darg) {
38381     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38382     return;
38383   }
38384   {
38385     try {
38386       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
38387     } CALL_CATCH_EXCEPTION();
38388   }
38389
38390 }
38391
38392
38393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
38394   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38395
38396   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38397   {
38398     try {
38399       (arg1)->OnInitialize();
38400     } CALL_CATCH_EXCEPTION();
38401   }
38402
38403 }
38404
38405
38406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
38407   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38408
38409   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38410   {
38411     try {
38412       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
38413     } CALL_CATCH_EXCEPTION();
38414   }
38415
38416 }
38417
38418
38419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
38420   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38421   Dali::Toolkit::StyleManager arg2 ;
38422   Dali::StyleChange::Type arg3 ;
38423   Dali::Toolkit::StyleManager *argp2 ;
38424
38425   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38426   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
38427   if (!argp2) {
38428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
38429     return ;
38430   }
38431   arg2 = *argp2;
38432   arg3 = (Dali::StyleChange::Type)jarg3;
38433   {
38434     try {
38435       (arg1)->OnStyleChange(arg2,arg3);
38436     } CALL_CATCH_EXCEPTION();
38437   }
38438
38439 }
38440
38441
38442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
38443   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38444   Dali::Toolkit::StyleManager arg2 ;
38445   Dali::StyleChange::Type arg3 ;
38446   Dali::Toolkit::StyleManager *argp2 ;
38447
38448   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38449   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
38450   if (!argp2) {
38451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
38452     return ;
38453   }
38454   arg2 = *argp2;
38455   arg3 = (Dali::StyleChange::Type)jarg3;
38456   {
38457     try {
38458       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
38459     } CALL_CATCH_EXCEPTION();
38460   }
38461
38462 }
38463
38464
38465 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
38466   bool jresult ;
38467   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38468   bool result;
38469
38470   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38471   {
38472     try {
38473       result = (bool)(arg1)->OnAccessibilityActivated();
38474     } CALL_CATCH_EXCEPTION(0);
38475   }
38476
38477   jresult = result;
38478   return jresult;
38479 }
38480
38481
38482 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
38483   bool jresult ;
38484   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38485   bool result;
38486
38487   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38488   {
38489     try {
38490       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
38491     } CALL_CATCH_EXCEPTION(0);
38492   }
38493
38494   jresult = result;
38495   return jresult;
38496 }
38497
38498
38499 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
38500   bool jresult ;
38501   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38502   Dali::PanGesture arg2 ;
38503   Dali::PanGesture *argp2 ;
38504   bool result;
38505
38506   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38507   argp2 = (Dali::PanGesture *)jarg2;
38508   if (!argp2) {
38509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
38510     return 0;
38511   }
38512   arg2 = *argp2;
38513   {
38514     try {
38515       result = (bool)(arg1)->OnAccessibilityPan(arg2);
38516     } CALL_CATCH_EXCEPTION(0);
38517   }
38518
38519   jresult = result;
38520   return jresult;
38521 }
38522
38523
38524 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
38525   bool jresult ;
38526   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38527   Dali::PanGesture arg2 ;
38528   Dali::PanGesture *argp2 ;
38529   bool result;
38530
38531   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38532   argp2 = (Dali::PanGesture *)jarg2;
38533   if (!argp2) {
38534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
38535     return 0;
38536   }
38537   arg2 = *argp2;
38538   {
38539     try {
38540       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
38541     } CALL_CATCH_EXCEPTION(0);
38542   }
38543
38544   jresult = result;
38545   return jresult;
38546 }
38547
38548 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, bool jarg2) {
38549   bool jresult ;
38550   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38551   bool arg2 ;
38552   bool result;
38553
38554   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38555   arg2 = jarg2 ? true : false;
38556   {
38557     try {
38558       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
38559     } CALL_CATCH_EXCEPTION(0);
38560   }
38561
38562   jresult = result;
38563   return jresult;
38564 }
38565
38566
38567 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, bool jarg2) {
38568   bool jresult ;
38569   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38570   bool arg2 ;
38571   bool result;
38572
38573   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38574   arg2 = jarg2 ? true : false;
38575   {
38576     try {
38577       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
38578     } CALL_CATCH_EXCEPTION(0);
38579   }
38580
38581   jresult = result;
38582   return jresult;
38583 }
38584
38585
38586 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
38587   bool jresult ;
38588   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38589   bool result;
38590
38591   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38592   {
38593     try {
38594       result = (bool)(arg1)->OnAccessibilityZoom();
38595     } CALL_CATCH_EXCEPTION(0);
38596   }
38597
38598   jresult = result;
38599   return jresult;
38600 }
38601
38602
38603 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
38604   bool jresult ;
38605   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38606   bool result;
38607
38608   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38609   {
38610     try {
38611       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
38612     } CALL_CATCH_EXCEPTION(0);
38613   }
38614
38615   jresult = result;
38616   return jresult;
38617 }
38618
38619
38620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
38621   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38622
38623   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38624   {
38625     try {
38626       (arg1)->OnKeyInputFocusGained();
38627     } CALL_CATCH_EXCEPTION();
38628   }
38629
38630 }
38631
38632
38633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
38634   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38635
38636   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38637   {
38638     try {
38639       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
38640     } CALL_CATCH_EXCEPTION();
38641   }
38642
38643 }
38644
38645
38646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
38647   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38648
38649   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38650   {
38651     try {
38652       (arg1)->OnKeyInputFocusLost();
38653     } CALL_CATCH_EXCEPTION();
38654   }
38655
38656 }
38657
38658
38659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
38660   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38661
38662   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38663   {
38664     try {
38665       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
38666     } CALL_CATCH_EXCEPTION();
38667   }
38668
38669 }
38670
38671
38672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, bool jarg4) {
38673   void * jresult ;
38674   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38675   Dali::Actor arg2 ;
38676   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
38677   bool arg4 ;
38678   Dali::Actor *argp2 ;
38679   Dali::Actor result;
38680
38681   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38682   argp2 = (Dali::Actor *)jarg2;
38683   if (!argp2) {
38684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
38685     return 0;
38686   }
38687   arg2 = *argp2;
38688   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
38689   arg4 = jarg4 ? true : false;
38690   {
38691     try {
38692       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
38693     } CALL_CATCH_EXCEPTION(0);
38694   }
38695
38696   jresult = new Dali::Actor((const Dali::Actor &)result);
38697   return jresult;
38698 }
38699
38700
38701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, bool jarg4) {
38702   void * jresult ;
38703   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38704   Dali::Actor arg2 ;
38705   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
38706   bool arg4 ;
38707   Dali::Actor *argp2 ;
38708   Dali::Actor result;
38709
38710   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38711   argp2 = (Dali::Actor *)jarg2;
38712   if (!argp2) {
38713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
38714     return 0;
38715   }
38716   arg2 = *argp2;
38717   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
38718   arg4 = jarg4 ? true : false;
38719   {
38720     try {
38721       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
38722     } CALL_CATCH_EXCEPTION(0);
38723   }
38724
38725   jresult = new Dali::Actor((const Dali::Actor &)result);
38726   return jresult;
38727 }
38728
38729
38730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
38731   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38732   Dali::Actor arg2 ;
38733   Dali::Actor *argp2 ;
38734
38735   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38736   argp2 = (Dali::Actor *)jarg2;
38737   if (!argp2) {
38738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
38739     return ;
38740   }
38741   arg2 = *argp2;
38742   {
38743     try {
38744       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
38745     } CALL_CATCH_EXCEPTION();
38746   }
38747
38748 }
38749
38750
38751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
38752   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38753   Dali::Actor arg2 ;
38754   Dali::Actor *argp2 ;
38755
38756   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38757   argp2 = (Dali::Actor *)jarg2;
38758   if (!argp2) {
38759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
38760     return ;
38761   }
38762   arg2 = *argp2;
38763   {
38764     try {
38765       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
38766     } CALL_CATCH_EXCEPTION();
38767   }
38768
38769 }
38770
38771
38772 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
38773   bool jresult ;
38774   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38775   bool result;
38776
38777   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38778   {
38779     try {
38780       result = (bool)(arg1)->OnKeyboardEnter();
38781     } CALL_CATCH_EXCEPTION(0);
38782   }
38783
38784   jresult = result;
38785   return jresult;
38786 }
38787
38788
38789 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
38790   bool jresult ;
38791   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38792   bool result;
38793
38794   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38795   {
38796     try {
38797       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
38798     } CALL_CATCH_EXCEPTION(0);
38799   }
38800
38801   jresult = result;
38802   return jresult;
38803 }
38804
38805
38806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
38807   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38808   Dali::PinchGesture *arg2 = 0 ;
38809
38810   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38811   arg2 = (Dali::PinchGesture *)jarg2;
38812   if (!arg2) {
38813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
38814     return ;
38815   }
38816   {
38817     try {
38818       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
38819     } CALL_CATCH_EXCEPTION();
38820   }
38821
38822 }
38823
38824
38825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
38826   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38827   Dali::PinchGesture *arg2 = 0 ;
38828
38829   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38830   arg2 = (Dali::PinchGesture *)jarg2;
38831   if (!arg2) {
38832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
38833     return ;
38834   }
38835   {
38836     try {
38837       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
38838     } CALL_CATCH_EXCEPTION();
38839   }
38840
38841 }
38842
38843
38844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
38845   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38846   Dali::PanGesture *arg2 = 0 ;
38847
38848   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38849   arg2 = (Dali::PanGesture *)jarg2;
38850   if (!arg2) {
38851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
38852     return ;
38853   }
38854   {
38855     try {
38856       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
38857     } CALL_CATCH_EXCEPTION();
38858   }
38859
38860 }
38861
38862
38863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
38864   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38865   Dali::PanGesture *arg2 = 0 ;
38866
38867   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38868   arg2 = (Dali::PanGesture *)jarg2;
38869   if (!arg2) {
38870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
38871     return ;
38872   }
38873   {
38874     try {
38875       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
38876     } CALL_CATCH_EXCEPTION();
38877   }
38878
38879 }
38880
38881
38882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
38883   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38884   Dali::TapGesture *arg2 = 0 ;
38885
38886   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38887   arg2 = (Dali::TapGesture *)jarg2;
38888   if (!arg2) {
38889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
38890     return ;
38891   }
38892   {
38893     try {
38894       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
38895     } CALL_CATCH_EXCEPTION();
38896   }
38897
38898 }
38899
38900
38901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
38902   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38903   Dali::TapGesture *arg2 = 0 ;
38904
38905   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38906   arg2 = (Dali::TapGesture *)jarg2;
38907   if (!arg2) {
38908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
38909     return ;
38910   }
38911   {
38912     try {
38913       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
38914     } CALL_CATCH_EXCEPTION();
38915   }
38916
38917 }
38918
38919
38920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
38921   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38922   Dali::LongPressGesture *arg2 = 0 ;
38923
38924   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38925   arg2 = (Dali::LongPressGesture *)jarg2;
38926   if (!arg2) {
38927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
38928     return ;
38929   }
38930   {
38931     try {
38932       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
38933     } CALL_CATCH_EXCEPTION();
38934   }
38935
38936 }
38937
38938
38939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
38940   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38941   Dali::LongPressGesture *arg2 = 0 ;
38942
38943   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38944   arg2 = (Dali::LongPressGesture *)jarg2;
38945   if (!arg2) {
38946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
38947     return ;
38948   }
38949   {
38950     try {
38951       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
38952     } CALL_CATCH_EXCEPTION();
38953   }
38954
38955 }
38956
38957
38958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
38959   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38960   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
38961   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
38962
38963   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38964   arg2 = (Dali::SlotObserver *)jarg2;
38965   arg3 = (Dali::CallbackBase *)jarg3;
38966   {
38967     try {
38968       (arg1)->SignalConnected(arg2,arg3);
38969     } CALL_CATCH_EXCEPTION();
38970   }
38971
38972 }
38973
38974
38975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
38976   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38977   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
38978   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
38979
38980   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38981   arg2 = (Dali::SlotObserver *)jarg2;
38982   arg3 = (Dali::CallbackBase *)jarg3;
38983   {
38984     try {
38985       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
38986     } CALL_CATCH_EXCEPTION();
38987   }
38988
38989 }
38990
38991
38992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
38993   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38994   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
38995   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
38996
38997   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38998   arg2 = (Dali::SlotObserver *)jarg2;
38999   arg3 = (Dali::CallbackBase *)jarg3;
39000   {
39001     try {
39002       (arg1)->SignalDisconnected(arg2,arg3);
39003     } CALL_CATCH_EXCEPTION();
39004   }
39005
39006 }
39007
39008
39009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
39010   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39011   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
39012   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
39013
39014   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39015   arg2 = (Dali::SlotObserver *)jarg2;
39016   arg3 = (Dali::CallbackBase *)jarg3;
39017   {
39018     try {
39019       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
39020     } CALL_CATCH_EXCEPTION();
39021   }
39022
39023 }
39024
39025 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) {
39026   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
39027   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
39028   if (director) {
39029     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);
39030   }
39031 }
39032
39033
39034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
39035   void * jresult ;
39036   Dali::Toolkit::Control *arg1 = 0 ;
39037   Dali::Toolkit::Internal::Control *result = 0 ;
39038
39039   arg1 = (Dali::Toolkit::Control *)jarg1;
39040   if (!arg1) {
39041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
39042     return 0;
39043   }
39044   {
39045     try {
39046       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
39047     } CALL_CATCH_EXCEPTION(0);
39048   }
39049
39050   jresult = (void *)result;
39051   return jresult;
39052 }
39053
39054
39055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
39056   int jresult ;
39057   int result;
39058
39059   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
39060   jresult = (int)result;
39061   return jresult;
39062 }
39063
39064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
39065   int jresult ;
39066   int result;
39067
39068   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
39069   jresult = (int)result;
39070   return jresult;
39071 }
39072
39073
39074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
39075   int jresult ;
39076   int result;
39077
39078   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
39079   jresult = (int)result;
39080   return jresult;
39081 }
39082
39083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
39084   int jresult ;
39085   int result;
39086
39087   result = (int)Dali::Toolkit::Control::Property::MARGIN;
39088   jresult = (int)result;
39089   return jresult;
39090 }
39091
39092
39093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
39094   int jresult ;
39095   int result;
39096
39097   result = (int)Dali::Toolkit::Control::Property::PADDING;
39098   jresult = (int)result;
39099   return jresult;
39100 }
39101
39102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
39103   int jresult ;
39104   int result;
39105
39106   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
39107   jresult = (int)result;
39108   return jresult;
39109 }
39110
39111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_NAME_get() {
39112   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_NAME;
39113 }
39114
39115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_DESCRIPTION_get() {
39116   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_DESCRIPTION;
39117 }
39118
39119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_TRANSLATION_DOMAIN_get() {
39120   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_TRANSLATION_DOMAIN;
39121 }
39122
39123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_ROLE_get() {
39124   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_ROLE;
39125 }
39126
39127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_HIGHLIGHTABLE_get() {
39128   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE;
39129 }
39130
39131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_ATTRIBUTES_get() {
39132   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_ATTRIBUTES;
39133 }
39134
39135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_HIDDEN_get() {
39136   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_HIDDEN;
39137 }
39138
39139 SWIGEXPORT int SWIGSTDCALL  CSharp_Dali_View_Property_AUTOMATION_ID_get() {
39140   return (int)Dali::Toolkit::DevelControl::Property::AUTOMATION_ID;
39141 }
39142
39143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
39144   void * jresult ;
39145   Dali::Toolkit::Control::Property *result = 0 ;
39146
39147   {
39148     try {
39149       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
39150     } CALL_CATCH_EXCEPTION(0);
39151   }
39152
39153   jresult = (void *)result;
39154   return jresult;
39155 }
39156
39157
39158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
39159   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
39160
39161   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
39162   {
39163     try {
39164       delete arg1;
39165     } CALL_CATCH_EXCEPTION();
39166   }
39167
39168 }
39169
39170
39171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
39172   void * jresult ;
39173   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
39174
39175   {
39176     try {
39177       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
39178     } CALL_CATCH_EXCEPTION(0);
39179   }
39180
39181   jresult = (void *)result;
39182   return jresult;
39183 }
39184
39185
39186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
39187   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
39188
39189   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
39190   {
39191     try {
39192       delete arg1;
39193     } CALL_CATCH_EXCEPTION();
39194   }
39195
39196 }
39197
39198
39199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
39200   void * jresult ;
39201   Dali::Toolkit::Control result;
39202
39203   {
39204     try {
39205       result = Dali::Toolkit::Control::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
39206     } CALL_CATCH_EXCEPTION(0);
39207   }
39208
39209   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
39210   return jresult;
39211 }
39212
39213
39214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
39215   void * jresult ;
39216   Dali::Toolkit::Control *result = 0 ;
39217
39218   {
39219     try {
39220       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
39221     } CALL_CATCH_EXCEPTION(0);
39222   }
39223
39224   jresult = (void *)result;
39225   return jresult;
39226 }
39227
39228
39229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
39230   void * jresult ;
39231   Dali::Toolkit::Control *arg1 = 0 ;
39232   Dali::Toolkit::Control *result = 0 ;
39233
39234   arg1 = (Dali::Toolkit::Control *)jarg1;
39235   if (!arg1) {
39236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
39237     return 0;
39238   }
39239   {
39240     try {
39241       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
39242     } CALL_CATCH_EXCEPTION(0);
39243   }
39244
39245   jresult = (void *)result;
39246   return jresult;
39247 }
39248
39249
39250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
39251   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39252
39253   arg1 = (Dali::Toolkit::Control *)jarg1;
39254   {
39255     try {
39256       delete arg1;
39257     } CALL_CATCH_EXCEPTION();
39258   }
39259
39260 }
39261
39262
39263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
39264   void * jresult ;
39265   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39266   Dali::Toolkit::Control *arg2 = 0 ;
39267   Dali::Toolkit::Control *result = 0 ;
39268
39269   arg1 = (Dali::Toolkit::Control *)jarg1;
39270   arg2 = (Dali::Toolkit::Control *)jarg2;
39271   if (!arg2) {
39272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
39273     return 0;
39274   }
39275   {
39276     try {
39277       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
39278     } CALL_CATCH_EXCEPTION(0);
39279   }
39280
39281   jresult = (void *)result;
39282   return jresult;
39283 }
39284
39285
39286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
39287   void * jresult ;
39288   Dali::BaseHandle arg1 ;
39289   Dali::BaseHandle *argp1 ;
39290   Dali::Toolkit::Control result;
39291
39292   argp1 = (Dali::BaseHandle *)jarg1;
39293   if (!argp1) {
39294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39295     return 0;
39296   }
39297   arg1 = *argp1;
39298   {
39299     try {
39300       result = Dali::Toolkit::Control::DownCast(arg1);
39301     } CALL_CATCH_EXCEPTION(0);
39302   }
39303
39304   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
39305   return jresult;
39306 }
39307
39308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Control(void * jarg1) {
39309   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) jarg1;
39310   try {
39311     delete arg1;
39312   } CALL_CATCH_EXCEPTION();
39313 }
39314
39315
39316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
39317   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39318
39319   arg1 = (Dali::Toolkit::Control *)jarg1;
39320   {
39321     try {
39322       (arg1)->SetKeyInputFocus();
39323     } CALL_CATCH_EXCEPTION();
39324   }
39325
39326 }
39327
39328
39329 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
39330   bool jresult ;
39331   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39332   bool result;
39333
39334   arg1 = (Dali::Toolkit::Control *)jarg1;
39335   {
39336     try {
39337       result = (bool)(arg1)->HasKeyInputFocus();
39338     } CALL_CATCH_EXCEPTION(0);
39339   }
39340
39341   jresult = result;
39342   return jresult;
39343 }
39344
39345
39346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
39347   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39348
39349   arg1 = (Dali::Toolkit::Control *)jarg1;
39350   {
39351     try {
39352       (arg1)->ClearKeyInputFocus();
39353     } CALL_CATCH_EXCEPTION();
39354   }
39355
39356 }
39357
39358
39359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
39360   void * jresult ;
39361   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39362   Dali::PinchGestureDetector result;
39363
39364   arg1 = (Dali::Toolkit::Control *)jarg1;
39365   {
39366     try {
39367       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
39368     } CALL_CATCH_EXCEPTION(0);
39369   }
39370
39371   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
39372   return jresult;
39373 }
39374
39375
39376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
39377   void * jresult ;
39378   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39379   Dali::PanGestureDetector result;
39380
39381   arg1 = (Dali::Toolkit::Control *)jarg1;
39382   {
39383     try {
39384       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
39385     } CALL_CATCH_EXCEPTION(0);
39386   }
39387
39388   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
39389   return jresult;
39390 }
39391
39392
39393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
39394   void * jresult ;
39395   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39396   Dali::TapGestureDetector result;
39397
39398   arg1 = (Dali::Toolkit::Control *)jarg1;
39399   {
39400     try {
39401       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
39402     } CALL_CATCH_EXCEPTION(0);
39403   }
39404
39405   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
39406   return jresult;
39407 }
39408
39409
39410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
39411   void * jresult ;
39412   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39413   Dali::LongPressGestureDetector result;
39414
39415   arg1 = (Dali::Toolkit::Control *)jarg1;
39416   {
39417     try {
39418       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
39419     } CALL_CATCH_EXCEPTION(0);
39420   }
39421
39422   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
39423   return jresult;
39424 }
39425
39426
39427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
39428   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39429   std::string *arg2 = 0 ;
39430
39431   arg1 = (Dali::Toolkit::Control *)jarg1;
39432   if (!jarg2) {
39433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
39434     return ;
39435   }
39436   std::string arg2_str(jarg2);
39437   arg2 = &arg2_str;
39438   {
39439     try {
39440       (arg1)->SetStyleName((std::string const &)*arg2);
39441     } CALL_CATCH_EXCEPTION();
39442   }
39443
39444
39445   //argout typemap for const std::string&
39446
39447 }
39448
39449
39450 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
39451   char * jresult ;
39452   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39453   std::string *result = 0 ;
39454
39455   arg1 = (Dali::Toolkit::Control *)jarg1;
39456   {
39457     try {
39458       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
39459     } CALL_CATCH_EXCEPTION(0);
39460   }
39461
39462   jresult = SWIG_csharp_string_callback(result->c_str());
39463   return jresult;
39464 }
39465
39466
39467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
39468   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39469   Dali::Vector4 *arg2 = 0 ;
39470
39471   arg1 = (Dali::Toolkit::Control *)jarg1;
39472   arg2 = (Dali::Vector4 *)jarg2;
39473   if (!arg2) {
39474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
39475     return ;
39476   }
39477   {
39478     try {
39479       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
39480     } CALL_CATCH_EXCEPTION();
39481   }
39482
39483 }
39484
39485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
39486   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39487
39488   arg1 = (Dali::Toolkit::Control *)jarg1;
39489   {
39490     try {
39491       (arg1)->ClearBackground();
39492     } CALL_CATCH_EXCEPTION();
39493   }
39494
39495 }
39496
39497
39498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
39499   void * jresult ;
39500   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39501   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
39502
39503   arg1 = (Dali::Toolkit::Control *)jarg1;
39504   {
39505     try {
39506       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
39507     } CALL_CATCH_EXCEPTION(0);
39508   }
39509
39510   jresult = (void *)result;
39511   return jresult;
39512 }
39513
39514
39515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
39516   void * jresult ;
39517   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39518   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
39519
39520   arg1 = (Dali::Toolkit::Control *)jarg1;
39521   {
39522     try {
39523       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
39524     } CALL_CATCH_EXCEPTION(0);
39525   }
39526
39527   jresult = (void *)result;
39528   return jresult;
39529 }
39530
39531
39532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
39533   void * jresult ;
39534   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39535   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
39536
39537   arg1 = (Dali::Toolkit::Control *)jarg1;
39538   {
39539     try {
39540       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
39541     } CALL_CATCH_EXCEPTION(0);
39542   }
39543
39544   jresult = (void *)result;
39545   return jresult;
39546 }
39547
39548
39549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
39550   void * jresult ;
39551   Dali::Toolkit::Internal::Control *arg1 = 0 ;
39552   Dali::Toolkit::Control *result = 0 ;
39553
39554   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39555   if (!arg1) {
39556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
39557     return 0;
39558   }
39559   {
39560     try {
39561       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
39562     } CALL_CATCH_EXCEPTION(0);
39563   }
39564
39565   jresult = (void *)result;
39566   return jresult;
39567 }
39568
39569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
39570 {
39571   int jresult;
39572   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39573   arg1 = (Dali::Toolkit::Control *)jarg1;
39574
39575   if (!arg1) {
39576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
39577     return 0;
39578   }
39579
39580   Dali::Property::Index arg2 = 0 ;
39581   arg2 = (Dali::Property::Index)jarg2;
39582
39583   Toolkit::Visual::ResourceStatus result;
39584   {
39585     try {
39586       result = arg1->GetVisualResourceStatus(arg2);
39587     } CALL_CATCH_EXCEPTION(0);
39588   }
39589
39590   jresult = (int)result;
39591   return jresult;
39592 }
39593
39594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
39595 {
39596   void * jresult;
39597   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39598   arg1 = (Dali::Toolkit::Control *)jarg1;
39599
39600   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
39601
39602   Dali::Toolkit::TransitionData *arg2 = 0 ;
39603   Dali::Animation result;
39604
39605   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
39606   if (!arg2) {
39607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
39608     return 0;
39609   }
39610   {
39611     try {
39612       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
39613     } CALL_CATCH_EXCEPTION(0);
39614   }
39615
39616   jresult = new Dali::Animation((const Dali::Animation &)result);
39617   return jresult;
39618 }
39619
39620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
39621 {
39622   Dali::Toolkit::Control arg1;
39623   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
39624
39625   if (!argp1) {
39626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
39627   }
39628   arg1 = *argp1;
39629
39630   Dali::Property::Index arg2 = 0 ;
39631   arg2 = (Dali::Property::Index)jarg2;
39632
39633   Dali::Property::Index arg3 = 0 ;
39634   arg3 = (Dali::Property::Index)jarg3;
39635
39636   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
39637
39638   {
39639     try {
39640       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
39641     } CALL_CATCH_EXCEPTION();
39642   }
39643 }
39644
39645 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_View_GetVisualProperty(void* control, int propertyIndex, int visualPropertyIndex)
39646 {
39647   if (!control)
39648   {
39649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Given control is null", 0);
39650     return 0;
39651   }
39652
39653   void* result = 0;
39654   try
39655   {
39656     Dali::Property property = DevelControl::GetVisualProperty(*((Dali::Toolkit::Control*)control), (Dali::Property::Index)propertyIndex, (Dali::Property::Index)visualPropertyIndex);
39657     result = new Dali::Property(property.object, property.propertyIndex, property.componentIndex);
39658   }
39659   CALL_CATCH_EXCEPTION(0);
39660
39661   return result;
39662 }
39663
39664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
39665   void * jresult ;
39666   Dali::Toolkit::Control *arg1 = 0 ;
39667   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
39668
39669   arg1 = (Dali::Toolkit::Control *)jarg1;
39670   if (!arg1) {
39671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
39672     return 0;
39673   }
39674   {
39675     try {
39676       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
39677     } CALL_CATCH_EXCEPTION(0);
39678   }
39679
39680   jresult = (void *)result;
39681   return jresult;
39682 }
39683
39684
39685 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
39686   bool jresult ;
39687   Dali::Toolkit::Control *arg1 = 0 ;
39688   bool result;
39689
39690   arg1 = (Dali::Toolkit::Control *)jarg1;
39691   if (!arg1) {
39692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
39693     return 0;
39694   }
39695   {
39696     try {
39697       result = (bool)arg1->IsResourceReady();
39698     } CALL_CATCH_EXCEPTION(0);
39699   }
39700
39701   jresult = result;
39702   return jresult;
39703 }
39704
39705
39706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
39707   void * jresult ;
39708   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
39709
39710   {
39711     try {
39712       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
39713     } CALL_CATCH_EXCEPTION(0);
39714   }
39715
39716   jresult = (void *)result;
39717   return jresult;
39718 }
39719
39720
39721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
39722   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
39723
39724   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
39725   {
39726     try {
39727       delete arg1;
39728     } CALL_CATCH_EXCEPTION();
39729   }
39730
39731 }
39732
39733
39734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
39735   void * jresult ;
39736   Dali::Toolkit::KeyInputFocusManager result;
39737
39738   {
39739     try {
39740       result = Dali::Toolkit::KeyInputFocusManager::Get();
39741     } CALL_CATCH_EXCEPTION(0);
39742   }
39743
39744   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
39745   return jresult;
39746 }
39747
39748
39749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
39750   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
39751   Dali::Toolkit::Control arg2 ;
39752   Dali::Toolkit::Control *argp2 ;
39753
39754   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
39755   argp2 = (Dali::Toolkit::Control *)jarg2;
39756   if (!argp2) {
39757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
39758     return ;
39759   }
39760   arg2 = *argp2;
39761   {
39762     try {
39763       (arg1)->SetFocus(arg2);
39764     } CALL_CATCH_EXCEPTION();
39765   }
39766
39767 }
39768
39769
39770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
39771   void * jresult ;
39772   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
39773   Dali::Toolkit::Control result;
39774
39775   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
39776   {
39777     try {
39778       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
39779     } CALL_CATCH_EXCEPTION(0);
39780   }
39781
39782   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
39783   return jresult;
39784 }
39785
39786
39787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
39788   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
39789   Dali::Toolkit::Control arg2 ;
39790   Dali::Toolkit::Control *argp2 ;
39791
39792   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
39793   argp2 = (Dali::Toolkit::Control *)jarg2;
39794   if (!argp2) {
39795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
39796     return ;
39797   }
39798   arg2 = *argp2;
39799   {
39800     try {
39801       (arg1)->RemoveFocus(arg2);
39802     } CALL_CATCH_EXCEPTION();
39803   }
39804
39805 }
39806
39807
39808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
39809   void * jresult ;
39810   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
39811   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
39812
39813   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
39814   {
39815     try {
39816       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
39817     } CALL_CATCH_EXCEPTION(0);
39818   }
39819
39820   jresult = (void *)result;
39821   return jresult;
39822 }
39823
39824
39825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
39826   void * jresult ;
39827   Dali::Toolkit::Alignment::Padding *result = 0 ;
39828
39829   {
39830     try {
39831       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
39832     } CALL_CATCH_EXCEPTION(0);
39833   }
39834
39835   jresult = (void *)result;
39836   return jresult;
39837 }
39838
39839
39840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
39841   void * jresult ;
39842   float arg1 ;
39843   float arg2 ;
39844   float arg3 ;
39845   float arg4 ;
39846   Dali::Toolkit::Alignment::Padding *result = 0 ;
39847
39848   arg1 = (float)jarg1;
39849   arg2 = (float)jarg2;
39850   arg3 = (float)jarg3;
39851   arg4 = (float)jarg4;
39852   {
39853     try {
39854       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
39855     } CALL_CATCH_EXCEPTION(0);
39856   }
39857
39858   jresult = (void *)result;
39859   return jresult;
39860 }
39861
39862
39863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
39864   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
39865   float arg2 ;
39866
39867   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
39868   arg2 = (float)jarg2;
39869   if (arg1) (arg1)->left = arg2;
39870 }
39871
39872
39873 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
39874   float jresult ;
39875   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
39876   float result;
39877
39878   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
39879   result = (float) ((arg1)->left);
39880   jresult = result;
39881   return jresult;
39882 }
39883
39884
39885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
39886   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
39887   float arg2 ;
39888
39889   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
39890   arg2 = (float)jarg2;
39891   if (arg1) (arg1)->right = arg2;
39892 }
39893
39894
39895 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
39896   float jresult ;
39897   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
39898   float result;
39899
39900   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
39901   result = (float) ((arg1)->right);
39902   jresult = result;
39903   return jresult;
39904 }
39905
39906
39907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
39908   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
39909   float arg2 ;
39910
39911   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
39912   arg2 = (float)jarg2;
39913   if (arg1) (arg1)->top = arg2;
39914 }
39915
39916
39917 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
39918   float jresult ;
39919   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
39920   float result;
39921
39922   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
39923   result = (float) ((arg1)->top);
39924   jresult = result;
39925   return jresult;
39926 }
39927
39928
39929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
39930   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
39931   float arg2 ;
39932
39933   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
39934   arg2 = (float)jarg2;
39935   if (arg1) (arg1)->bottom = arg2;
39936 }
39937
39938
39939 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
39940   float jresult ;
39941   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
39942   float result;
39943
39944   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
39945   result = (float) ((arg1)->bottom);
39946   jresult = result;
39947   return jresult;
39948 }
39949
39950
39951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
39952   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
39953
39954   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
39955   {
39956     try {
39957       delete arg1;
39958     } CALL_CATCH_EXCEPTION();
39959   }
39960
39961 }
39962
39963
39964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
39965   void * jresult ;
39966   Dali::Toolkit::Alignment *result = 0 ;
39967
39968   {
39969     try {
39970       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
39971     } CALL_CATCH_EXCEPTION(0);
39972   }
39973
39974   jresult = (void *)result;
39975   return jresult;
39976 }
39977
39978
39979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
39980   void * jresult ;
39981   Dali::Toolkit::Alignment::Type arg1 ;
39982   Dali::Toolkit::Alignment::Type arg2 ;
39983   Dali::Toolkit::Alignment result;
39984
39985   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
39986   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
39987   {
39988     try {
39989       result = Dali::Toolkit::Alignment::New(arg1,arg2);
39990     } CALL_CATCH_EXCEPTION(0);
39991   }
39992
39993   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
39994   return jresult;
39995 }
39996
39997
39998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
39999   void * jresult ;
40000   Dali::Toolkit::Alignment::Type arg1 ;
40001   Dali::Toolkit::Alignment result;
40002
40003   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
40004   {
40005     try {
40006       result = Dali::Toolkit::Alignment::New(arg1);
40007     } CALL_CATCH_EXCEPTION(0);
40008   }
40009
40010   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
40011   return jresult;
40012 }
40013
40014
40015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
40016   void * jresult ;
40017   Dali::Toolkit::Alignment result;
40018
40019   {
40020     try {
40021       result = Dali::Toolkit::Alignment::New();
40022     } CALL_CATCH_EXCEPTION(0);
40023   }
40024
40025   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
40026   return jresult;
40027 }
40028
40029
40030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
40031   void * jresult ;
40032   Dali::Toolkit::Alignment *arg1 = 0 ;
40033   Dali::Toolkit::Alignment *result = 0 ;
40034
40035   arg1 = (Dali::Toolkit::Alignment *)jarg1;
40036   if (!arg1) {
40037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
40038     return 0;
40039   }
40040   {
40041     try {
40042       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
40043     } CALL_CATCH_EXCEPTION(0);
40044   }
40045
40046   jresult = (void *)result;
40047   return jresult;
40048 }
40049
40050
40051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
40052   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
40053
40054   arg1 = (Dali::Toolkit::Alignment *)jarg1;
40055   {
40056     try {
40057       delete arg1;
40058     } CALL_CATCH_EXCEPTION();
40059   }
40060
40061 }
40062
40063
40064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
40065   void * jresult ;
40066   Dali::BaseHandle arg1 ;
40067   Dali::BaseHandle *argp1 ;
40068   Dali::Toolkit::Alignment result;
40069
40070   argp1 = (Dali::BaseHandle *)jarg1;
40071   if (!argp1) {
40072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40073     return 0;
40074   }
40075   arg1 = *argp1;
40076   {
40077     try {
40078       result = Dali::Toolkit::Alignment::DownCast(arg1);
40079     } CALL_CATCH_EXCEPTION(0);
40080   }
40081
40082   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
40083   return jresult;
40084 }
40085
40086
40087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
40088   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
40089   Dali::Toolkit::Alignment::Type arg2 ;
40090
40091   arg1 = (Dali::Toolkit::Alignment *)jarg1;
40092   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
40093   {
40094     try {
40095       (arg1)->SetAlignmentType(arg2);
40096     } CALL_CATCH_EXCEPTION();
40097   }
40098
40099 }
40100
40101
40102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
40103   int jresult ;
40104   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
40105   Dali::Toolkit::Alignment::Type result;
40106
40107   arg1 = (Dali::Toolkit::Alignment *)jarg1;
40108   {
40109     try {
40110       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
40111     } CALL_CATCH_EXCEPTION(0);
40112   }
40113
40114   jresult = (int)result;
40115   return jresult;
40116 }
40117
40118
40119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
40120   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
40121   Dali::Toolkit::Alignment::Scaling arg2 ;
40122
40123   arg1 = (Dali::Toolkit::Alignment *)jarg1;
40124   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
40125   {
40126     try {
40127       (arg1)->SetScaling(arg2);
40128     } CALL_CATCH_EXCEPTION();
40129   }
40130
40131 }
40132
40133
40134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
40135   int jresult ;
40136   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
40137   Dali::Toolkit::Alignment::Scaling result;
40138
40139   arg1 = (Dali::Toolkit::Alignment *)jarg1;
40140   {
40141     try {
40142       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
40143     } CALL_CATCH_EXCEPTION(0);
40144   }
40145
40146   jresult = (int)result;
40147   return jresult;
40148 }
40149
40150
40151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
40152   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
40153   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
40154
40155   arg1 = (Dali::Toolkit::Alignment *)jarg1;
40156   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
40157   if (!arg2) {
40158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
40159     return ;
40160   }
40161   {
40162     try {
40163       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
40164     } CALL_CATCH_EXCEPTION();
40165   }
40166
40167 }
40168
40169
40170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
40171   void * jresult ;
40172   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
40173   Dali::Toolkit::Alignment::Padding *result = 0 ;
40174
40175   arg1 = (Dali::Toolkit::Alignment *)jarg1;
40176   {
40177     try {
40178       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
40179     } CALL_CATCH_EXCEPTION(0);
40180   }
40181
40182   jresult = (void *)result;
40183   return jresult;
40184 }
40185
40186
40187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
40188   void * jresult ;
40189   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
40190   Dali::Toolkit::Alignment *arg2 = 0 ;
40191   Dali::Toolkit::Alignment *result = 0 ;
40192
40193   arg1 = (Dali::Toolkit::Alignment *)jarg1;
40194   arg2 = (Dali::Toolkit::Alignment *)jarg2;
40195   if (!arg2) {
40196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
40197     return 0;
40198   }
40199   {
40200     try {
40201       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
40202     } CALL_CATCH_EXCEPTION(0);
40203   }
40204
40205   jresult = (void *)result;
40206   return jresult;
40207 }
40208
40209
40210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
40211   int jresult ;
40212   int result;
40213
40214   result = (int)Dali::Toolkit::Button::Property::DISABLED;
40215   jresult = (int)result;
40216   return jresult;
40217 }
40218
40219
40220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
40221   int jresult ;
40222   int result;
40223
40224   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
40225   jresult = (int)result;
40226   return jresult;
40227 }
40228
40229
40230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
40231   int jresult ;
40232   int result;
40233
40234   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
40235   jresult = (int)result;
40236   return jresult;
40237 }
40238
40239
40240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
40241   int jresult ;
40242   int result;
40243
40244   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
40245   jresult = (int)result;
40246   return jresult;
40247 }
40248
40249
40250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
40251   int jresult ;
40252   int result;
40253
40254   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
40255   jresult = (int)result;
40256   return jresult;
40257 }
40258
40259
40260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
40261   int jresult ;
40262   int result;
40263
40264   result = (int)Dali::Toolkit::Button::Property::SELECTED;
40265   jresult = (int)result;
40266   return jresult;
40267 }
40268
40269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
40270   int jresult ;
40271   int result;
40272
40273   result = (int)Dali::Toolkit::Button::Property::LABEL;
40274   jresult = (int)result;
40275   return jresult;
40276 }
40277
40278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
40279   void * jresult ;
40280   Dali::Toolkit::Button::Property *result = 0 ;
40281
40282   {
40283     try {
40284       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
40285     } CALL_CATCH_EXCEPTION(0);
40286   }
40287
40288   jresult = (void *)result;
40289   return jresult;
40290 }
40291
40292
40293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
40294   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
40295
40296   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
40297   {
40298     try {
40299       delete arg1;
40300     } CALL_CATCH_EXCEPTION();
40301   }
40302
40303 }
40304
40305
40306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
40307   void * jresult ;
40308   Dali::Toolkit::Button *result = 0 ;
40309
40310   {
40311     try {
40312       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
40313     } CALL_CATCH_EXCEPTION(0);
40314   }
40315
40316   jresult = (void *)result;
40317   return jresult;
40318 }
40319
40320
40321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
40322   void * jresult ;
40323   Dali::Toolkit::Button *arg1 = 0 ;
40324   Dali::Toolkit::Button *result = 0 ;
40325
40326   arg1 = (Dali::Toolkit::Button *)jarg1;
40327   if (!arg1) {
40328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
40329     return 0;
40330   }
40331   {
40332     try {
40333       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
40334     } CALL_CATCH_EXCEPTION(0);
40335   }
40336
40337   jresult = (void *)result;
40338   return jresult;
40339 }
40340
40341
40342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
40343   void * jresult ;
40344   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
40345   Dali::Toolkit::Button *arg2 = 0 ;
40346   Dali::Toolkit::Button *result = 0 ;
40347
40348   arg1 = (Dali::Toolkit::Button *)jarg1;
40349   arg2 = (Dali::Toolkit::Button *)jarg2;
40350   if (!arg2) {
40351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
40352     return 0;
40353   }
40354   {
40355     try {
40356       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
40357     } CALL_CATCH_EXCEPTION(0);
40358   }
40359
40360   jresult = (void *)result;
40361   return jresult;
40362 }
40363
40364
40365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
40366   void * jresult ;
40367   Dali::BaseHandle arg1 ;
40368   Dali::BaseHandle *argp1 ;
40369   Dali::Toolkit::Button result;
40370
40371   argp1 = (Dali::BaseHandle *)jarg1;
40372   if (!argp1) {
40373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40374     return 0;
40375   }
40376   arg1 = *argp1;
40377   {
40378     try {
40379       result = Dali::Toolkit::Button::DownCast(arg1);
40380     } CALL_CATCH_EXCEPTION(0);
40381   }
40382
40383   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
40384   return jresult;
40385 }
40386
40387
40388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
40389   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
40390
40391   arg1 = (Dali::Toolkit::Button *)jarg1;
40392   {
40393     try {
40394       delete arg1;
40395     } CALL_CATCH_EXCEPTION();
40396   }
40397
40398 }
40399
40400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
40401   void * jresult ;
40402   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
40403   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
40404
40405   arg1 = (Dali::Toolkit::Button *)jarg1;
40406   {
40407     try {
40408       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
40409     } CALL_CATCH_EXCEPTION(0);
40410   }
40411
40412   jresult = (void *)result;
40413   return jresult;
40414 }
40415
40416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
40417   void * jresult ;
40418   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
40419   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
40420
40421   arg1 = (Dali::Toolkit::Button *)jarg1;
40422   {
40423     try {
40424       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
40425     } CALL_CATCH_EXCEPTION(0);
40426   }
40427
40428   jresult = (void *)result;
40429   return jresult;
40430 }
40431
40432
40433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
40434   void * jresult ;
40435   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
40436   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
40437
40438   arg1 = (Dali::Toolkit::Button *)jarg1;
40439   {
40440     try {
40441       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
40442     } CALL_CATCH_EXCEPTION(0);
40443   }
40444
40445   jresult = (void *)result;
40446   return jresult;
40447 }
40448
40449
40450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
40451   void * jresult ;
40452   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
40453   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
40454
40455   arg1 = (Dali::Toolkit::Button *)jarg1;
40456   {
40457     try {
40458       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
40459     } CALL_CATCH_EXCEPTION(0);
40460   }
40461
40462   jresult = (void *)result;
40463   return jresult;
40464 }
40465
40466
40467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
40468   void * jresult ;
40469   Dali::Toolkit::CheckBoxButton *result = 0 ;
40470
40471   {
40472     try {
40473       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
40474     } CALL_CATCH_EXCEPTION(0);
40475   }
40476
40477   jresult = (void *)result;
40478   return jresult;
40479 }
40480
40481
40482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
40483   void * jresult ;
40484   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
40485   Dali::Toolkit::CheckBoxButton *result = 0 ;
40486
40487   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
40488   if (!arg1) {
40489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
40490     return 0;
40491   }
40492   {
40493     try {
40494       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
40495     } CALL_CATCH_EXCEPTION(0);
40496   }
40497
40498   jresult = (void *)result;
40499   return jresult;
40500 }
40501
40502
40503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
40504   void * jresult ;
40505   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
40506   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
40507   Dali::Toolkit::CheckBoxButton *result = 0 ;
40508
40509   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
40510   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
40511   if (!arg2) {
40512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
40513     return 0;
40514   }
40515   {
40516     try {
40517       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
40518     } CALL_CATCH_EXCEPTION(0);
40519   }
40520
40521   jresult = (void *)result;
40522   return jresult;
40523 }
40524
40525
40526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
40527   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
40528
40529   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
40530   {
40531     try {
40532       delete arg1;
40533     } CALL_CATCH_EXCEPTION();
40534   }
40535
40536 }
40537
40538
40539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
40540   void * jresult ;
40541   Dali::Toolkit::CheckBoxButton result;
40542
40543   {
40544     try {
40545       result = Dali::Toolkit::CheckBoxButton::New();
40546     } CALL_CATCH_EXCEPTION(0);
40547   }
40548
40549   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
40550   return jresult;
40551 }
40552
40553
40554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
40555   void * jresult ;
40556   Dali::BaseHandle arg1 ;
40557   Dali::BaseHandle *argp1 ;
40558   Dali::Toolkit::CheckBoxButton result;
40559
40560   argp1 = (Dali::BaseHandle *)jarg1;
40561   if (!argp1) {
40562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40563     return 0;
40564   }
40565   arg1 = *argp1;
40566   {
40567     try {
40568       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
40569     } CALL_CATCH_EXCEPTION(0);
40570   }
40571
40572   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
40573   return jresult;
40574 }
40575
40576
40577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
40578   int jresult ;
40579   int result;
40580
40581   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
40582   jresult = (int)result;
40583   return jresult;
40584 }
40585
40586
40587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
40588   int jresult ;
40589   int result;
40590
40591   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
40592   jresult = (int)result;
40593   return jresult;
40594 }
40595
40596
40597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
40598   void * jresult ;
40599   Dali::Toolkit::PushButton::Property *result = 0 ;
40600
40601   {
40602     try {
40603       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
40604     } CALL_CATCH_EXCEPTION(0);
40605   }
40606
40607   jresult = (void *)result;
40608   return jresult;
40609 }
40610
40611
40612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
40613   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
40614
40615   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
40616   {
40617     try {
40618       delete arg1;
40619     } CALL_CATCH_EXCEPTION();
40620   }
40621
40622 }
40623
40624
40625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
40626   void * jresult ;
40627   Dali::Toolkit::PushButton *result = 0 ;
40628
40629   {
40630     try {
40631       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
40632     } CALL_CATCH_EXCEPTION(0);
40633   }
40634
40635   jresult = (void *)result;
40636   return jresult;
40637 }
40638
40639
40640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
40641   void * jresult ;
40642   Dali::Toolkit::PushButton *arg1 = 0 ;
40643   Dali::Toolkit::PushButton *result = 0 ;
40644
40645   arg1 = (Dali::Toolkit::PushButton *)jarg1;
40646   if (!arg1) {
40647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
40648     return 0;
40649   }
40650   {
40651     try {
40652       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
40653     } CALL_CATCH_EXCEPTION(0);
40654   }
40655
40656   jresult = (void *)result;
40657   return jresult;
40658 }
40659
40660
40661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
40662   void * jresult ;
40663   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
40664   Dali::Toolkit::PushButton *arg2 = 0 ;
40665   Dali::Toolkit::PushButton *result = 0 ;
40666
40667   arg1 = (Dali::Toolkit::PushButton *)jarg1;
40668   arg2 = (Dali::Toolkit::PushButton *)jarg2;
40669   if (!arg2) {
40670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
40671     return 0;
40672   }
40673   {
40674     try {
40675       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
40676     } CALL_CATCH_EXCEPTION(0);
40677   }
40678
40679   jresult = (void *)result;
40680   return jresult;
40681 }
40682
40683
40684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
40685   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
40686
40687   arg1 = (Dali::Toolkit::PushButton *)jarg1;
40688   {
40689     try {
40690       delete arg1;
40691     } CALL_CATCH_EXCEPTION();
40692   }
40693
40694 }
40695
40696
40697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
40698   void * jresult ;
40699   Dali::Toolkit::PushButton result;
40700
40701   {
40702     try {
40703       result = Dali::Toolkit::PushButton::New();
40704     } CALL_CATCH_EXCEPTION(0);
40705   }
40706
40707   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
40708   return jresult;
40709 }
40710
40711
40712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
40713   void * jresult ;
40714   Dali::BaseHandle arg1 ;
40715   Dali::BaseHandle *argp1 ;
40716   Dali::Toolkit::PushButton result;
40717
40718   argp1 = (Dali::BaseHandle *)jarg1;
40719   if (!argp1) {
40720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40721     return 0;
40722   }
40723   arg1 = *argp1;
40724   {
40725     try {
40726       result = Dali::Toolkit::PushButton::DownCast(arg1);
40727     } CALL_CATCH_EXCEPTION(0);
40728   }
40729
40730   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
40731   return jresult;
40732 }
40733
40734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
40735   void * jresult ;
40736   Dali::Toolkit::RadioButton *result = 0 ;
40737
40738   {
40739     try {
40740       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
40741     } CALL_CATCH_EXCEPTION(0);
40742   }
40743
40744   jresult = (void *)result;
40745   return jresult;
40746 }
40747
40748
40749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
40750   void * jresult ;
40751   Dali::Toolkit::RadioButton *arg1 = 0 ;
40752   Dali::Toolkit::RadioButton *result = 0 ;
40753
40754   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
40755   if (!arg1) {
40756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
40757     return 0;
40758   }
40759   {
40760     try {
40761       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
40762     } CALL_CATCH_EXCEPTION(0);
40763   }
40764
40765   jresult = (void *)result;
40766   return jresult;
40767 }
40768
40769
40770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
40771   void * jresult ;
40772   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
40773   Dali::Toolkit::RadioButton *arg2 = 0 ;
40774   Dali::Toolkit::RadioButton *result = 0 ;
40775
40776   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
40777   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
40778   if (!arg2) {
40779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
40780     return 0;
40781   }
40782   {
40783     try {
40784       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
40785     } CALL_CATCH_EXCEPTION(0);
40786   }
40787
40788   jresult = (void *)result;
40789   return jresult;
40790 }
40791
40792
40793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
40794   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
40795
40796   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
40797   {
40798     try {
40799       delete arg1;
40800     } CALL_CATCH_EXCEPTION();
40801   }
40802
40803 }
40804
40805
40806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
40807   void * jresult ;
40808   Dali::Toolkit::RadioButton result;
40809
40810   {
40811     try {
40812       result = Dali::Toolkit::RadioButton::New();
40813     } CALL_CATCH_EXCEPTION(0);
40814   }
40815
40816   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
40817   return jresult;
40818 }
40819
40820
40821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
40822   void * jresult ;
40823   std::string *arg1 = 0 ;
40824   Dali::Toolkit::RadioButton result;
40825
40826   if (!jarg1) {
40827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40828     return 0;
40829   }
40830   std::string arg1_str(jarg1);
40831   arg1 = &arg1_str;
40832   {
40833     try {
40834       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
40835     } CALL_CATCH_EXCEPTION(0);
40836   }
40837
40838   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
40839
40840   //argout typemap for const std::string&
40841
40842   return jresult;
40843 }
40844
40845
40846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
40847   void * jresult ;
40848   Dali::BaseHandle arg1 ;
40849   Dali::BaseHandle *argp1 ;
40850   Dali::Toolkit::RadioButton result;
40851
40852   argp1 = (Dali::BaseHandle *)jarg1;
40853   if (!argp1) {
40854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40855     return 0;
40856   }
40857   arg1 = *argp1;
40858   {
40859     try {
40860       result = Dali::Toolkit::RadioButton::DownCast(arg1);
40861     } CALL_CATCH_EXCEPTION(0);
40862   }
40863
40864   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
40865   return jresult;
40866 }
40867
40868
40869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
40870   int jresult ;
40871   int result;
40872
40873   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
40874   jresult = (int)result;
40875   return jresult;
40876 }
40877
40878
40879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
40880   int jresult ;
40881   int result;
40882
40883   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
40884   jresult = (int)result;
40885   return jresult;
40886 }
40887
40888
40889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
40890   int jresult ;
40891   int result;
40892
40893   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
40894   jresult = (int)result;
40895   return jresult;
40896 }
40897
40898
40899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
40900   int jresult ;
40901   int result;
40902
40903   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
40904   jresult = (int)result;
40905   return jresult;
40906 }
40907
40908
40909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
40910   int jresult ;
40911   int result;
40912
40913   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
40914   jresult = (int)result;
40915   return jresult;
40916 }
40917
40918
40919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
40920   int jresult ;
40921   int result;
40922
40923   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
40924   jresult = (int)result;
40925   return jresult;
40926 }
40927
40928
40929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
40930   void * jresult ;
40931   Dali::Toolkit::FlexContainer::Property *result = 0 ;
40932
40933   {
40934     try {
40935       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
40936     } CALL_CATCH_EXCEPTION(0);
40937   }
40938
40939   jresult = (void *)result;
40940   return jresult;
40941 }
40942
40943
40944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
40945   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
40946
40947   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
40948   {
40949     try {
40950       delete arg1;
40951     } CALL_CATCH_EXCEPTION();
40952   }
40953
40954 }
40955
40956
40957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
40958   int jresult ;
40959   int result;
40960
40961   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
40962   jresult = (int)result;
40963   return jresult;
40964 }
40965
40966
40967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
40968   int jresult ;
40969   int result;
40970
40971   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
40972   jresult = (int)result;
40973   return jresult;
40974 }
40975
40976
40977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
40978   int jresult ;
40979   int result;
40980
40981   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
40982   jresult = (int)result;
40983   return jresult;
40984 }
40985
40986
40987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
40988   void * jresult ;
40989   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
40990
40991   {
40992     try {
40993       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
40994     } CALL_CATCH_EXCEPTION(0);
40995   }
40996
40997   jresult = (void *)result;
40998   return jresult;
40999 }
41000
41001
41002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
41003   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
41004
41005   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
41006   {
41007     try {
41008       delete arg1;
41009     } CALL_CATCH_EXCEPTION();
41010   }
41011
41012 }
41013
41014
41015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
41016   void * jresult ;
41017   Dali::Toolkit::FlexContainer *result = 0 ;
41018
41019   {
41020     try {
41021       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
41022     } CALL_CATCH_EXCEPTION(0);
41023   }
41024
41025   jresult = (void *)result;
41026   return jresult;
41027 }
41028
41029
41030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
41031   void * jresult ;
41032   Dali::Toolkit::FlexContainer *arg1 = 0 ;
41033   Dali::Toolkit::FlexContainer *result = 0 ;
41034
41035   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
41036   if (!arg1) {
41037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
41038     return 0;
41039   }
41040   {
41041     try {
41042       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
41043     } CALL_CATCH_EXCEPTION(0);
41044   }
41045
41046   jresult = (void *)result;
41047   return jresult;
41048 }
41049
41050
41051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
41052   void * jresult ;
41053   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
41054   Dali::Toolkit::FlexContainer *arg2 = 0 ;
41055   Dali::Toolkit::FlexContainer *result = 0 ;
41056
41057   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
41058   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
41059   if (!arg2) {
41060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
41061     return 0;
41062   }
41063   {
41064     try {
41065       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
41066     } CALL_CATCH_EXCEPTION(0);
41067   }
41068
41069   jresult = (void *)result;
41070   return jresult;
41071 }
41072
41073
41074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
41075   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
41076
41077   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
41078   {
41079     try {
41080       delete arg1;
41081     } CALL_CATCH_EXCEPTION();
41082   }
41083
41084 }
41085
41086
41087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
41088   void * jresult ;
41089   Dali::Toolkit::FlexContainer result;
41090
41091   {
41092     try {
41093       result = Dali::Toolkit::FlexContainer::New();
41094     } CALL_CATCH_EXCEPTION(0);
41095   }
41096
41097   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
41098   return jresult;
41099 }
41100
41101
41102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
41103   void * jresult ;
41104   Dali::BaseHandle arg1 ;
41105   Dali::BaseHandle *argp1 ;
41106   Dali::Toolkit::FlexContainer result;
41107
41108   argp1 = (Dali::BaseHandle *)jarg1;
41109   if (!argp1) {
41110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41111     return 0;
41112   }
41113   arg1 = *argp1;
41114   {
41115     try {
41116       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
41117     } CALL_CATCH_EXCEPTION(0);
41118   }
41119
41120   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
41121   return jresult;
41122 }
41123
41124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
41125   int jresult ;
41126   int result;
41127
41128   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
41129   jresult = (int)result;
41130   return jresult;
41131 }
41132
41133
41134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
41135   int jresult ;
41136   int result;
41137
41138   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
41139   jresult = (int)result;
41140   return jresult;
41141 }
41142
41143
41144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
41145   int jresult ;
41146   int result;
41147
41148   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
41149   jresult = (int)result;
41150   return jresult;
41151 }
41152
41153
41154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
41155   void * jresult ;
41156   Dali::Toolkit::ImageView::Property *result = 0 ;
41157
41158   {
41159     try {
41160       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
41161     } CALL_CATCH_EXCEPTION(0);
41162   }
41163
41164   jresult = (void *)result;
41165   return jresult;
41166 }
41167
41168
41169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
41170   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
41171
41172   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
41173   {
41174     try {
41175       delete arg1;
41176     } CALL_CATCH_EXCEPTION();
41177   }
41178
41179 }
41180
41181
41182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
41183   void * jresult ;
41184   Dali::Toolkit::ImageView *result = 0 ;
41185
41186   {
41187     try {
41188       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
41189     } CALL_CATCH_EXCEPTION(0);
41190   }
41191
41192   jresult = (void *)result;
41193   return jresult;
41194 }
41195
41196
41197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
41198   void * jresult ;
41199   Dali::Toolkit::ImageView result;
41200
41201   {
41202     try {
41203       result = Dali::Toolkit::ImageView::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
41204     } CALL_CATCH_EXCEPTION(0);
41205   }
41206
41207   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
41208   return jresult;
41209 }
41210
41211
41212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
41213   void * jresult ;
41214   std::string *arg1 = 0 ;
41215   Dali::Toolkit::ImageView result;
41216
41217   if (!jarg1) {
41218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
41219     return 0;
41220   }
41221   std::string arg1_str(jarg1);
41222   arg1 = &arg1_str;
41223   {
41224     try {
41225       result = Dali::Toolkit::ImageView::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS, (std::string const &)*arg1);
41226     } CALL_CATCH_EXCEPTION(0);
41227   }
41228
41229   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
41230
41231   //argout typemap for const std::string&
41232
41233   return jresult;
41234 }
41235
41236
41237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
41238   void * jresult ;
41239   std::string *arg1 = 0 ;
41240   Dali::ImageDimensions arg2 ;
41241   Dali::ImageDimensions *argp2 ;
41242   Dali::Toolkit::ImageView result;
41243
41244   if (!jarg1) {
41245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
41246     return 0;
41247   }
41248   std::string arg1_str(jarg1);
41249   arg1 = &arg1_str;
41250   argp2 = (Dali::ImageDimensions *)jarg2;
41251   if (!argp2) {
41252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41253     return 0;
41254   }
41255   arg2 = *argp2;
41256   {
41257     try {
41258       result = Dali::Toolkit::ImageView::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS, (std::string const &)*arg1,arg2);
41259     } CALL_CATCH_EXCEPTION(0);
41260   }
41261
41262   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
41263
41264   //argout typemap for const std::string&
41265
41266   return jresult;
41267 }
41268
41269
41270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
41271   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
41272
41273   arg1 = (Dali::Toolkit::ImageView *)jarg1;
41274   {
41275     try {
41276       delete arg1;
41277     } CALL_CATCH_EXCEPTION();
41278   }
41279
41280 }
41281
41282
41283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
41284   void * jresult ;
41285   Dali::Toolkit::ImageView *arg1 = 0 ;
41286   Dali::Toolkit::ImageView *result = 0 ;
41287
41288   arg1 = (Dali::Toolkit::ImageView *)jarg1;
41289   if (!arg1) {
41290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
41291     return 0;
41292   }
41293   {
41294     try {
41295       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
41296     } CALL_CATCH_EXCEPTION(0);
41297   }
41298
41299   jresult = (void *)result;
41300   return jresult;
41301 }
41302
41303
41304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
41305   void * jresult ;
41306   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
41307   Dali::Toolkit::ImageView *arg2 = 0 ;
41308   Dali::Toolkit::ImageView *result = 0 ;
41309
41310   arg1 = (Dali::Toolkit::ImageView *)jarg1;
41311   arg2 = (Dali::Toolkit::ImageView *)jarg2;
41312   if (!arg2) {
41313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
41314     return 0;
41315   }
41316   {
41317     try {
41318       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
41319     } CALL_CATCH_EXCEPTION(0);
41320   }
41321
41322   jresult = (void *)result;
41323   return jresult;
41324 }
41325
41326
41327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
41328   void * jresult ;
41329   Dali::BaseHandle arg1 ;
41330   Dali::BaseHandle *argp1 ;
41331   Dali::Toolkit::ImageView result;
41332
41333   argp1 = (Dali::BaseHandle *)jarg1;
41334   if (!argp1) {
41335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41336     return 0;
41337   }
41338   arg1 = *argp1;
41339   {
41340     try {
41341       result = Dali::Toolkit::ImageView::DownCast(arg1);
41342     } CALL_CATCH_EXCEPTION(0);
41343   }
41344
41345   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
41346   return jresult;
41347 }
41348
41349
41350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
41351   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
41352   std::string *arg2 = 0 ;
41353
41354   arg1 = (Dali::Toolkit::ImageView *)jarg1;
41355   if (!jarg2) {
41356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
41357     return ;
41358   }
41359   std::string arg2_str(jarg2);
41360   arg2 = &arg2_str;
41361   {
41362     try {
41363       (arg1)->SetImage((std::string const &)*arg2);
41364     } CALL_CATCH_EXCEPTION();
41365   }
41366
41367
41368   //argout typemap for const std::string&
41369
41370 }
41371
41372
41373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
41374   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
41375   std::string *arg2 = 0 ;
41376   Dali::ImageDimensions arg3 ;
41377   Dali::ImageDimensions *argp3 ;
41378
41379   arg1 = (Dali::Toolkit::ImageView *)jarg1;
41380   if (!jarg2) {
41381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
41382     return ;
41383   }
41384   std::string arg2_str(jarg2);
41385   arg2 = &arg2_str;
41386   argp3 = (Dali::ImageDimensions *)jarg3;
41387   if (!argp3) {
41388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41389     return ;
41390   }
41391   arg3 = *argp3;
41392   {
41393     try {
41394       (arg1)->SetImage((std::string const &)*arg2,arg3);
41395     } CALL_CATCH_EXCEPTION();
41396   }
41397
41398
41399   //argout typemap for const std::string&
41400
41401 }
41402
41403
41404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
41405   int jresult ;
41406   int result;
41407
41408   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
41409   jresult = (int)result;
41410   return jresult;
41411 }
41412
41413
41414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
41415   int jresult ;
41416   int result;
41417
41418   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
41419   jresult = (int)result;
41420   return jresult;
41421 }
41422
41423
41424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
41425   int jresult ;
41426   int result;
41427
41428   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
41429   jresult = (int)result;
41430   return jresult;
41431 }
41432
41433
41434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
41435   int jresult ;
41436   int result;
41437
41438   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
41439   jresult = (int)result;
41440   return jresult;
41441 }
41442
41443
41444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
41445   int jresult ;
41446   int result;
41447
41448   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
41449   jresult = (int)result;
41450   return jresult;
41451 }
41452
41453
41454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
41455   int jresult ;
41456   int result;
41457
41458   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
41459   jresult = (int)result;
41460   return jresult;
41461 }
41462
41463
41464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
41465   int jresult ;
41466   int result;
41467
41468   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
41469   jresult = (int)result;
41470   return jresult;
41471 }
41472
41473
41474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
41475   int jresult ;
41476   int result;
41477
41478   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
41479   jresult = (int)result;
41480   return jresult;
41481 }
41482
41483
41484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
41485   int jresult ;
41486   int result;
41487
41488   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
41489   jresult = (int)result;
41490   return jresult;
41491 }
41492
41493
41494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
41495   void * jresult ;
41496   Dali::Toolkit::ScrollBar::Property *result = 0 ;
41497
41498   {
41499     try {
41500       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
41501     } CALL_CATCH_EXCEPTION(0);
41502   }
41503
41504   jresult = (void *)result;
41505   return jresult;
41506 }
41507
41508
41509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
41510   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
41511
41512   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
41513   {
41514     try {
41515       delete arg1;
41516     } CALL_CATCH_EXCEPTION();
41517   }
41518
41519 }
41520
41521
41522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
41523   void * jresult ;
41524   Dali::Toolkit::ScrollBar *result = 0 ;
41525
41526   {
41527     try {
41528       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
41529     } CALL_CATCH_EXCEPTION(0);
41530   }
41531
41532   jresult = (void *)result;
41533   return jresult;
41534 }
41535
41536
41537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
41538   void * jresult ;
41539   Dali::Toolkit::ScrollBar *arg1 = 0 ;
41540   Dali::Toolkit::ScrollBar *result = 0 ;
41541
41542   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41543   if (!arg1) {
41544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
41545     return 0;
41546   }
41547   {
41548     try {
41549       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
41550     } CALL_CATCH_EXCEPTION(0);
41551   }
41552
41553   jresult = (void *)result;
41554   return jresult;
41555 }
41556
41557
41558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
41559   void * jresult ;
41560   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41561   Dali::Toolkit::ScrollBar *arg2 = 0 ;
41562   Dali::Toolkit::ScrollBar *result = 0 ;
41563
41564   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41565   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
41566   if (!arg2) {
41567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
41568     return 0;
41569   }
41570   {
41571     try {
41572       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
41573     } CALL_CATCH_EXCEPTION(0);
41574   }
41575
41576   jresult = (void *)result;
41577   return jresult;
41578 }
41579
41580
41581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
41582   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41583
41584   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41585   {
41586     try {
41587       delete arg1;
41588     } CALL_CATCH_EXCEPTION();
41589   }
41590
41591 }
41592
41593
41594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
41595   void * jresult ;
41596   Dali::Toolkit::ScrollBar::Direction arg1 ;
41597   Dali::Toolkit::ScrollBar result;
41598
41599   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
41600   {
41601     try {
41602       result = Dali::Toolkit::ScrollBar::New(arg1);
41603     } CALL_CATCH_EXCEPTION(0);
41604   }
41605
41606   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
41607   return jresult;
41608 }
41609
41610
41611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
41612   void * jresult ;
41613   Dali::Toolkit::ScrollBar result;
41614
41615   {
41616     try {
41617       result = Dali::Toolkit::ScrollBar::New();
41618     } CALL_CATCH_EXCEPTION(0);
41619   }
41620
41621   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
41622   return jresult;
41623 }
41624
41625
41626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
41627   void * jresult ;
41628   Dali::BaseHandle arg1 ;
41629   Dali::BaseHandle *argp1 ;
41630   Dali::Toolkit::ScrollBar result;
41631
41632   argp1 = (Dali::BaseHandle *)jarg1;
41633   if (!argp1) {
41634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41635     return 0;
41636   }
41637   arg1 = *argp1;
41638   {
41639     try {
41640       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
41641     } CALL_CATCH_EXCEPTION(0);
41642   }
41643
41644   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
41645   return jresult;
41646 }
41647
41648
41649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
41650   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41651   Dali::Handle arg2 ;
41652   Dali::Property::Index arg3 ;
41653   Dali::Property::Index arg4 ;
41654   Dali::Property::Index arg5 ;
41655   Dali::Property::Index arg6 ;
41656   Dali::Handle *argp2 ;
41657
41658   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41659   argp2 = (Dali::Handle *)jarg2;
41660   if (!argp2) {
41661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
41662     return ;
41663   }
41664   arg2 = *argp2;
41665   arg3 = (Dali::Property::Index)jarg3;
41666   arg4 = (Dali::Property::Index)jarg4;
41667   arg5 = (Dali::Property::Index)jarg5;
41668   arg6 = (Dali::Property::Index)jarg6;
41669   {
41670     try {
41671       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
41672     } CALL_CATCH_EXCEPTION();
41673   }
41674
41675 }
41676
41677
41678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
41679   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41680   Dali::Actor arg2 ;
41681   Dali::Actor *argp2 ;
41682
41683   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41684   argp2 = (Dali::Actor *)jarg2;
41685   if (!argp2) {
41686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
41687     return ;
41688   }
41689   arg2 = *argp2;
41690   {
41691     try {
41692       (arg1)->SetScrollIndicator(arg2);
41693     } CALL_CATCH_EXCEPTION();
41694   }
41695
41696 }
41697
41698
41699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
41700   void * jresult ;
41701   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41702   Dali::Actor result;
41703
41704   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41705   {
41706     try {
41707       result = (arg1)->GetScrollIndicator();
41708     } CALL_CATCH_EXCEPTION(0);
41709   }
41710
41711   jresult = new Dali::Actor((const Dali::Actor &)result);
41712   return jresult;
41713 }
41714
41715
41716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
41717   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41718   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
41719
41720   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41721   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
41722   if (!arg2) {
41723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
41724     return ;
41725   }
41726   {
41727     try {
41728       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
41729     } CALL_CATCH_EXCEPTION();
41730   }
41731
41732 }
41733
41734
41735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
41736   void * jresult ;
41737   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41738
41739   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41740   {
41741     try {
41742       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()));
41743     } CALL_CATCH_EXCEPTION(0);
41744   }
41745   return jresult;
41746 }
41747
41748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
41749   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41750   Dali::Toolkit::ScrollBar::Direction arg2 ;
41751
41752   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41753   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
41754   {
41755     try {
41756       (arg1)->SetScrollDirection(arg2);
41757     } CALL_CATCH_EXCEPTION();
41758   }
41759
41760 }
41761
41762
41763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
41764   int jresult ;
41765   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41766   Dali::Toolkit::ScrollBar::Direction result;
41767
41768   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41769   {
41770     try {
41771       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
41772     } CALL_CATCH_EXCEPTION(0);
41773   }
41774
41775   jresult = (int)result;
41776   return jresult;
41777 }
41778
41779
41780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
41781   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41782   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
41783
41784   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41785   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
41786   {
41787     try {
41788       (arg1)->SetIndicatorHeightPolicy(arg2);
41789     } CALL_CATCH_EXCEPTION();
41790   }
41791
41792 }
41793
41794
41795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
41796   int jresult ;
41797   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41798   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
41799
41800   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41801   {
41802     try {
41803       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
41804     } CALL_CATCH_EXCEPTION(0);
41805   }
41806
41807   jresult = (int)result;
41808   return jresult;
41809 }
41810
41811
41812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
41813   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41814   float arg2 ;
41815
41816   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41817   arg2 = (float)jarg2;
41818   {
41819     try {
41820       (arg1)->SetIndicatorFixedHeight(arg2);
41821     } CALL_CATCH_EXCEPTION();
41822   }
41823
41824 }
41825
41826
41827 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
41828   float jresult ;
41829   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41830   float result;
41831
41832   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41833   {
41834     try {
41835       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
41836     } CALL_CATCH_EXCEPTION(0);
41837   }
41838
41839   jresult = result;
41840   return jresult;
41841 }
41842
41843
41844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
41845   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41846   float arg2 ;
41847
41848   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41849   arg2 = (float)jarg2;
41850   {
41851     try {
41852       (arg1)->SetIndicatorShowDuration(arg2);
41853     } CALL_CATCH_EXCEPTION();
41854   }
41855
41856 }
41857
41858
41859 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
41860   float jresult ;
41861   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41862   float result;
41863
41864   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41865   {
41866     try {
41867       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
41868     } CALL_CATCH_EXCEPTION(0);
41869   }
41870
41871   jresult = result;
41872   return jresult;
41873 }
41874
41875
41876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
41877   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41878   float arg2 ;
41879
41880   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41881   arg2 = (float)jarg2;
41882   {
41883     try {
41884       (arg1)->SetIndicatorHideDuration(arg2);
41885     } CALL_CATCH_EXCEPTION();
41886   }
41887
41888 }
41889
41890
41891 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
41892   float jresult ;
41893   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41894   float result;
41895
41896   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41897   {
41898     try {
41899       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
41900     } CALL_CATCH_EXCEPTION(0);
41901   }
41902
41903   jresult = result;
41904   return jresult;
41905 }
41906
41907
41908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
41909   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41910
41911   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41912   {
41913     try {
41914       (arg1)->ShowIndicator();
41915     } CALL_CATCH_EXCEPTION();
41916   }
41917
41918 }
41919
41920
41921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
41922   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41923
41924   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41925   {
41926     try {
41927       (arg1)->HideIndicator();
41928     } CALL_CATCH_EXCEPTION();
41929   }
41930
41931 }
41932
41933
41934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
41935   void * jresult ;
41936   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41937   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
41938
41939   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41940   {
41941     try {
41942       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
41943     } CALL_CATCH_EXCEPTION(0);
41944   }
41945
41946   jresult = (void *)result;
41947   return jresult;
41948 }
41949
41950
41951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
41952   void * jresult ;
41953   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41954   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
41955
41956   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41957   {
41958     try {
41959       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
41960     } CALL_CATCH_EXCEPTION(0);
41961   }
41962
41963   jresult = (void *)result;
41964   return jresult;
41965 }
41966
41967
41968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
41969   int jresult ;
41970   int result;
41971
41972   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
41973   jresult = (int)result;
41974   return jresult;
41975 }
41976
41977
41978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
41979   int jresult ;
41980   int result;
41981
41982   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
41983   jresult = (int)result;
41984   return jresult;
41985 }
41986
41987
41988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
41989   int jresult ;
41990   int result;
41991
41992   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
41993   jresult = (int)result;
41994   return jresult;
41995 }
41996
41997
41998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
41999   int jresult ;
42000   int result;
42001
42002   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
42003   jresult = (int)result;
42004   return jresult;
42005 }
42006
42007
42008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
42009   int jresult ;
42010   int result;
42011
42012   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
42013   jresult = (int)result;
42014   return jresult;
42015 }
42016
42017
42018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
42019   int jresult ;
42020   int result;
42021
42022   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
42023   jresult = (int)result;
42024   return jresult;
42025 }
42026
42027
42028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
42029   int jresult ;
42030   int result;
42031
42032   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
42033   jresult = (int)result;
42034   return jresult;
42035 }
42036
42037
42038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
42039   int jresult ;
42040   int result;
42041
42042   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
42043   jresult = (int)result;
42044   return jresult;
42045 }
42046
42047
42048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
42049   int jresult ;
42050   int result;
42051
42052   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
42053   jresult = (int)result;
42054   return jresult;
42055 }
42056
42057
42058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
42059   int jresult ;
42060   int result;
42061
42062   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
42063   jresult = (int)result;
42064   return jresult;
42065 }
42066
42067
42068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
42069   int jresult ;
42070   int result;
42071
42072   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
42073   jresult = (int)result;
42074   return jresult;
42075 }
42076
42077
42078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
42079   int jresult ;
42080   int result;
42081
42082   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
42083   jresult = (int)result;
42084   return jresult;
42085 }
42086
42087
42088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
42089   int jresult ;
42090   int result;
42091
42092   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
42093   jresult = (int)result;
42094   return jresult;
42095 }
42096
42097
42098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
42099   int jresult ;
42100   int result;
42101
42102   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
42103   jresult = (int)result;
42104   return jresult;
42105 }
42106
42107
42108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
42109   void * jresult ;
42110   Dali::Toolkit::Scrollable::Property *result = 0 ;
42111
42112   {
42113     try {
42114       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
42115     } CALL_CATCH_EXCEPTION(0);
42116   }
42117
42118   jresult = (void *)result;
42119   return jresult;
42120 }
42121
42122
42123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
42124   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
42125
42126   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
42127   {
42128     try {
42129       delete arg1;
42130     } CALL_CATCH_EXCEPTION();
42131   }
42132
42133 }
42134
42135
42136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
42137   void * jresult ;
42138   Dali::Toolkit::Scrollable *result = 0 ;
42139
42140   {
42141     try {
42142       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
42143     } CALL_CATCH_EXCEPTION(0);
42144   }
42145
42146   jresult = (void *)result;
42147   return jresult;
42148 }
42149
42150
42151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
42152   void * jresult ;
42153   Dali::Toolkit::Scrollable *arg1 = 0 ;
42154   Dali::Toolkit::Scrollable *result = 0 ;
42155
42156   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
42157   if (!arg1) {
42158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
42159     return 0;
42160   }
42161   {
42162     try {
42163       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
42164     } CALL_CATCH_EXCEPTION(0);
42165   }
42166
42167   jresult = (void *)result;
42168   return jresult;
42169 }
42170
42171
42172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
42173   void * jresult ;
42174   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
42175   Dali::Toolkit::Scrollable *arg2 = 0 ;
42176   Dali::Toolkit::Scrollable *result = 0 ;
42177
42178   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
42179   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
42180   if (!arg2) {
42181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
42182     return 0;
42183   }
42184   {
42185     try {
42186       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
42187     } CALL_CATCH_EXCEPTION(0);
42188   }
42189
42190   jresult = (void *)result;
42191   return jresult;
42192 }
42193
42194
42195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
42196   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
42197
42198   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
42199   {
42200     try {
42201       delete arg1;
42202     } CALL_CATCH_EXCEPTION();
42203   }
42204
42205 }
42206
42207
42208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
42209   void * jresult ;
42210   Dali::BaseHandle arg1 ;
42211   Dali::BaseHandle *argp1 ;
42212   Dali::Toolkit::Scrollable result;
42213
42214   argp1 = (Dali::BaseHandle *)jarg1;
42215   if (!argp1) {
42216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42217     return 0;
42218   }
42219   arg1 = *argp1;
42220   {
42221     try {
42222       result = Dali::Toolkit::Scrollable::DownCast(arg1);
42223     } CALL_CATCH_EXCEPTION(0);
42224   }
42225
42226   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
42227   return jresult;
42228 }
42229
42230
42231 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
42232   bool jresult ;
42233   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
42234   bool result;
42235
42236   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
42237   {
42238     try {
42239       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
42240     } CALL_CATCH_EXCEPTION(0);
42241   }
42242
42243   jresult = result;
42244   return jresult;
42245 }
42246
42247
42248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, bool jarg2) {
42249   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
42250   bool arg2 ;
42251
42252   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
42253   arg2 = jarg2 ? true : false;
42254   {
42255     try {
42256       (arg1)->SetOvershootEnabled(arg2);
42257     } CALL_CATCH_EXCEPTION();
42258   }
42259
42260 }
42261
42262
42263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
42264   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
42265   Dali::Vector4 *arg2 = 0 ;
42266
42267   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
42268   arg2 = (Dali::Vector4 *)jarg2;
42269   if (!arg2) {
42270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
42271     return ;
42272   }
42273   {
42274     try {
42275       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
42276     } CALL_CATCH_EXCEPTION();
42277   }
42278
42279 }
42280
42281
42282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
42283   void * jresult ;
42284   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
42285   Dali::Vector4 result;
42286
42287   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
42288   {
42289     try {
42290       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
42291     } CALL_CATCH_EXCEPTION(0);
42292   }
42293
42294   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42295   return jresult;
42296 }
42297
42298
42299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
42300   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
42301   float arg2 ;
42302
42303   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
42304   arg2 = (float)jarg2;
42305   {
42306     try {
42307       (arg1)->SetOvershootAnimationSpeed(arg2);
42308     } CALL_CATCH_EXCEPTION();
42309   }
42310
42311 }
42312
42313
42314 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
42315   float jresult ;
42316   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
42317   float result;
42318
42319   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
42320   {
42321     try {
42322       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
42323     } CALL_CATCH_EXCEPTION(0);
42324   }
42325
42326   jresult = result;
42327   return jresult;
42328 }
42329
42330
42331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
42332   void * jresult ;
42333   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
42334   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
42335
42336   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
42337   {
42338     try {
42339       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
42340     } CALL_CATCH_EXCEPTION(0);
42341   }
42342
42343   jresult = (void *)result;
42344   return jresult;
42345 }
42346
42347
42348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
42349   void * jresult ;
42350   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
42351   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
42352
42353   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
42354   {
42355     try {
42356       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
42357     } CALL_CATCH_EXCEPTION(0);
42358   }
42359
42360   jresult = (void *)result;
42361   return jresult;
42362 }
42363
42364
42365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
42366   void * jresult ;
42367   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
42368   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
42369
42370   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
42371   {
42372     try {
42373       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
42374     } CALL_CATCH_EXCEPTION(0);
42375   }
42376
42377   jresult = (void *)result;
42378   return jresult;
42379 }
42380
42381
42382 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
42383   bool jresult ;
42384   Dali::Toolkit::ControlOrientation::Type arg1 ;
42385   bool result;
42386
42387   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
42388   {
42389     try {
42390       result = (bool)Dali::Toolkit::IsVertical(arg1);
42391     } CALL_CATCH_EXCEPTION(0);
42392   }
42393
42394   jresult = result;
42395   return jresult;
42396 }
42397
42398
42399 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
42400   bool jresult ;
42401   Dali::Toolkit::ControlOrientation::Type arg1 ;
42402   bool result;
42403
42404   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
42405   {
42406     try {
42407       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
42408     } CALL_CATCH_EXCEPTION(0);
42409   }
42410
42411   jresult = result;
42412   return jresult;
42413 }
42414
42415
42416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
42417   void * jresult ;
42418   unsigned int arg1 ;
42419   unsigned int arg2 ;
42420   Dali::Toolkit::ItemRange *result = 0 ;
42421
42422   arg1 = (unsigned int)jarg1;
42423   arg2 = (unsigned int)jarg2;
42424   {
42425     try {
42426       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
42427     } CALL_CATCH_EXCEPTION(0);
42428   }
42429
42430   jresult = (void *)result;
42431   return jresult;
42432 }
42433
42434
42435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
42436   void * jresult ;
42437   Dali::Toolkit::ItemRange *arg1 = 0 ;
42438   Dali::Toolkit::ItemRange *result = 0 ;
42439
42440   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
42441   if (!arg1) {
42442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
42443     return 0;
42444   }
42445   {
42446     try {
42447       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
42448     } CALL_CATCH_EXCEPTION(0);
42449   }
42450
42451   jresult = (void *)result;
42452   return jresult;
42453 }
42454
42455
42456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
42457   void * jresult ;
42458   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
42459   Dali::Toolkit::ItemRange *arg2 = 0 ;
42460   Dali::Toolkit::ItemRange *result = 0 ;
42461
42462   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
42463   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
42464   if (!arg2) {
42465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
42466     return 0;
42467   }
42468   {
42469     try {
42470       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
42471     } CALL_CATCH_EXCEPTION(0);
42472   }
42473
42474   jresult = (void *)result;
42475   return jresult;
42476 }
42477
42478
42479 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
42480   bool jresult ;
42481   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
42482   unsigned int arg2 ;
42483   bool result;
42484
42485   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
42486   arg2 = (unsigned int)jarg2;
42487   {
42488     try {
42489       result = (bool)(arg1)->Within(arg2);
42490     } CALL_CATCH_EXCEPTION(0);
42491   }
42492
42493   jresult = result;
42494   return jresult;
42495 }
42496
42497
42498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
42499   void * jresult ;
42500   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
42501   Dali::Toolkit::ItemRange *arg2 = 0 ;
42502   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
42503
42504   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
42505   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
42506   if (!arg2) {
42507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
42508     return 0;
42509   }
42510   {
42511     try {
42512       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
42513     } CALL_CATCH_EXCEPTION(0);
42514   }
42515
42516   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
42517   return jresult;
42518 }
42519
42520
42521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
42522   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
42523   unsigned int arg2 ;
42524
42525   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
42526   arg2 = (unsigned int)jarg2;
42527   if (arg1) (arg1)->begin = arg2;
42528 }
42529
42530
42531 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
42532   unsigned int jresult ;
42533   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
42534   unsigned int result;
42535
42536   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
42537   result = (unsigned int) ((arg1)->begin);
42538   jresult = result;
42539   return jresult;
42540 }
42541
42542
42543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
42544   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
42545   unsigned int arg2 ;
42546
42547   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
42548   arg2 = (unsigned int)jarg2;
42549   if (arg1) (arg1)->end = arg2;
42550 }
42551
42552
42553 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
42554   unsigned int jresult ;
42555   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
42556   unsigned int result;
42557
42558   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
42559   result = (unsigned int) ((arg1)->end);
42560   jresult = result;
42561   return jresult;
42562 }
42563
42564
42565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
42566   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
42567
42568   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
42569   {
42570     try {
42571       delete arg1;
42572     } CALL_CATCH_EXCEPTION();
42573   }
42574
42575 }
42576
42577
42578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
42579   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42580
42581   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42582   {
42583     try {
42584       delete arg1;
42585     } CALL_CATCH_EXCEPTION();
42586   }
42587
42588 }
42589
42590
42591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
42592   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42593   Dali::Toolkit::ControlOrientation::Type arg2 ;
42594
42595   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42596   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
42597   {
42598     try {
42599       (arg1)->SetOrientation(arg2);
42600     } CALL_CATCH_EXCEPTION();
42601   }
42602
42603 }
42604
42605
42606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
42607   int jresult ;
42608   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42609   Dali::Toolkit::ControlOrientation::Type result;
42610
42611   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42612   {
42613     try {
42614       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
42615     } CALL_CATCH_EXCEPTION(0);
42616   }
42617
42618   jresult = (int)result;
42619   return jresult;
42620 }
42621
42622
42623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
42624   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42625   Dali::Property::Map *arg2 = 0 ;
42626
42627   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42628   arg2 = (Dali::Property::Map *)jarg2;
42629   if (!arg2) {
42630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
42631     return ;
42632   }
42633   {
42634     try {
42635       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
42636     } CALL_CATCH_EXCEPTION();
42637   }
42638
42639 }
42640
42641
42642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
42643   void * jresult ;
42644   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42645   Dali::Property::Map result;
42646
42647   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42648   {
42649     try {
42650       result = (arg1)->GetLayoutProperties();
42651     } CALL_CATCH_EXCEPTION(0);
42652   }
42653
42654   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
42655   return jresult;
42656 }
42657
42658
42659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
42660   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42661   unsigned int arg2 ;
42662   Dali::Vector3 *arg3 = 0 ;
42663   Dali::Vector3 *arg4 = 0 ;
42664
42665   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42666   arg2 = (unsigned int)jarg2;
42667   arg3 = (Dali::Vector3 *)jarg3;
42668   if (!arg3) {
42669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42670     return ;
42671   }
42672   arg4 = (Dali::Vector3 *)jarg4;
42673   if (!arg4) {
42674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
42675     return ;
42676   }
42677   {
42678     try {
42679       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
42680     } CALL_CATCH_EXCEPTION();
42681   }
42682
42683 }
42684
42685
42686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
42687   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42688   Dali::Vector3 *arg2 = 0 ;
42689
42690   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42691   arg2 = (Dali::Vector3 *)jarg2;
42692   if (!arg2) {
42693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42694     return ;
42695   }
42696   {
42697     try {
42698       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
42699     } CALL_CATCH_EXCEPTION();
42700   }
42701
42702 }
42703
42704
42705 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
42706   float jresult ;
42707   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42708   unsigned int arg2 ;
42709   Dali::Vector3 arg3 ;
42710   Dali::Vector3 *argp3 ;
42711   float result;
42712
42713   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42714   arg2 = (unsigned int)jarg2;
42715   argp3 = (Dali::Vector3 *)jarg3;
42716   if (!argp3) {
42717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
42718     return 0;
42719   }
42720   arg3 = *argp3;
42721   {
42722     try {
42723       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
42724     } CALL_CATCH_EXCEPTION(0);
42725   }
42726
42727   jresult = result;
42728   return jresult;
42729 }
42730
42731
42732 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
42733   float jresult ;
42734   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42735   float arg2 ;
42736   float result;
42737
42738   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42739   arg2 = (float)jarg2;
42740   {
42741     try {
42742       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
42743     } CALL_CATCH_EXCEPTION(0);
42744   }
42745
42746   jresult = result;
42747   return jresult;
42748 }
42749
42750
42751 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
42752   float jresult ;
42753   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42754   unsigned int arg2 ;
42755   float result;
42756
42757   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42758   arg2 = (unsigned int)jarg2;
42759   {
42760     try {
42761       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
42762     } CALL_CATCH_EXCEPTION(0);
42763   }
42764
42765   jresult = result;
42766   return jresult;
42767 }
42768
42769
42770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
42771   void * jresult ;
42772   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42773   float arg2 ;
42774   Dali::Vector3 arg3 ;
42775   Dali::Vector3 *argp3 ;
42776   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
42777
42778   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42779   arg2 = (float)jarg2;
42780   argp3 = (Dali::Vector3 *)jarg3;
42781   if (!argp3) {
42782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
42783     return 0;
42784   }
42785   arg3 = *argp3;
42786   {
42787     try {
42788       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
42789     } CALL_CATCH_EXCEPTION(0);
42790   }
42791
42792   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
42793   return jresult;
42794 }
42795
42796
42797 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
42798   float jresult ;
42799   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42800   int arg2 ;
42801   float arg3 ;
42802   Dali::Vector3 *arg4 = 0 ;
42803   float result;
42804
42805   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42806   arg2 = (int)jarg2;
42807   arg3 = (float)jarg3;
42808   arg4 = (Dali::Vector3 *)jarg4;
42809   if (!arg4) {
42810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42811     return 0;
42812   }
42813   {
42814     try {
42815       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
42816     } CALL_CATCH_EXCEPTION(0);
42817   }
42818
42819   jresult = result;
42820   return jresult;
42821 }
42822
42823
42824 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
42825   unsigned int jresult ;
42826   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42827   Dali::Vector3 arg2 ;
42828   Dali::Vector3 *argp2 ;
42829   unsigned int result;
42830
42831   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42832   argp2 = (Dali::Vector3 *)jarg2;
42833   if (!argp2) {
42834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
42835     return 0;
42836   }
42837   arg2 = *argp2;
42838   {
42839     try {
42840       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
42841     } CALL_CATCH_EXCEPTION(0);
42842   }
42843
42844   jresult = result;
42845   return jresult;
42846 }
42847
42848
42849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
42850   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42851   unsigned int arg2 ;
42852   Dali::Vector3 *arg3 = 0 ;
42853   Dali::Vector3 *arg4 = 0 ;
42854
42855   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42856   arg2 = (unsigned int)jarg2;
42857   arg3 = (Dali::Vector3 *)jarg3;
42858   if (!arg3) {
42859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42860     return ;
42861   }
42862   arg4 = (Dali::Vector3 *)jarg4;
42863   if (!arg4) {
42864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
42865     return ;
42866   }
42867   {
42868     try {
42869       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
42870     } CALL_CATCH_EXCEPTION();
42871   }
42872
42873 }
42874
42875
42876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
42877   void * jresult ;
42878   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42879   Dali::Degree result;
42880
42881   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42882   {
42883     try {
42884       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
42885     } CALL_CATCH_EXCEPTION(0);
42886   }
42887
42888   jresult = new Dali::Degree((const Dali::Degree &)result);
42889   return jresult;
42890 }
42891
42892
42893 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
42894   float jresult ;
42895   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42896   float result;
42897
42898   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42899   {
42900     try {
42901       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
42902     } CALL_CATCH_EXCEPTION(0);
42903   }
42904
42905   jresult = result;
42906   return jresult;
42907 }
42908
42909
42910 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
42911   float jresult ;
42912   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42913   float result;
42914
42915   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42916   {
42917     try {
42918       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
42919     } CALL_CATCH_EXCEPTION(0);
42920   }
42921
42922   jresult = result;
42923   return jresult;
42924 }
42925
42926
42927 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
42928   float jresult ;
42929   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42930   float result;
42931
42932   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42933   {
42934     try {
42935       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
42936     } CALL_CATCH_EXCEPTION(0);
42937   }
42938
42939   jresult = result;
42940   return jresult;
42941 }
42942
42943
42944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, bool jarg5) {
42945   int jresult ;
42946   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42947   int arg2 ;
42948   int arg3 ;
42949   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
42950   bool arg5 ;
42951   int result;
42952
42953   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42954   arg2 = (int)jarg2;
42955   arg3 = (int)jarg3;
42956   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
42957   arg5 = jarg5 ? true : false;
42958   {
42959     try {
42960       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
42961     } CALL_CATCH_EXCEPTION(0);
42962   }
42963
42964   jresult = result;
42965   return jresult;
42966 }
42967
42968
42969 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
42970   float jresult ;
42971   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42972   float result;
42973
42974   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42975   {
42976     try {
42977       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
42978     } CALL_CATCH_EXCEPTION(0);
42979   }
42980
42981   jresult = result;
42982   return jresult;
42983 }
42984
42985
42986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
42987   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42988   Dali::Actor *arg2 = 0 ;
42989   int arg3 ;
42990   Dali::Vector3 *arg4 = 0 ;
42991   Dali::Actor *arg5 = 0 ;
42992
42993   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42994   arg2 = (Dali::Actor *)jarg2;
42995   if (!arg2) {
42996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
42997     return ;
42998   }
42999   arg3 = (int)jarg3;
43000   arg4 = (Dali::Vector3 *)jarg4;
43001   if (!arg4) {
43002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43003     return ;
43004   }
43005   arg5 = (Dali::Actor *)jarg5;
43006   if (!arg5) {
43007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
43008     return ;
43009   }
43010   {
43011     try {
43012       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
43013     } CALL_CATCH_EXCEPTION();
43014   }
43015
43016 }
43017
43018
43019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
43020   void * jresult ;
43021   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43022   int arg2 ;
43023   float arg3 ;
43024   Dali::Vector3 *arg4 = 0 ;
43025   Dali::Vector3 result;
43026
43027   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43028   arg2 = (int)jarg2;
43029   arg3 = (float)jarg3;
43030   arg4 = (Dali::Vector3 *)jarg4;
43031   if (!arg4) {
43032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43033     return 0;
43034   }
43035   {
43036     try {
43037       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
43038     } CALL_CATCH_EXCEPTION(0);
43039   }
43040
43041   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
43042   return jresult;
43043 }
43044
43045
43046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
43047   void * jresult ;
43048   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
43049   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
43050
43051   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
43052   {
43053     try {
43054       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
43055     } CALL_CATCH_EXCEPTION(0);
43056   }
43057
43058   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
43059   return jresult;
43060 }
43061
43062
43063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
43064   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
43065
43066   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
43067   {
43068     try {
43069       delete arg1;
43070     } CALL_CATCH_EXCEPTION();
43071   }
43072
43073 }
43074
43075
43076 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
43077   unsigned int jresult ;
43078   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
43079   unsigned int result;
43080
43081   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
43082   {
43083     try {
43084       result = (unsigned int)(arg1)->GetNumberOfItems();
43085     } CALL_CATCH_EXCEPTION(0);
43086   }
43087
43088   jresult = result;
43089   return jresult;
43090 }
43091
43092
43093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
43094   void * jresult ;
43095   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
43096   unsigned int arg2 ;
43097   Dali::Actor result;
43098
43099   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
43100   arg2 = (unsigned int)jarg2;
43101   {
43102     try {
43103       result = (arg1)->NewItem(arg2);
43104     } CALL_CATCH_EXCEPTION(0);
43105   }
43106
43107   jresult = new Dali::Actor((const Dali::Actor &)result);
43108   return jresult;
43109 }
43110
43111
43112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
43113   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
43114   unsigned int arg2 ;
43115   Dali::Actor arg3 ;
43116   Dali::Actor *argp3 ;
43117
43118   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
43119   arg2 = (unsigned int)jarg2;
43120   argp3 = (Dali::Actor *)jarg3;
43121   if (!argp3) {
43122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
43123     return ;
43124   }
43125   arg3 = *argp3;
43126   {
43127     try {
43128       (arg1)->ItemReleased(arg2,arg3);
43129     } CALL_CATCH_EXCEPTION();
43130   }
43131
43132 }
43133
43134
43135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
43136   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
43137   unsigned int arg2 ;
43138   Dali::Actor arg3 ;
43139   Dali::Actor *argp3 ;
43140
43141   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
43142   arg2 = (unsigned int)jarg2;
43143   argp3 = (Dali::Actor *)jarg3;
43144   if (!argp3) {
43145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
43146     return ;
43147   }
43148   arg3 = *argp3;
43149   {
43150     try {
43151       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
43152     } CALL_CATCH_EXCEPTION();
43153   }
43154
43155 }
43156
43157
43158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
43159   void * jresult ;
43160   Dali::Toolkit::ItemFactory *result = 0 ;
43161
43162   {
43163     try {
43164       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
43165     } CALL_CATCH_EXCEPTION(0);
43166   }
43167
43168   jresult = (void *)result;
43169   return jresult;
43170 }
43171
43172
43173 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) {
43174   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
43175   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
43176   if (director) {
43177     director->swig_connect_director(callback0, callback1, callback2);
43178   }
43179 }
43180
43181
43182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
43183   int jresult ;
43184   int result;
43185
43186   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
43187   jresult = (int)result;
43188   return jresult;
43189 }
43190
43191
43192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
43193   int jresult ;
43194   int result;
43195
43196   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
43197   jresult = (int)result;
43198   return jresult;
43199 }
43200
43201
43202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
43203   int jresult ;
43204   int result;
43205
43206   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
43207   jresult = (int)result;
43208   return jresult;
43209 }
43210
43211
43212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
43213   int jresult ;
43214   int result;
43215
43216   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
43217   jresult = (int)result;
43218   return jresult;
43219 }
43220
43221
43222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
43223   int jresult ;
43224   int result;
43225
43226   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
43227   jresult = (int)result;
43228   return jresult;
43229 }
43230
43231
43232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
43233   int jresult ;
43234   int result;
43235
43236   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
43237   jresult = (int)result;
43238   return jresult;
43239 }
43240
43241
43242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
43243   int jresult ;
43244   int result;
43245
43246   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
43247   jresult = (int)result;
43248   return jresult;
43249 }
43250
43251
43252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
43253   int jresult ;
43254   int result;
43255
43256   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
43257   jresult = (int)result;
43258   return jresult;
43259 }
43260
43261
43262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
43263   int jresult ;
43264   int result;
43265
43266   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
43267   jresult = (int)result;
43268   return jresult;
43269 }
43270
43271
43272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
43273   int jresult ;
43274   int result;
43275
43276   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
43277   jresult = (int)result;
43278   return jresult;
43279 }
43280
43281
43282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
43283   int jresult ;
43284   int result;
43285
43286   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
43287   jresult = (int)result;
43288   return jresult;
43289 }
43290
43291
43292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
43293   void * jresult ;
43294   Dali::Toolkit::ItemView::Property *result = 0 ;
43295
43296   {
43297     try {
43298       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
43299     } CALL_CATCH_EXCEPTION(0);
43300   }
43301
43302   jresult = (void *)result;
43303   return jresult;
43304 }
43305
43306
43307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
43308   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
43309
43310   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
43311   {
43312     try {
43313       delete arg1;
43314     } CALL_CATCH_EXCEPTION();
43315   }
43316
43317 }
43318
43319
43320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
43321   void * jresult ;
43322   Dali::Toolkit::ItemView *result = 0 ;
43323
43324   {
43325     try {
43326       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
43327     } CALL_CATCH_EXCEPTION(0);
43328   }
43329
43330   jresult = (void *)result;
43331   return jresult;
43332 }
43333
43334
43335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
43336   void * jresult ;
43337   Dali::Toolkit::ItemView *arg1 = 0 ;
43338   Dali::Toolkit::ItemView *result = 0 ;
43339
43340   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43341   if (!arg1) {
43342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
43343     return 0;
43344   }
43345   {
43346     try {
43347       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
43348     } CALL_CATCH_EXCEPTION(0);
43349   }
43350
43351   jresult = (void *)result;
43352   return jresult;
43353 }
43354
43355
43356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
43357   void * jresult ;
43358   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43359   Dali::Toolkit::ItemView *arg2 = 0 ;
43360   Dali::Toolkit::ItemView *result = 0 ;
43361
43362   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43363   arg2 = (Dali::Toolkit::ItemView *)jarg2;
43364   if (!arg2) {
43365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
43366     return 0;
43367   }
43368   {
43369     try {
43370       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
43371     } CALL_CATCH_EXCEPTION(0);
43372   }
43373
43374   jresult = (void *)result;
43375   return jresult;
43376 }
43377
43378
43379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
43380   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43381
43382   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43383   {
43384     try {
43385       delete arg1;
43386     } CALL_CATCH_EXCEPTION();
43387   }
43388
43389 }
43390
43391
43392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
43393   void * jresult ;
43394   Dali::Toolkit::ItemFactory *arg1 = 0 ;
43395   Dali::Toolkit::ItemView result;
43396
43397   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
43398   if (!arg1) {
43399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
43400     return 0;
43401   }
43402   {
43403     try {
43404       result = Dali::Toolkit::ItemView::New(*arg1);
43405     } CALL_CATCH_EXCEPTION(0);
43406   }
43407
43408   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
43409   return jresult;
43410 }
43411
43412
43413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
43414   void * jresult ;
43415   Dali::BaseHandle arg1 ;
43416   Dali::BaseHandle *argp1 ;
43417   Dali::Toolkit::ItemView result;
43418
43419   argp1 = (Dali::BaseHandle *)jarg1;
43420   if (!argp1) {
43421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43422     return 0;
43423   }
43424   arg1 = *argp1;
43425   {
43426     try {
43427       result = Dali::Toolkit::ItemView::DownCast(arg1);
43428     } CALL_CATCH_EXCEPTION(0);
43429   }
43430
43431   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
43432   return jresult;
43433 }
43434
43435
43436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
43437   unsigned int jresult ;
43438   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43439   unsigned int result;
43440
43441   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43442   {
43443     try {
43444       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
43445     } CALL_CATCH_EXCEPTION(0);
43446   }
43447
43448   jresult = result;
43449   return jresult;
43450 }
43451
43452
43453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
43454   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43455   Dali::Toolkit::ItemLayout *arg2 = 0 ;
43456
43457   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43458   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
43459   if (!arg2) {
43460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
43461     return ;
43462   }
43463   {
43464     try {
43465       (arg1)->AddLayout(*arg2);
43466     } CALL_CATCH_EXCEPTION();
43467   }
43468
43469 }
43470
43471
43472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
43473   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43474   unsigned int arg2 ;
43475
43476   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43477   arg2 = (unsigned int)jarg2;
43478   {
43479     try {
43480       (arg1)->RemoveLayout(arg2);
43481     } CALL_CATCH_EXCEPTION();
43482   }
43483
43484 }
43485
43486
43487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
43488   void * jresult ;
43489   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43490   unsigned int arg2 ;
43491   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
43492
43493   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43494   arg2 = (unsigned int)jarg2;
43495   {
43496     try {
43497       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
43498     } CALL_CATCH_EXCEPTION(0);
43499   }
43500
43501   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
43502   return jresult;
43503 }
43504
43505
43506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
43507   void * jresult ;
43508   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43509   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
43510
43511   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43512   {
43513     try {
43514       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
43515     } CALL_CATCH_EXCEPTION(0);
43516   }
43517
43518   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
43519   return jresult;
43520 }
43521
43522
43523 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
43524   float jresult ;
43525   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43526   Dali::Toolkit::ItemId arg2 ;
43527   float result;
43528
43529   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43530   arg2 = (Dali::Toolkit::ItemId)jarg2;
43531   {
43532     try {
43533       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
43534     } CALL_CATCH_EXCEPTION(0);
43535   }
43536
43537   jresult = result;
43538   return jresult;
43539 }
43540
43541
43542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
43543   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43544   unsigned int arg2 ;
43545   Dali::Vector3 arg3 ;
43546   float arg4 ;
43547   Dali::Vector3 *argp3 ;
43548
43549   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43550   arg2 = (unsigned int)jarg2;
43551   argp3 = (Dali::Vector3 *)jarg3;
43552   if (!argp3) {
43553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
43554     return ;
43555   }
43556   arg3 = *argp3;
43557   arg4 = (float)jarg4;
43558   {
43559     try {
43560       (arg1)->ActivateLayout(arg2,arg3,arg4);
43561     } CALL_CATCH_EXCEPTION();
43562   }
43563
43564 }
43565
43566
43567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
43568   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43569
43570   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43571   {
43572     try {
43573       (arg1)->DeactivateCurrentLayout();
43574     } CALL_CATCH_EXCEPTION();
43575   }
43576
43577 }
43578
43579
43580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
43581   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43582   float arg2 ;
43583
43584   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43585   arg2 = (float)jarg2;
43586   {
43587     try {
43588       (arg1)->SetMinimumSwipeSpeed(arg2);
43589     } CALL_CATCH_EXCEPTION();
43590   }
43591
43592 }
43593
43594
43595 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
43596   float jresult ;
43597   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43598   float result;
43599
43600   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43601   {
43602     try {
43603       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
43604     } CALL_CATCH_EXCEPTION(0);
43605   }
43606
43607   jresult = result;
43608   return jresult;
43609 }
43610
43611
43612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
43613   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43614   float arg2 ;
43615
43616   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43617   arg2 = (float)jarg2;
43618   {
43619     try {
43620       (arg1)->SetMinimumSwipeDistance(arg2);
43621     } CALL_CATCH_EXCEPTION();
43622   }
43623
43624 }
43625
43626
43627 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
43628   float jresult ;
43629   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43630   float result;
43631
43632   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43633   {
43634     try {
43635       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
43636     } CALL_CATCH_EXCEPTION(0);
43637   }
43638
43639   jresult = result;
43640   return jresult;
43641 }
43642
43643
43644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
43645   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43646   float arg2 ;
43647
43648   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43649   arg2 = (float)jarg2;
43650   {
43651     try {
43652       (arg1)->SetWheelScrollDistanceStep(arg2);
43653     } CALL_CATCH_EXCEPTION();
43654   }
43655
43656 }
43657
43658
43659 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
43660   float jresult ;
43661   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43662   float result;
43663
43664   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43665   {
43666     try {
43667       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
43668     } CALL_CATCH_EXCEPTION(0);
43669   }
43670
43671   jresult = result;
43672   return jresult;
43673 }
43674
43675
43676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, bool jarg2) {
43677   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43678   bool arg2 ;
43679
43680   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43681   arg2 = jarg2 ? true : false;
43682   {
43683     try {
43684       (arg1)->SetAnchoring(arg2);
43685     } CALL_CATCH_EXCEPTION();
43686   }
43687
43688 }
43689
43690 //// ========================= end of part 3 =============================
43691
43692 //// ========================== start part 4 ===============================
43693
43694
43695 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
43696   bool jresult ;
43697   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43698   bool result;
43699
43700   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43701   {
43702     try {
43703       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
43704     } CALL_CATCH_EXCEPTION(0);
43705   }
43706
43707   jresult = result;
43708   return jresult;
43709 }
43710
43711
43712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
43713   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43714   float arg2 ;
43715
43716   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43717   arg2 = (float)jarg2;
43718   {
43719     try {
43720       (arg1)->SetAnchoringDuration(arg2);
43721     } CALL_CATCH_EXCEPTION();
43722   }
43723
43724 }
43725
43726
43727 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
43728   float jresult ;
43729   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43730   float result;
43731
43732   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43733   {
43734     try {
43735       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
43736     } CALL_CATCH_EXCEPTION(0);
43737   }
43738
43739   jresult = result;
43740   return jresult;
43741 }
43742
43743
43744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
43745   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43746   Dali::Toolkit::ItemId arg2 ;
43747   float arg3 ;
43748
43749   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43750   arg2 = (Dali::Toolkit::ItemId)jarg2;
43751   arg3 = (float)jarg3;
43752   {
43753     try {
43754       (arg1)->ScrollToItem(arg2,arg3);
43755     } CALL_CATCH_EXCEPTION();
43756   }
43757
43758 }
43759
43760
43761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
43762   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43763   float arg2 ;
43764
43765   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43766   arg2 = (float)jarg2;
43767   {
43768     try {
43769       (arg1)->SetRefreshInterval(arg2);
43770     } CALL_CATCH_EXCEPTION();
43771   }
43772
43773 }
43774
43775
43776 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
43777   float jresult ;
43778   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43779   float result;
43780
43781   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43782   {
43783     try {
43784       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
43785     } CALL_CATCH_EXCEPTION(0);
43786   }
43787
43788   jresult = result;
43789   return jresult;
43790 }
43791
43792
43793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
43794   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43795
43796   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43797   {
43798     try {
43799       (arg1)->Refresh();
43800     } CALL_CATCH_EXCEPTION();
43801   }
43802
43803 }
43804
43805
43806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
43807   void * jresult ;
43808   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43809   Dali::Toolkit::ItemId arg2 ;
43810   Dali::Actor result;
43811
43812   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43813   arg2 = (Dali::Toolkit::ItemId)jarg2;
43814   {
43815     try {
43816       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
43817     } CALL_CATCH_EXCEPTION(0);
43818   }
43819
43820   jresult = new Dali::Actor((const Dali::Actor &)result);
43821   return jresult;
43822 }
43823
43824
43825 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
43826   unsigned int jresult ;
43827   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43828   Dali::Actor arg2 ;
43829   Dali::Actor *argp2 ;
43830   Dali::Toolkit::ItemId result;
43831
43832   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43833   argp2 = (Dali::Actor *)jarg2;
43834   if (!argp2) {
43835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
43836     return 0;
43837   }
43838   arg2 = *argp2;
43839   {
43840     try {
43841       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
43842     } CALL_CATCH_EXCEPTION(0);
43843   }
43844
43845   jresult = result;
43846   return jresult;
43847 }
43848
43849
43850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
43851   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43852   Dali::Toolkit::Item arg2 ;
43853   float arg3 ;
43854   Dali::Toolkit::Item *argp2 ;
43855
43856   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43857   argp2 = (Dali::Toolkit::Item *)jarg2;
43858   if (!argp2) {
43859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
43860     return ;
43861   }
43862   arg2 = *argp2;
43863   arg3 = (float)jarg3;
43864   {
43865     try {
43866       (arg1)->InsertItem(arg2,arg3);
43867     } CALL_CATCH_EXCEPTION();
43868   }
43869
43870 }
43871
43872
43873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
43874   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43875   Dali::Toolkit::ItemContainer *arg2 = 0 ;
43876   float arg3 ;
43877
43878   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43879   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
43880   if (!arg2) {
43881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
43882     return ;
43883   }
43884   arg3 = (float)jarg3;
43885   {
43886     try {
43887       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
43888     } CALL_CATCH_EXCEPTION();
43889   }
43890
43891 }
43892
43893
43894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
43895   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43896   Dali::Toolkit::ItemId arg2 ;
43897   float arg3 ;
43898
43899   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43900   arg2 = (Dali::Toolkit::ItemId)jarg2;
43901   arg3 = (float)jarg3;
43902   {
43903     try {
43904       (arg1)->RemoveItem(arg2,arg3);
43905     } CALL_CATCH_EXCEPTION();
43906   }
43907
43908 }
43909
43910
43911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
43912   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43913   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
43914   float arg3 ;
43915
43916   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43917   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
43918   if (!arg2) {
43919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
43920     return ;
43921   }
43922   arg3 = (float)jarg3;
43923   {
43924     try {
43925       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
43926     } CALL_CATCH_EXCEPTION();
43927   }
43928
43929 }
43930
43931
43932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
43933   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43934   Dali::Toolkit::Item arg2 ;
43935   float arg3 ;
43936   Dali::Toolkit::Item *argp2 ;
43937
43938   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43939   argp2 = (Dali::Toolkit::Item *)jarg2;
43940   if (!argp2) {
43941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
43942     return ;
43943   }
43944   arg2 = *argp2;
43945   arg3 = (float)jarg3;
43946   {
43947     try {
43948       (arg1)->ReplaceItem(arg2,arg3);
43949     } CALL_CATCH_EXCEPTION();
43950   }
43951
43952 }
43953
43954
43955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
43956   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43957   Dali::Toolkit::ItemContainer *arg2 = 0 ;
43958   float arg3 ;
43959
43960   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43961   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
43962   if (!arg2) {
43963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
43964     return ;
43965   }
43966   arg3 = (float)jarg3;
43967   {
43968     try {
43969       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
43970     } CALL_CATCH_EXCEPTION();
43971   }
43972
43973 }
43974
43975
43976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
43977   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43978   Dali::Vector3 *arg2 = 0 ;
43979
43980   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43981   arg2 = (Dali::Vector3 *)jarg2;
43982   if (!arg2) {
43983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43984     return ;
43985   }
43986   {
43987     try {
43988       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
43989     } CALL_CATCH_EXCEPTION();
43990   }
43991
43992 }
43993
43994
43995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
43996   void * jresult ;
43997   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43998   Dali::Vector3 result;
43999
44000   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44001   {
44002     try {
44003       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
44004     } CALL_CATCH_EXCEPTION(0);
44005   }
44006
44007   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
44008   return jresult;
44009 }
44010
44011
44012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
44013   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44014   Dali::Vector3 *arg2 = 0 ;
44015
44016   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44017   arg2 = (Dali::Vector3 *)jarg2;
44018   if (!arg2) {
44019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44020     return ;
44021   }
44022   {
44023     try {
44024       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
44025     } CALL_CATCH_EXCEPTION();
44026   }
44027
44028 }
44029
44030
44031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
44032   void * jresult ;
44033   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44034   Dali::Vector3 result;
44035
44036   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44037   {
44038     try {
44039       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
44040     } CALL_CATCH_EXCEPTION(0);
44041   }
44042
44043   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
44044   return jresult;
44045 }
44046
44047
44048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
44049   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44050   Dali::Toolkit::ItemRange *arg2 = 0 ;
44051
44052   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44053   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
44054   if (!arg2) {
44055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
44056     return ;
44057   }
44058   {
44059     try {
44060       (arg1)->GetItemsRange(*arg2);
44061     } CALL_CATCH_EXCEPTION();
44062   }
44063
44064 }
44065
44066
44067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
44068   void * jresult ;
44069   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44070   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
44071
44072   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44073   {
44074     try {
44075       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
44076     } CALL_CATCH_EXCEPTION(0);
44077   }
44078
44079   jresult = (void *)result;
44080   return jresult;
44081 }
44082
44083
44084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
44085   Dali::Vector3 *arg1 = 0 ;
44086   PropertyInputContainer *arg2 = 0 ;
44087
44088   arg1 = (Dali::Vector3 *)jarg1;
44089   if (!arg1) {
44090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
44091     return ;
44092   }
44093   arg2 = (PropertyInputContainer *)jarg2;
44094   if (!arg2) {
44095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
44096     return ;
44097   }
44098   {
44099     try {
44100       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
44101     } CALL_CATCH_EXCEPTION();
44102   }
44103
44104 }
44105
44106
44107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
44108   Dali::Vector3 *arg1 = 0 ;
44109   PropertyInputContainer *arg2 = 0 ;
44110
44111   arg1 = (Dali::Vector3 *)jarg1;
44112   if (!arg1) {
44113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
44114     return ;
44115   }
44116   arg2 = (PropertyInputContainer *)jarg2;
44117   if (!arg2) {
44118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
44119     return ;
44120   }
44121   {
44122     try {
44123       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
44124     } CALL_CATCH_EXCEPTION();
44125   }
44126
44127 }
44128
44129
44130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
44131   void * jresult ;
44132   Dali::Toolkit::ScrollViewEffect *result = 0 ;
44133
44134   {
44135     try {
44136       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
44137     } CALL_CATCH_EXCEPTION(0);
44138   }
44139
44140   jresult = (void *)result;
44141   return jresult;
44142 }
44143
44144
44145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
44146   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
44147
44148   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
44149   {
44150     try {
44151       delete arg1;
44152     } CALL_CATCH_EXCEPTION();
44153   }
44154
44155 }
44156
44157
44158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
44159   void * jresult ;
44160   Dali::Path arg1 ;
44161   Dali::Vector3 *arg2 = 0 ;
44162   Dali::Property::Index arg3 ;
44163   Dali::Vector3 *arg4 = 0 ;
44164   unsigned int arg5 ;
44165   Dali::Path *argp1 ;
44166   Dali::Toolkit::ScrollViewPagePathEffect result;
44167
44168   argp1 = (Dali::Path *)jarg1;
44169   if (!argp1) {
44170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
44171     return 0;
44172   }
44173   arg1 = *argp1;
44174   arg2 = (Dali::Vector3 *)jarg2;
44175   if (!arg2) {
44176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44177     return 0;
44178   }
44179   arg3 = (Dali::Property::Index)jarg3;
44180   arg4 = (Dali::Vector3 *)jarg4;
44181   if (!arg4) {
44182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44183     return 0;
44184   }
44185   arg5 = (unsigned int)jarg5;
44186   {
44187     try {
44188       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
44189     } CALL_CATCH_EXCEPTION(0);
44190   }
44191
44192   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
44193   return jresult;
44194 }
44195
44196
44197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
44198   void * jresult ;
44199   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
44200
44201   {
44202     try {
44203       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
44204     } CALL_CATCH_EXCEPTION(0);
44205   }
44206
44207   jresult = (void *)result;
44208   return jresult;
44209 }
44210
44211
44212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
44213   void * jresult ;
44214   Dali::BaseHandle arg1 ;
44215   Dali::BaseHandle *argp1 ;
44216   Dali::Toolkit::ScrollViewPagePathEffect result;
44217
44218   argp1 = (Dali::BaseHandle *)jarg1;
44219   if (!argp1) {
44220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44221     return 0;
44222   }
44223   arg1 = *argp1;
44224   {
44225     try {
44226       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
44227     } CALL_CATCH_EXCEPTION(0);
44228   }
44229
44230   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
44231   return jresult;
44232 }
44233
44234
44235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
44236   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
44237   Dali::Actor arg2 ;
44238   unsigned int arg3 ;
44239   Dali::Actor *argp2 ;
44240
44241   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
44242   argp2 = (Dali::Actor *)jarg2;
44243   if (!argp2) {
44244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
44245     return ;
44246   }
44247   arg2 = *argp2;
44248   arg3 = (unsigned int)jarg3;
44249   {
44250     try {
44251       (arg1)->ApplyToPage(arg2,arg3);
44252     } CALL_CATCH_EXCEPTION();
44253   }
44254
44255 }
44256
44257
44258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
44259   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
44260
44261   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
44262   {
44263     try {
44264       delete arg1;
44265     } CALL_CATCH_EXCEPTION();
44266   }
44267
44268 }
44269
44270
44271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
44272   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
44273   Dali::Toolkit::ClampState arg2 ;
44274
44275   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
44276   arg2 = (Dali::Toolkit::ClampState)jarg2;
44277   if (arg1) (arg1)->x = arg2;
44278 }
44279
44280
44281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
44282   int jresult ;
44283   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
44284   Dali::Toolkit::ClampState result;
44285
44286   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
44287   result = (Dali::Toolkit::ClampState) ((arg1)->x);
44288   jresult = (int)result;
44289   return jresult;
44290 }
44291
44292
44293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
44294   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
44295   Dali::Toolkit::ClampState arg2 ;
44296
44297   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
44298   arg2 = (Dali::Toolkit::ClampState)jarg2;
44299   if (arg1) (arg1)->y = arg2;
44300 }
44301
44302
44303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
44304   int jresult ;
44305   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
44306   Dali::Toolkit::ClampState result;
44307
44308   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
44309   result = (Dali::Toolkit::ClampState) ((arg1)->y);
44310   jresult = (int)result;
44311   return jresult;
44312 }
44313
44314
44315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
44316   void * jresult ;
44317   Dali::Toolkit::ClampState2D *result = 0 ;
44318
44319   {
44320     try {
44321       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
44322     } CALL_CATCH_EXCEPTION(0);
44323   }
44324
44325   jresult = (void *)result;
44326   return jresult;
44327 }
44328
44329
44330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
44331   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
44332
44333   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
44334   {
44335     try {
44336       delete arg1;
44337     } CALL_CATCH_EXCEPTION();
44338   }
44339
44340 }
44341
44342
44343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, bool jarg3) {
44344   void * jresult ;
44345   float arg1 ;
44346   float arg2 ;
44347   bool arg3 ;
44348   Dali::Toolkit::RulerDomain *result = 0 ;
44349
44350   arg1 = (float)jarg1;
44351   arg2 = (float)jarg2;
44352   arg3 = jarg3 ? true : false;
44353   {
44354     try {
44355       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
44356     } CALL_CATCH_EXCEPTION(0);
44357   }
44358
44359   jresult = (void *)result;
44360   return jresult;
44361 }
44362
44363
44364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
44365   void * jresult ;
44366   float arg1 ;
44367   float arg2 ;
44368   Dali::Toolkit::RulerDomain *result = 0 ;
44369
44370   arg1 = (float)jarg1;
44371   arg2 = (float)jarg2;
44372   {
44373     try {
44374       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
44375     } CALL_CATCH_EXCEPTION(0);
44376   }
44377
44378   jresult = (void *)result;
44379   return jresult;
44380 }
44381
44382
44383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
44384   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
44385   float arg2 ;
44386
44387   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
44388   arg2 = (float)jarg2;
44389   if (arg1) (arg1)->min = arg2;
44390 }
44391
44392
44393 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
44394   float jresult ;
44395   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
44396   float result;
44397
44398   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
44399   result = (float) ((arg1)->min);
44400   jresult = result;
44401   return jresult;
44402 }
44403
44404
44405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
44406   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
44407   float arg2 ;
44408
44409   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
44410   arg2 = (float)jarg2;
44411   if (arg1) (arg1)->max = arg2;
44412 }
44413
44414
44415 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
44416   float jresult ;
44417   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
44418   float result;
44419
44420   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
44421   result = (float) ((arg1)->max);
44422   jresult = result;
44423   return jresult;
44424 }
44425
44426
44427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, bool jarg2) {
44428   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
44429   bool arg2 ;
44430
44431   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
44432   arg2 = jarg2 ? true : false;
44433   if (arg1) (arg1)->enabled = arg2;
44434 }
44435
44436
44437 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
44438   bool jresult ;
44439   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
44440   bool result;
44441
44442   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
44443   result = (bool) ((arg1)->enabled);
44444   jresult = result;
44445   return jresult;
44446 }
44447
44448
44449 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
44450   float jresult ;
44451   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
44452   float arg2 ;
44453   float arg3 ;
44454   float arg4 ;
44455   float result;
44456
44457   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
44458   arg2 = (float)jarg2;
44459   arg3 = (float)jarg3;
44460   arg4 = (float)jarg4;
44461   {
44462     try {
44463       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
44464     } CALL_CATCH_EXCEPTION(0);
44465   }
44466
44467   jresult = result;
44468   return jresult;
44469 }
44470
44471
44472 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
44473   float jresult ;
44474   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
44475   float arg2 ;
44476   float arg3 ;
44477   float result;
44478
44479   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
44480   arg2 = (float)jarg2;
44481   arg3 = (float)jarg3;
44482   {
44483     try {
44484       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
44485     } CALL_CATCH_EXCEPTION(0);
44486   }
44487
44488   jresult = result;
44489   return jresult;
44490 }
44491
44492
44493 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
44494   float jresult ;
44495   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
44496   float arg2 ;
44497   float result;
44498
44499   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
44500   arg2 = (float)jarg2;
44501   {
44502     try {
44503       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
44504     } CALL_CATCH_EXCEPTION(0);
44505   }
44506
44507   jresult = result;
44508   return jresult;
44509 }
44510
44511
44512 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
44513   float jresult ;
44514   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
44515   float arg2 ;
44516   float arg3 ;
44517   float arg4 ;
44518   Dali::Toolkit::ClampState *arg5 = 0 ;
44519   float result;
44520
44521   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
44522   arg2 = (float)jarg2;
44523   arg3 = (float)jarg3;
44524   arg4 = (float)jarg4;
44525   arg5 = (Dali::Toolkit::ClampState *)jarg5;
44526   if (!arg5) {
44527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
44528     return 0;
44529   }
44530   {
44531     try {
44532       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
44533     } CALL_CATCH_EXCEPTION(0);
44534   }
44535
44536   jresult = result;
44537   return jresult;
44538 }
44539
44540
44541 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
44542   float jresult ;
44543   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
44544   float result;
44545
44546   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
44547   {
44548     try {
44549       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
44550     } CALL_CATCH_EXCEPTION(0);
44551   }
44552
44553   jresult = result;
44554   return jresult;
44555 }
44556
44557
44558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
44559   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
44560
44561   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
44562   {
44563     try {
44564       delete arg1;
44565     } CALL_CATCH_EXCEPTION();
44566   }
44567
44568 }
44569
44570
44571 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
44572   float jresult ;
44573   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44574   float arg2 ;
44575   float arg3 ;
44576   float result;
44577
44578   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44579   arg2 = (float)jarg2;
44580   arg3 = (float)jarg3;
44581   {
44582     try {
44583       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
44584     } CALL_CATCH_EXCEPTION(0);
44585   }
44586
44587   jresult = result;
44588   return jresult;
44589 }
44590
44591
44592 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
44593   float jresult ;
44594   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44595   float arg2 ;
44596   float result;
44597
44598   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44599   arg2 = (float)jarg2;
44600   {
44601     try {
44602       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
44603     } CALL_CATCH_EXCEPTION(0);
44604   }
44605
44606   jresult = result;
44607   return jresult;
44608 }
44609
44610
44611 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) {
44612   float jresult ;
44613   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44614   unsigned int arg2 ;
44615   unsigned int *arg3 = 0 ;
44616   bool arg4 ;
44617   float result;
44618
44619   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44620   arg2 = (unsigned int)jarg2;
44621   arg3 = (unsigned int *)jarg3;
44622   arg4 = jarg4 ? true : false;
44623   {
44624     try {
44625       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
44626     } CALL_CATCH_EXCEPTION(0);
44627   }
44628
44629   jresult = result;
44630   return jresult;
44631 }
44632
44633
44634 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) {
44635   unsigned int jresult ;
44636   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44637   float arg2 ;
44638   bool arg3 ;
44639   unsigned int result;
44640
44641   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44642   arg2 = (float)jarg2;
44643   arg3 = jarg3 ? true : false;
44644   {
44645     try {
44646       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
44647     } CALL_CATCH_EXCEPTION(0);
44648   }
44649
44650   jresult = result;
44651   return jresult;
44652 }
44653
44654
44655 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
44656   unsigned int jresult ;
44657   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44658   unsigned int result;
44659
44660   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44661   {
44662     try {
44663       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
44664     } CALL_CATCH_EXCEPTION(0);
44665   }
44666
44667   jresult = result;
44668   return jresult;
44669 }
44670
44671
44672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
44673   int jresult ;
44674   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44675   Dali::Toolkit::Ruler::RulerType result;
44676
44677   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44678   {
44679     try {
44680       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
44681     } CALL_CATCH_EXCEPTION(0);
44682   }
44683
44684   jresult = (int)result;
44685   return jresult;
44686 }
44687
44688
44689 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
44690   bool jresult ;
44691   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44692   bool result;
44693
44694   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44695   {
44696     try {
44697       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
44698     } CALL_CATCH_EXCEPTION(0);
44699   }
44700
44701   jresult = result;
44702   return jresult;
44703 }
44704
44705
44706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
44707   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44708
44709   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44710   {
44711     try {
44712       (arg1)->Enable();
44713     } CALL_CATCH_EXCEPTION();
44714   }
44715
44716 }
44717
44718
44719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
44720   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44721
44722   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44723   {
44724     try {
44725       (arg1)->Disable();
44726     } CALL_CATCH_EXCEPTION();
44727   }
44728
44729 }
44730
44731
44732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
44733   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44734   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
44735   Dali::Toolkit::RulerDomain *argp2 ;
44736
44737   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44738   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
44739   if (!argp2) {
44740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
44741     return ;
44742   }
44743   arg2 = *argp2;
44744   {
44745     try {
44746       (arg1)->SetDomain(arg2);
44747     } CALL_CATCH_EXCEPTION();
44748   }
44749
44750 }
44751
44752
44753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
44754   void * jresult ;
44755   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44756   Dali::Toolkit::RulerDomain *result = 0 ;
44757
44758   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44759   {
44760     try {
44761       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
44762     } CALL_CATCH_EXCEPTION(0);
44763   }
44764
44765   jresult = (void *)result;
44766   return jresult;
44767 }
44768
44769
44770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
44771   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44772
44773   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44774   {
44775     try {
44776       (arg1)->DisableDomain();
44777     } CALL_CATCH_EXCEPTION();
44778   }
44779
44780 }
44781
44782
44783 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
44784   float jresult ;
44785   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44786   float arg2 ;
44787   float arg3 ;
44788   float arg4 ;
44789   float result;
44790
44791   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44792   arg2 = (float)jarg2;
44793   arg3 = (float)jarg3;
44794   arg4 = (float)jarg4;
44795   {
44796     try {
44797       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
44798     } CALL_CATCH_EXCEPTION(0);
44799   }
44800
44801   jresult = result;
44802   return jresult;
44803 }
44804
44805
44806 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
44807   float jresult ;
44808   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44809   float arg2 ;
44810   float arg3 ;
44811   float result;
44812
44813   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44814   arg2 = (float)jarg2;
44815   arg3 = (float)jarg3;
44816   {
44817     try {
44818       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
44819     } CALL_CATCH_EXCEPTION(0);
44820   }
44821
44822   jresult = result;
44823   return jresult;
44824 }
44825
44826
44827 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
44828   float jresult ;
44829   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44830   float arg2 ;
44831   float result;
44832
44833   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44834   arg2 = (float)jarg2;
44835   {
44836     try {
44837       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
44838     } CALL_CATCH_EXCEPTION(0);
44839   }
44840
44841   jresult = result;
44842   return jresult;
44843 }
44844
44845
44846 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
44847   float jresult ;
44848   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44849   float arg2 ;
44850   float arg3 ;
44851   float arg4 ;
44852   Dali::Toolkit::ClampState *arg5 = 0 ;
44853   float result;
44854
44855   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44856   arg2 = (float)jarg2;
44857   arg3 = (float)jarg3;
44858   arg4 = (float)jarg4;
44859   arg5 = (Dali::Toolkit::ClampState *)jarg5;
44860   if (!arg5) {
44861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
44862     return 0;
44863   }
44864   {
44865     try {
44866       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
44867     } CALL_CATCH_EXCEPTION(0);
44868   }
44869
44870   jresult = result;
44871   return jresult;
44872 }
44873
44874
44875 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
44876   float jresult ;
44877   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44878   float arg2 ;
44879   float arg3 ;
44880   float arg4 ;
44881   float arg5 ;
44882   float result;
44883
44884   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44885   arg2 = (float)jarg2;
44886   arg3 = (float)jarg3;
44887   arg4 = (float)jarg4;
44888   arg5 = (float)jarg5;
44889   {
44890     try {
44891       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
44892     } CALL_CATCH_EXCEPTION(0);
44893   }
44894
44895   jresult = result;
44896   return jresult;
44897 }
44898
44899
44900 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
44901   float jresult ;
44902   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44903   float arg2 ;
44904   float arg3 ;
44905   float arg4 ;
44906   float result;
44907
44908   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44909   arg2 = (float)jarg2;
44910   arg3 = (float)jarg3;
44911   arg4 = (float)jarg4;
44912   {
44913     try {
44914       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
44915     } CALL_CATCH_EXCEPTION(0);
44916   }
44917
44918   jresult = result;
44919   return jresult;
44920 }
44921
44922
44923 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
44924   float jresult ;
44925   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44926   float arg2 ;
44927   float arg3 ;
44928   float result;
44929
44930   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44931   arg2 = (float)jarg2;
44932   arg3 = (float)jarg3;
44933   {
44934     try {
44935       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
44936     } CALL_CATCH_EXCEPTION(0);
44937   }
44938
44939   jresult = result;
44940   return jresult;
44941 }
44942
44943
44944 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
44945   float jresult ;
44946   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44947   float arg2 ;
44948   float result;
44949
44950   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44951   arg2 = (float)jarg2;
44952   {
44953     try {
44954       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
44955     } CALL_CATCH_EXCEPTION(0);
44956   }
44957
44958   jresult = result;
44959   return jresult;
44960 }
44961
44962
44963 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
44964   float jresult ;
44965   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44966   float arg2 ;
44967   float arg3 ;
44968   float arg4 ;
44969   float arg5 ;
44970   Dali::Toolkit::ClampState *arg6 = 0 ;
44971   float result;
44972
44973   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44974   arg2 = (float)jarg2;
44975   arg3 = (float)jarg3;
44976   arg4 = (float)jarg4;
44977   arg5 = (float)jarg5;
44978   arg6 = (Dali::Toolkit::ClampState *)jarg6;
44979   if (!arg6) {
44980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
44981     return 0;
44982   }
44983   {
44984     try {
44985       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
44986     } CALL_CATCH_EXCEPTION(0);
44987   }
44988
44989   jresult = result;
44990   return jresult;
44991 }
44992
44993
44994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
44995   void * jresult ;
44996   Dali::Toolkit::DefaultRuler *result = 0 ;
44997
44998   {
44999     try {
45000       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
45001     } CALL_CATCH_EXCEPTION(0);
45002   }
45003
45004   jresult = (void *)result;
45005   return jresult;
45006 }
45007
45008
45009 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
45010   float jresult ;
45011   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
45012   float arg2 ;
45013   float arg3 ;
45014   float result;
45015
45016   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
45017   arg2 = (float)jarg2;
45018   arg3 = (float)jarg3;
45019   {
45020     try {
45021       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
45022     } CALL_CATCH_EXCEPTION(0);
45023   }
45024
45025   jresult = result;
45026   return jresult;
45027 }
45028
45029
45030 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) {
45031   float jresult ;
45032   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
45033   unsigned int arg2 ;
45034   unsigned int *arg3 = 0 ;
45035   bool arg4 ;
45036   float result;
45037
45038   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
45039   arg2 = (unsigned int)jarg2;
45040   arg3 = (unsigned int *)jarg3;
45041   arg4 = jarg4 ? true : false;
45042   {
45043     try {
45044       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
45045     } CALL_CATCH_EXCEPTION(0);
45046   }
45047
45048   jresult = result;
45049   return jresult;
45050 }
45051
45052
45053 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) {
45054   unsigned int jresult ;
45055   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
45056   float arg2 ;
45057   bool arg3 ;
45058   unsigned int result;
45059
45060   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
45061   arg2 = (float)jarg2;
45062   arg3 = jarg3 ? true : false;
45063   {
45064     try {
45065       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
45066     } CALL_CATCH_EXCEPTION(0);
45067   }
45068
45069   jresult = result;
45070   return jresult;
45071 }
45072
45073
45074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
45075   unsigned int jresult ;
45076   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
45077   unsigned int result;
45078
45079   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
45080   {
45081     try {
45082       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
45083     } CALL_CATCH_EXCEPTION(0);
45084   }
45085
45086   jresult = result;
45087   return jresult;
45088 }
45089
45090
45091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
45092   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
45093
45094   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
45095   {
45096     try {
45097       delete arg1;
45098     } CALL_CATCH_EXCEPTION();
45099   }
45100
45101 }
45102
45103
45104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
45105   void * jresult ;
45106   float arg1 ;
45107   Dali::Toolkit::FixedRuler *result = 0 ;
45108
45109   arg1 = (float)jarg1;
45110   {
45111     try {
45112       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
45113     } CALL_CATCH_EXCEPTION(0);
45114   }
45115
45116   jresult = (void *)result;
45117   return jresult;
45118 }
45119
45120
45121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
45122   void * jresult ;
45123   Dali::Toolkit::FixedRuler *result = 0 ;
45124
45125   {
45126     try {
45127       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
45128     } CALL_CATCH_EXCEPTION(0);
45129   }
45130
45131   jresult = (void *)result;
45132   return jresult;
45133 }
45134
45135
45136 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
45137   float jresult ;
45138   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
45139   float arg2 ;
45140   float arg3 ;
45141   float result;
45142
45143   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
45144   arg2 = (float)jarg2;
45145   arg3 = (float)jarg3;
45146   {
45147     try {
45148       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
45149     } CALL_CATCH_EXCEPTION(0);
45150   }
45151
45152   jresult = result;
45153   return jresult;
45154 }
45155
45156
45157 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) {
45158   float jresult ;
45159   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
45160   unsigned int arg2 ;
45161   unsigned int *arg3 = 0 ;
45162   bool arg4 ;
45163   float result;
45164
45165   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
45166   arg2 = (unsigned int)jarg2;
45167   arg3 = (unsigned int *)jarg3;
45168   arg4 = jarg4 ? true : false;
45169   {
45170     try {
45171       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
45172     } CALL_CATCH_EXCEPTION(0);
45173   }
45174
45175   jresult = result;
45176   return jresult;
45177 }
45178
45179
45180 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) {
45181   unsigned int jresult ;
45182   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
45183   float arg2 ;
45184   bool arg3 ;
45185   unsigned int result;
45186
45187   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
45188   arg2 = (float)jarg2;
45189   arg3 = jarg3 ? true : false;
45190   {
45191     try {
45192       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
45193     } CALL_CATCH_EXCEPTION(0);
45194   }
45195
45196   jresult = result;
45197   return jresult;
45198 }
45199
45200
45201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
45202   unsigned int jresult ;
45203   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
45204   unsigned int result;
45205
45206   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
45207   {
45208     try {
45209       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
45210     } CALL_CATCH_EXCEPTION(0);
45211   }
45212
45213   jresult = result;
45214   return jresult;
45215 }
45216
45217
45218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
45219   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
45220
45221   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
45222   {
45223     try {
45224       delete arg1;
45225     } CALL_CATCH_EXCEPTION();
45226   }
45227
45228 }
45229
45230
45231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
45232   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
45233   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
45234
45235   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
45236   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
45237   if (arg1) (arg1)->scale = *arg2;
45238 }
45239
45240
45241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
45242   void * jresult ;
45243   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
45244   Dali::Toolkit::ClampState2D *result = 0 ;
45245
45246   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
45247   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
45248   jresult = (void *)result;
45249   return jresult;
45250 }
45251
45252
45253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
45254   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
45255   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
45256
45257   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
45258   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
45259   if (arg1) (arg1)->position = *arg2;
45260 }
45261
45262
45263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
45264   void * jresult ;
45265   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
45266   Dali::Toolkit::ClampState2D *result = 0 ;
45267
45268   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
45269   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
45270   jresult = (void *)result;
45271   return jresult;
45272 }
45273
45274
45275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
45276   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
45277   Dali::Toolkit::ClampState arg2 ;
45278
45279   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
45280   arg2 = (Dali::Toolkit::ClampState)jarg2;
45281   if (arg1) (arg1)->rotation = arg2;
45282 }
45283
45284
45285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
45286   int jresult ;
45287   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
45288   Dali::Toolkit::ClampState result;
45289
45290   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
45291   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
45292   jresult = (int)result;
45293   return jresult;
45294 }
45295
45296
45297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
45298   void * jresult ;
45299   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
45300
45301   {
45302     try {
45303       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
45304     } CALL_CATCH_EXCEPTION(0);
45305   }
45306
45307   jresult = (void *)result;
45308   return jresult;
45309 }
45310
45311
45312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
45313   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
45314
45315   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
45316   {
45317     try {
45318       delete arg1;
45319     } CALL_CATCH_EXCEPTION();
45320   }
45321
45322 }
45323
45324
45325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
45326   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
45327   Dali::Toolkit::SnapType arg2 ;
45328
45329   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
45330   arg2 = (Dali::Toolkit::SnapType)jarg2;
45331   if (arg1) (arg1)->type = arg2;
45332 }
45333
45334
45335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
45336   int jresult ;
45337   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
45338   Dali::Toolkit::SnapType result;
45339
45340   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
45341   result = (Dali::Toolkit::SnapType) ((arg1)->type);
45342   jresult = (int)result;
45343   return jresult;
45344 }
45345
45346
45347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
45348   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
45349   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
45350
45351   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
45352   arg2 = (Dali::Vector2 *)jarg2;
45353   if (arg1) (arg1)->position = *arg2;
45354 }
45355
45356
45357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
45358   void * jresult ;
45359   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
45360   Dali::Vector2 *result = 0 ;
45361
45362   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
45363   result = (Dali::Vector2 *)& ((arg1)->position);
45364   jresult = (void *)result;
45365   return jresult;
45366 }
45367
45368
45369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
45370   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
45371   float arg2 ;
45372
45373   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
45374   arg2 = (float)jarg2;
45375   if (arg1) (arg1)->duration = arg2;
45376 }
45377
45378
45379 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
45380   float jresult ;
45381   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
45382   float result;
45383
45384   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
45385   result = (float) ((arg1)->duration);
45386   jresult = result;
45387   return jresult;
45388 }
45389
45390
45391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
45392   void * jresult ;
45393   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
45394
45395   {
45396     try {
45397       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
45398     } CALL_CATCH_EXCEPTION(0);
45399   }
45400
45401   jresult = (void *)result;
45402   return jresult;
45403 }
45404
45405
45406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
45407   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
45408
45409   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
45410   {
45411     try {
45412       delete arg1;
45413     } CALL_CATCH_EXCEPTION();
45414   }
45415
45416 }
45417
45418
45419 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
45420   int jresult ;
45421   int result;
45422
45423   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
45424   jresult = (int)result;
45425   return jresult;
45426 }
45427
45428
45429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
45430   int jresult ;
45431   int result;
45432
45433   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
45434   jresult = (int)result;
45435   return jresult;
45436 }
45437
45438
45439 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
45440   int jresult ;
45441   int result;
45442
45443   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
45444   jresult = (int)result;
45445   return jresult;
45446 }
45447
45448
45449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
45450   int jresult ;
45451   int result;
45452
45453   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
45454   jresult = (int)result;
45455   return jresult;
45456 }
45457
45458
45459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
45460   int jresult ;
45461   int result;
45462
45463   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
45464   jresult = (int)result;
45465   return jresult;
45466 }
45467
45468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
45469   int jresult ;
45470   int result;
45471
45472   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
45473   jresult = (int)result;
45474   return jresult;
45475 }
45476
45477
45478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
45479   int jresult ;
45480   int result;
45481
45482   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
45483   jresult = (int)result;
45484   return jresult;
45485 }
45486
45487
45488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
45489   int jresult ;
45490   int result;
45491
45492   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
45493   jresult = (int)result;
45494   return jresult;
45495 }
45496
45497
45498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
45499   int jresult ;
45500   int result;
45501
45502   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
45503   jresult = (int)result;
45504   return jresult;
45505 }
45506
45507
45508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
45509   int jresult ;
45510   int result;
45511
45512   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
45513   jresult = (int)result;
45514   return jresult;
45515 }
45516
45517
45518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
45519   int jresult ;
45520   int result;
45521
45522   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
45523   jresult = (int)result;
45524   return jresult;
45525 }
45526
45527
45528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
45529   int jresult ;
45530   int result;
45531
45532   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
45533   jresult = (int)result;
45534   return jresult;
45535 }
45536
45537
45538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
45539   int jresult ;
45540   int result;
45541
45542   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
45543   jresult = (int)result;
45544   return jresult;
45545 }
45546
45547
45548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
45549   int jresult ;
45550   int result;
45551
45552   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
45553   jresult = (int)result;
45554   return jresult;
45555 }
45556
45557
45558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
45559   int jresult ;
45560   int result;
45561
45562   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
45563   jresult = (int)result;
45564   return jresult;
45565 }
45566
45567
45568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
45569   int jresult ;
45570   int result;
45571
45572   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
45573   jresult = (int)result;
45574   return jresult;
45575 }
45576
45577
45578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
45579   int jresult ;
45580   int result;
45581
45582   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
45583   jresult = (int)result;
45584   return jresult;
45585 }
45586
45587
45588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
45589   int jresult ;
45590   int result;
45591
45592   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
45593   jresult = (int)result;
45594   return jresult;
45595 }
45596
45597
45598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
45599   int jresult ;
45600   int result;
45601
45602   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
45603   jresult = (int)result;
45604   return jresult;
45605 }
45606
45607
45608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
45609   int jresult ;
45610   int result;
45611
45612   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
45613   jresult = (int)result;
45614   return jresult;
45615 }
45616
45617
45618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
45619   int jresult ;
45620   int result;
45621
45622   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
45623   jresult = (int)result;
45624   return jresult;
45625 }
45626
45627
45628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
45629   int jresult ;
45630   int result;
45631
45632   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
45633   jresult = (int)result;
45634   return jresult;
45635 }
45636
45637
45638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
45639   int jresult ;
45640   int result;
45641
45642   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
45643   jresult = (int)result;
45644   return jresult;
45645 }
45646
45647
45648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
45649   int jresult ;
45650   int result;
45651
45652   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
45653   jresult = (int)result;
45654   return jresult;
45655 }
45656
45657
45658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
45659   int jresult ;
45660   int result;
45661
45662   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
45663   jresult = (int)result;
45664   return jresult;
45665 }
45666
45667
45668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
45669   int jresult ;
45670   int result;
45671
45672   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
45673   jresult = (int)result;
45674   return jresult;
45675 }
45676
45677
45678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
45679   void * jresult ;
45680   Dali::Toolkit::ScrollView::Property *result = 0 ;
45681
45682   {
45683     try {
45684       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
45685     } CALL_CATCH_EXCEPTION(0);
45686   }
45687
45688   jresult = (void *)result;
45689   return jresult;
45690 }
45691
45692
45693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
45694   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
45695
45696   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
45697   {
45698     try {
45699       delete arg1;
45700     } CALL_CATCH_EXCEPTION();
45701   }
45702
45703 }
45704
45705
45706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
45707   void * jresult ;
45708   Dali::Toolkit::ScrollView *result = 0 ;
45709
45710   {
45711     try {
45712       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
45713     } CALL_CATCH_EXCEPTION(0);
45714   }
45715
45716   jresult = (void *)result;
45717   return jresult;
45718 }
45719
45720
45721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
45722   void * jresult ;
45723   Dali::Toolkit::ScrollView *arg1 = 0 ;
45724   Dali::Toolkit::ScrollView *result = 0 ;
45725
45726   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45727   if (!arg1) {
45728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
45729     return 0;
45730   }
45731   {
45732     try {
45733       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
45734     } CALL_CATCH_EXCEPTION(0);
45735   }
45736
45737   jresult = (void *)result;
45738   return jresult;
45739 }
45740
45741
45742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
45743   void * jresult ;
45744   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45745   Dali::Toolkit::ScrollView *arg2 = 0 ;
45746   Dali::Toolkit::ScrollView *result = 0 ;
45747
45748   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45749   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
45750   if (!arg2) {
45751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
45752     return 0;
45753   }
45754   {
45755     try {
45756       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
45757     } CALL_CATCH_EXCEPTION(0);
45758   }
45759
45760   jresult = (void *)result;
45761   return jresult;
45762 }
45763
45764
45765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
45766   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45767
45768   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45769   {
45770     try {
45771       delete arg1;
45772     } CALL_CATCH_EXCEPTION();
45773   }
45774
45775 }
45776
45777
45778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
45779   void * jresult ;
45780   Dali::Toolkit::ScrollView result;
45781
45782   {
45783     try {
45784       result = Dali::Toolkit::ScrollView::New();
45785     } CALL_CATCH_EXCEPTION(0);
45786   }
45787
45788   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
45789   return jresult;
45790 }
45791
45792
45793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
45794   void * jresult ;
45795   Dali::BaseHandle arg1 ;
45796   Dali::BaseHandle *argp1 ;
45797   Dali::Toolkit::ScrollView result;
45798
45799   argp1 = (Dali::BaseHandle *)jarg1;
45800   if (!argp1) {
45801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45802     return 0;
45803   }
45804   arg1 = *argp1;
45805   {
45806     try {
45807       result = Dali::Toolkit::ScrollView::DownCast(arg1);
45808     } CALL_CATCH_EXCEPTION(0);
45809   }
45810
45811   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
45812   return jresult;
45813 }
45814
45815
45816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
45817   void * jresult ;
45818   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45819   Dali::AlphaFunction result;
45820
45821   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45822   {
45823     try {
45824       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
45825     } CALL_CATCH_EXCEPTION(0);
45826   }
45827
45828   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
45829   return jresult;
45830 }
45831
45832
45833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
45834   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45835   Dali::AlphaFunction arg2 ;
45836   Dali::AlphaFunction *argp2 ;
45837
45838   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45839   argp2 = (Dali::AlphaFunction *)jarg2;
45840   if (!argp2) {
45841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
45842     return ;
45843   }
45844   arg2 = *argp2;
45845   {
45846     try {
45847       (arg1)->SetScrollSnapAlphaFunction(arg2);
45848     } CALL_CATCH_EXCEPTION();
45849   }
45850
45851 }
45852
45853
45854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
45855   void * jresult ;
45856   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45857   Dali::AlphaFunction result;
45858
45859   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45860   {
45861     try {
45862       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
45863     } CALL_CATCH_EXCEPTION(0);
45864   }
45865
45866   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
45867   return jresult;
45868 }
45869
45870
45871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
45872   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45873   Dali::AlphaFunction arg2 ;
45874   Dali::AlphaFunction *argp2 ;
45875
45876   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45877   argp2 = (Dali::AlphaFunction *)jarg2;
45878   if (!argp2) {
45879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
45880     return ;
45881   }
45882   arg2 = *argp2;
45883   {
45884     try {
45885       (arg1)->SetScrollFlickAlphaFunction(arg2);
45886     } CALL_CATCH_EXCEPTION();
45887   }
45888
45889 }
45890
45891
45892 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
45893   float jresult ;
45894   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45895   float result;
45896
45897   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45898   {
45899     try {
45900       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
45901     } CALL_CATCH_EXCEPTION(0);
45902   }
45903
45904   jresult = result;
45905   return jresult;
45906 }
45907
45908
45909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
45910   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45911   float arg2 ;
45912
45913   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45914   arg2 = (float)jarg2;
45915   {
45916     try {
45917       (arg1)->SetScrollSnapDuration(arg2);
45918     } CALL_CATCH_EXCEPTION();
45919   }
45920
45921 }
45922
45923
45924 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
45925   float jresult ;
45926   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45927   float result;
45928
45929   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45930   {
45931     try {
45932       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
45933     } CALL_CATCH_EXCEPTION(0);
45934   }
45935
45936   jresult = result;
45937   return jresult;
45938 }
45939
45940
45941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
45942   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45943   float arg2 ;
45944
45945   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45946   arg2 = (float)jarg2;
45947   {
45948     try {
45949       (arg1)->SetScrollFlickDuration(arg2);
45950     } CALL_CATCH_EXCEPTION();
45951   }
45952
45953 }
45954
45955
45956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
45957   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45958   Dali::Toolkit::RulerPtr arg2 ;
45959   Dali::Toolkit::RulerPtr *argp2 ;
45960
45961   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45962   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
45963   if (!argp2) {
45964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
45965     return ;
45966   }
45967   arg2 = *argp2;
45968   {
45969     try {
45970       (arg1)->SetRulerX(arg2);
45971     } CALL_CATCH_EXCEPTION();
45972   }
45973
45974 }
45975
45976
45977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
45978   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45979   Dali::Toolkit::RulerPtr arg2 ;
45980   Dali::Toolkit::RulerPtr *argp2 ;
45981
45982   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45983   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
45984   if (!argp2) {
45985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
45986     return ;
45987   }
45988   arg2 = *argp2;
45989   {
45990     try {
45991       (arg1)->SetRulerY(arg2);
45992     } CALL_CATCH_EXCEPTION();
45993   }
45994
45995 }
45996
45997
45998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, bool jarg2) {
45999   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46000   bool arg2 ;
46001
46002   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46003   arg2 = jarg2 ? true : false;
46004   {
46005     try {
46006       (arg1)->SetScrollSensitive(arg2);
46007     } CALL_CATCH_EXCEPTION();
46008   }
46009
46010 }
46011
46012
46013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
46014   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46015   float arg2 ;
46016   float arg3 ;
46017
46018   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46019   arg2 = (float)jarg2;
46020   arg3 = (float)jarg3;
46021   {
46022     try {
46023       (arg1)->SetMaxOvershoot(arg2,arg3);
46024     } CALL_CATCH_EXCEPTION();
46025   }
46026
46027 }
46028
46029
46030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
46031   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46032   Dali::AlphaFunction arg2 ;
46033   Dali::AlphaFunction *argp2 ;
46034
46035   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46036   argp2 = (Dali::AlphaFunction *)jarg2;
46037   if (!argp2) {
46038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
46039     return ;
46040   }
46041   arg2 = *argp2;
46042   {
46043     try {
46044       (arg1)->SetSnapOvershootAlphaFunction(arg2);
46045     } CALL_CATCH_EXCEPTION();
46046   }
46047
46048 }
46049
46050
46051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
46052   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46053   float arg2 ;
46054
46055   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46056   arg2 = (float)jarg2;
46057   {
46058     try {
46059       (arg1)->SetSnapOvershootDuration(arg2);
46060     } CALL_CATCH_EXCEPTION();
46061   }
46062
46063 }
46064
46065
46066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, bool jarg2) {
46067   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46068   bool arg2 ;
46069
46070   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46071   arg2 = jarg2 ? true : false;
46072   {
46073     try {
46074       (arg1)->SetActorAutoSnap(arg2);
46075     } CALL_CATCH_EXCEPTION();
46076   }
46077
46078 }
46079
46080
46081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, bool jarg2) {
46082   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46083   bool arg2 ;
46084
46085   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46086   arg2 = jarg2 ? true : false;
46087   {
46088     try {
46089       (arg1)->SetWrapMode(arg2);
46090     } CALL_CATCH_EXCEPTION();
46091   }
46092
46093 }
46094
46095
46096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
46097   int jresult ;
46098   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46099   int result;
46100
46101   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46102   {
46103     try {
46104       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
46105     } CALL_CATCH_EXCEPTION(0);
46106   }
46107
46108   jresult = result;
46109   return jresult;
46110 }
46111
46112
46113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
46114   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46115   int arg2 ;
46116
46117   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46118   arg2 = (int)jarg2;
46119   {
46120     try {
46121       (arg1)->SetScrollUpdateDistance(arg2);
46122     } CALL_CATCH_EXCEPTION();
46123   }
46124
46125 }
46126
46127
46128 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
46129   bool jresult ;
46130   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46131   bool result;
46132
46133   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46134   {
46135     try {
46136       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
46137     } CALL_CATCH_EXCEPTION(0);
46138   }
46139
46140   jresult = result;
46141   return jresult;
46142 }
46143
46144
46145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, bool jarg2) {
46146   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46147   bool arg2 ;
46148
46149   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46150   arg2 = jarg2 ? true : false;
46151   {
46152     try {
46153       (arg1)->SetAxisAutoLock(arg2);
46154     } CALL_CATCH_EXCEPTION();
46155   }
46156
46157 }
46158
46159
46160 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
46161   float jresult ;
46162   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46163   float result;
46164
46165   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46166   {
46167     try {
46168       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
46169     } CALL_CATCH_EXCEPTION(0);
46170   }
46171
46172   jresult = result;
46173   return jresult;
46174 }
46175
46176
46177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
46178   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46179   float arg2 ;
46180
46181   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46182   arg2 = (float)jarg2;
46183   {
46184     try {
46185       (arg1)->SetAxisAutoLockGradient(arg2);
46186     } CALL_CATCH_EXCEPTION();
46187   }
46188
46189 }
46190
46191
46192 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
46193   float jresult ;
46194   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46195   float result;
46196
46197   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46198   {
46199     try {
46200       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
46201     } CALL_CATCH_EXCEPTION(0);
46202   }
46203
46204   jresult = result;
46205   return jresult;
46206 }
46207
46208
46209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
46210   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46211   float arg2 ;
46212
46213   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46214   arg2 = (float)jarg2;
46215   {
46216     try {
46217       (arg1)->SetFrictionCoefficient(arg2);
46218     } CALL_CATCH_EXCEPTION();
46219   }
46220
46221 }
46222
46223
46224 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
46225   float jresult ;
46226   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46227   float result;
46228
46229   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46230   {
46231     try {
46232       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
46233     } CALL_CATCH_EXCEPTION(0);
46234   }
46235
46236   jresult = result;
46237   return jresult;
46238 }
46239
46240
46241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
46242   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46243   float arg2 ;
46244
46245   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46246   arg2 = (float)jarg2;
46247   {
46248     try {
46249       (arg1)->SetFlickSpeedCoefficient(arg2);
46250     } CALL_CATCH_EXCEPTION();
46251   }
46252
46253 }
46254
46255
46256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
46257   void * jresult ;
46258   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46259   Dali::Vector2 result;
46260
46261   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46262   {
46263     try {
46264       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
46265     } CALL_CATCH_EXCEPTION(0);
46266   }
46267
46268   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
46269   return jresult;
46270 }
46271
46272
46273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
46274   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46275   Dali::Vector2 *arg2 = 0 ;
46276
46277   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46278   arg2 = (Dali::Vector2 *)jarg2;
46279   if (!arg2) {
46280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
46281     return ;
46282   }
46283   {
46284     try {
46285       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
46286     } CALL_CATCH_EXCEPTION();
46287   }
46288
46289 }
46290
46291
46292 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
46293   float jresult ;
46294   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46295   float result;
46296
46297   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46298   {
46299     try {
46300       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
46301     } CALL_CATCH_EXCEPTION(0);
46302   }
46303
46304   jresult = result;
46305   return jresult;
46306 }
46307
46308
46309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
46310   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46311   float arg2 ;
46312
46313   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46314   arg2 = (float)jarg2;
46315   {
46316     try {
46317       (arg1)->SetMinimumSpeedForFlick(arg2);
46318     } CALL_CATCH_EXCEPTION();
46319   }
46320
46321 }
46322
46323
46324 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
46325   float jresult ;
46326   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46327   float result;
46328
46329   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46330   {
46331     try {
46332       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
46333     } CALL_CATCH_EXCEPTION(0);
46334   }
46335
46336   jresult = result;
46337   return jresult;
46338 }
46339
46340
46341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
46342   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46343   float arg2 ;
46344
46345   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46346   arg2 = (float)jarg2;
46347   {
46348     try {
46349       (arg1)->SetMaxFlickSpeed(arg2);
46350     } CALL_CATCH_EXCEPTION();
46351   }
46352
46353 }
46354
46355
46356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
46357   void * jresult ;
46358   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46359   Dali::Vector2 result;
46360
46361   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46362   {
46363     try {
46364       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
46365     } CALL_CATCH_EXCEPTION(0);
46366   }
46367
46368   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
46369   return jresult;
46370 }
46371
46372
46373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
46374   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46375   Dali::Vector2 arg2 ;
46376   Dali::Vector2 *argp2 ;
46377
46378   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46379   argp2 = (Dali::Vector2 *)jarg2;
46380   if (!argp2) {
46381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
46382     return ;
46383   }
46384   arg2 = *argp2;
46385   {
46386     try {
46387       (arg1)->SetWheelScrollDistanceStep(arg2);
46388     } CALL_CATCH_EXCEPTION();
46389   }
46390
46391 }
46392
46393
46394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
46395   void * jresult ;
46396   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46397   Dali::Vector2 result;
46398
46399   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46400   {
46401     try {
46402       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
46403     } CALL_CATCH_EXCEPTION(0);
46404   }
46405
46406   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
46407   return jresult;
46408 }
46409
46410
46411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
46412   unsigned int jresult ;
46413   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46414   unsigned int result;
46415
46416   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46417   {
46418     try {
46419       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
46420     } CALL_CATCH_EXCEPTION(0);
46421   }
46422
46423   jresult = result;
46424   return jresult;
46425 }
46426
46427
46428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
46429   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46430   Dali::Vector2 *arg2 = 0 ;
46431
46432   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46433   arg2 = (Dali::Vector2 *)jarg2;
46434   if (!arg2) {
46435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
46436     return ;
46437   }
46438   {
46439     try {
46440       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
46441     } CALL_CATCH_EXCEPTION();
46442   }
46443
46444 }
46445
46446
46447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
46448   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46449   Dali::Vector2 *arg2 = 0 ;
46450   float arg3 ;
46451
46452   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46453   arg2 = (Dali::Vector2 *)jarg2;
46454   if (!arg2) {
46455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
46456     return ;
46457   }
46458   arg3 = (float)jarg3;
46459   {
46460     try {
46461       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
46462     } CALL_CATCH_EXCEPTION();
46463   }
46464
46465 }
46466
46467
46468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
46469   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46470   Dali::Vector2 *arg2 = 0 ;
46471   float arg3 ;
46472   Dali::AlphaFunction arg4 ;
46473   Dali::AlphaFunction *argp4 ;
46474
46475   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46476   arg2 = (Dali::Vector2 *)jarg2;
46477   if (!arg2) {
46478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
46479     return ;
46480   }
46481   arg3 = (float)jarg3;
46482   argp4 = (Dali::AlphaFunction *)jarg4;
46483   if (!argp4) {
46484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
46485     return ;
46486   }
46487   arg4 = *argp4;
46488   {
46489     try {
46490       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
46491     } CALL_CATCH_EXCEPTION();
46492   }
46493
46494 }
46495
46496
46497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
46498   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46499   Dali::Vector2 *arg2 = 0 ;
46500   float arg3 ;
46501   Dali::Toolkit::DirectionBias arg4 ;
46502   Dali::Toolkit::DirectionBias arg5 ;
46503
46504   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46505   arg2 = (Dali::Vector2 *)jarg2;
46506   if (!arg2) {
46507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
46508     return ;
46509   }
46510   arg3 = (float)jarg3;
46511   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
46512   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
46513   {
46514     try {
46515       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
46516     } CALL_CATCH_EXCEPTION();
46517   }
46518
46519 }
46520
46521
46522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
46523   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46524   Dali::Vector2 *arg2 = 0 ;
46525   float arg3 ;
46526   Dali::AlphaFunction arg4 ;
46527   Dali::Toolkit::DirectionBias arg5 ;
46528   Dali::Toolkit::DirectionBias arg6 ;
46529   Dali::AlphaFunction *argp4 ;
46530
46531   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46532   arg2 = (Dali::Vector2 *)jarg2;
46533   if (!arg2) {
46534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
46535     return ;
46536   }
46537   arg3 = (float)jarg3;
46538   argp4 = (Dali::AlphaFunction *)jarg4;
46539   if (!argp4) {
46540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
46541     return ;
46542   }
46543   arg4 = *argp4;
46544   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
46545   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
46546   {
46547     try {
46548       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
46549     } CALL_CATCH_EXCEPTION();
46550   }
46551
46552 }
46553
46554
46555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
46556   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46557   unsigned int arg2 ;
46558
46559   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46560   arg2 = (unsigned int)jarg2;
46561   {
46562     try {
46563       (arg1)->ScrollTo(arg2);
46564     } CALL_CATCH_EXCEPTION();
46565   }
46566
46567 }
46568
46569
46570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
46571   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46572   unsigned int arg2 ;
46573   float arg3 ;
46574
46575   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46576   arg2 = (unsigned int)jarg2;
46577   arg3 = (float)jarg3;
46578   {
46579     try {
46580       (arg1)->ScrollTo(arg2,arg3);
46581     } CALL_CATCH_EXCEPTION();
46582   }
46583
46584 }
46585
46586
46587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
46588   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46589   unsigned int arg2 ;
46590   float arg3 ;
46591   Dali::Toolkit::DirectionBias arg4 ;
46592
46593   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46594   arg2 = (unsigned int)jarg2;
46595   arg3 = (float)jarg3;
46596   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
46597   {
46598     try {
46599       (arg1)->ScrollTo(arg2,arg3,arg4);
46600     } CALL_CATCH_EXCEPTION();
46601   }
46602
46603 }
46604
46605
46606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
46607   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46608   Dali::Actor *arg2 = 0 ;
46609
46610   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46611   arg2 = (Dali::Actor *)jarg2;
46612   if (!arg2) {
46613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
46614     return ;
46615   }
46616   {
46617     try {
46618       (arg1)->ScrollTo(*arg2);
46619     } CALL_CATCH_EXCEPTION();
46620   }
46621
46622 }
46623
46624
46625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
46626   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46627   Dali::Actor *arg2 = 0 ;
46628   float arg3 ;
46629
46630   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46631   arg2 = (Dali::Actor *)jarg2;
46632   if (!arg2) {
46633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
46634     return ;
46635   }
46636   arg3 = (float)jarg3;
46637   {
46638     try {
46639       (arg1)->ScrollTo(*arg2,arg3);
46640     } CALL_CATCH_EXCEPTION();
46641   }
46642
46643 }
46644
46645
46646 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
46647   bool jresult ;
46648   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46649   bool result;
46650
46651   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46652   {
46653     try {
46654       result = (bool)(arg1)->ScrollToSnapPoint();
46655     } CALL_CATCH_EXCEPTION(0);
46656   }
46657
46658   jresult = result;
46659   return jresult;
46660 }
46661
46662
46663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
46664   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46665   Dali::Constraint arg2 ;
46666   Dali::Constraint *argp2 ;
46667
46668   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46669   argp2 = (Dali::Constraint *)jarg2;
46670   if (!argp2) {
46671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
46672     return ;
46673   }
46674   arg2 = *argp2;
46675   {
46676     try {
46677       (arg1)->ApplyConstraintToChildren(arg2);
46678     } CALL_CATCH_EXCEPTION();
46679   }
46680
46681 }
46682
46683
46684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
46685   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46686
46687   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46688   {
46689     try {
46690       (arg1)->RemoveConstraintsFromChildren();
46691     } CALL_CATCH_EXCEPTION();
46692   }
46693
46694 }
46695
46696
46697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
46698   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46699   Dali::Toolkit::ScrollViewEffect arg2 ;
46700   Dali::Toolkit::ScrollViewEffect *argp2 ;
46701
46702   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46703   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
46704   if (!argp2) {
46705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
46706     return ;
46707   }
46708   arg2 = *argp2;
46709   {
46710     try {
46711       (arg1)->ApplyEffect(arg2);
46712     } CALL_CATCH_EXCEPTION();
46713   }
46714
46715 }
46716
46717
46718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
46719   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46720   Dali::Toolkit::ScrollViewEffect arg2 ;
46721   Dali::Toolkit::ScrollViewEffect *argp2 ;
46722
46723   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46724   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
46725   if (!argp2) {
46726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
46727     return ;
46728   }
46729   arg2 = *argp2;
46730   {
46731     try {
46732       (arg1)->RemoveEffect(arg2);
46733     } CALL_CATCH_EXCEPTION();
46734   }
46735
46736 }
46737
46738
46739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
46740   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46741
46742   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46743   {
46744     try {
46745       (arg1)->RemoveAllEffects();
46746     } CALL_CATCH_EXCEPTION();
46747   }
46748
46749 }
46750
46751
46752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
46753   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46754   Dali::Actor arg2 ;
46755   Dali::Actor *argp2 ;
46756
46757   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46758   argp2 = (Dali::Actor *)jarg2;
46759   if (!argp2) {
46760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
46761     return ;
46762   }
46763   arg2 = *argp2;
46764   {
46765     try {
46766       (arg1)->BindActor(arg2);
46767     } CALL_CATCH_EXCEPTION();
46768   }
46769
46770 }
46771
46772
46773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
46774   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46775   Dali::Actor arg2 ;
46776   Dali::Actor *argp2 ;
46777
46778   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46779   argp2 = (Dali::Actor *)jarg2;
46780   if (!argp2) {
46781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
46782     return ;
46783   }
46784   arg2 = *argp2;
46785   {
46786     try {
46787       (arg1)->UnbindActor(arg2);
46788     } CALL_CATCH_EXCEPTION();
46789   }
46790
46791 }
46792
46793
46794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
46795   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46796   Dali::Radian arg2 ;
46797   Dali::Radian arg3 ;
46798   Dali::Radian *argp2 ;
46799   Dali::Radian *argp3 ;
46800
46801   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46802   argp2 = (Dali::Radian *)jarg2;
46803   if (!argp2) {
46804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
46805     return ;
46806   }
46807   arg2 = *argp2;
46808   argp3 = (Dali::Radian *)jarg3;
46809   if (!argp3) {
46810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
46811     return ;
46812   }
46813   arg3 = *argp3;
46814   {
46815     try {
46816       (arg1)->SetScrollingDirection(arg2,arg3);
46817     } CALL_CATCH_EXCEPTION();
46818   }
46819
46820 }
46821
46822
46823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
46824   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46825   Dali::Radian arg2 ;
46826   Dali::Radian *argp2 ;
46827
46828   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46829   argp2 = (Dali::Radian *)jarg2;
46830   if (!argp2) {
46831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
46832     return ;
46833   }
46834   arg2 = *argp2;
46835   {
46836     try {
46837       (arg1)->SetScrollingDirection(arg2);
46838     } CALL_CATCH_EXCEPTION();
46839   }
46840
46841 }
46842
46843
46844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
46845   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46846   Dali::Radian arg2 ;
46847   Dali::Radian *argp2 ;
46848
46849   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46850   argp2 = (Dali::Radian *)jarg2;
46851   if (!argp2) {
46852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
46853     return ;
46854   }
46855   arg2 = *argp2;
46856   {
46857     try {
46858       (arg1)->RemoveScrollingDirection(arg2);
46859     } CALL_CATCH_EXCEPTION();
46860   }
46861
46862 }
46863
46864
46865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
46866   void * jresult ;
46867   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46868   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
46869
46870   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46871   {
46872     try {
46873       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
46874     } CALL_CATCH_EXCEPTION(0);
46875   }
46876
46877   jresult = (void *)result;
46878   return jresult;
46879 }
46880
46881
46882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
46883   int jresult ;
46884   int result;
46885
46886   result = (int)Dali::Toolkit::TableView::Property::ROWS;
46887   jresult = (int)result;
46888   return jresult;
46889 }
46890
46891
46892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
46893   int jresult ;
46894   int result;
46895
46896   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
46897   jresult = (int)result;
46898   return jresult;
46899 }
46900
46901
46902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
46903   int jresult ;
46904   int result;
46905
46906   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
46907   jresult = (int)result;
46908   return jresult;
46909 }
46910
46911
46912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
46913   int jresult ;
46914   int result;
46915
46916   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
46917   jresult = (int)result;
46918   return jresult;
46919 }
46920
46921
46922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
46923   int jresult ;
46924   int result;
46925
46926   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
46927   jresult = (int)result;
46928   return jresult;
46929 }
46930
46931
46932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
46933   void * jresult ;
46934   Dali::Toolkit::TableView::Property *result = 0 ;
46935
46936   {
46937     try {
46938       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
46939     } CALL_CATCH_EXCEPTION(0);
46940   }
46941
46942   jresult = (void *)result;
46943   return jresult;
46944 }
46945
46946
46947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
46948   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
46949
46950   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
46951   {
46952     try {
46953       delete arg1;
46954     } CALL_CATCH_EXCEPTION();
46955   }
46956
46957 }
46958
46959
46960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
46961   int jresult ;
46962   int result;
46963
46964   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
46965   jresult = (int)result;
46966   return jresult;
46967 }
46968
46969
46970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
46971   int jresult ;
46972   int result;
46973
46974   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
46975   jresult = (int)result;
46976   return jresult;
46977 }
46978
46979
46980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
46981   int jresult ;
46982   int result;
46983
46984   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
46985   jresult = (int)result;
46986   return jresult;
46987 }
46988
46989
46990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
46991   int jresult ;
46992   int result;
46993
46994   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
46995   jresult = (int)result;
46996   return jresult;
46997 }
46998
46999
47000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
47001   int jresult ;
47002   int result;
47003
47004   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
47005   jresult = (int)result;
47006   return jresult;
47007 }
47008
47009
47010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
47011   void * jresult ;
47012   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
47013
47014   {
47015     try {
47016       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
47017     } CALL_CATCH_EXCEPTION(0);
47018   }
47019
47020   jresult = (void *)result;
47021   return jresult;
47022 }
47023
47024
47025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
47026   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
47027
47028   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
47029   {
47030     try {
47031       delete arg1;
47032     } CALL_CATCH_EXCEPTION();
47033   }
47034
47035 }
47036
47037
47038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
47039   void * jresult ;
47040   unsigned int arg1 ;
47041   unsigned int arg2 ;
47042   unsigned int arg3 ;
47043   unsigned int arg4 ;
47044   Dali::Toolkit::TableView::CellPosition *result = 0 ;
47045
47046   arg1 = (unsigned int)jarg1;
47047   arg2 = (unsigned int)jarg2;
47048   arg3 = (unsigned int)jarg3;
47049   arg4 = (unsigned int)jarg4;
47050   {
47051     try {
47052       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
47053     } CALL_CATCH_EXCEPTION(0);
47054   }
47055
47056   jresult = (void *)result;
47057   return jresult;
47058 }
47059
47060
47061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
47062   void * jresult ;
47063   unsigned int arg1 ;
47064   unsigned int arg2 ;
47065   unsigned int arg3 ;
47066   Dali::Toolkit::TableView::CellPosition *result = 0 ;
47067
47068   arg1 = (unsigned int)jarg1;
47069   arg2 = (unsigned int)jarg2;
47070   arg3 = (unsigned int)jarg3;
47071   {
47072     try {
47073       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
47074     } CALL_CATCH_EXCEPTION(0);
47075   }
47076
47077   jresult = (void *)result;
47078   return jresult;
47079 }
47080
47081
47082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47083   void * jresult ;
47084   unsigned int arg1 ;
47085   unsigned int arg2 ;
47086   Dali::Toolkit::TableView::CellPosition *result = 0 ;
47087
47088   arg1 = (unsigned int)jarg1;
47089   arg2 = (unsigned int)jarg2;
47090   {
47091     try {
47092       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
47093     } CALL_CATCH_EXCEPTION(0);
47094   }
47095
47096   jresult = (void *)result;
47097   return jresult;
47098 }
47099
47100
47101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
47102   void * jresult ;
47103   unsigned int arg1 ;
47104   Dali::Toolkit::TableView::CellPosition *result = 0 ;
47105
47106   arg1 = (unsigned int)jarg1;
47107   {
47108     try {
47109       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
47110     } CALL_CATCH_EXCEPTION(0);
47111   }
47112
47113   jresult = (void *)result;
47114   return jresult;
47115 }
47116
47117
47118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
47119   void * jresult ;
47120   Dali::Toolkit::TableView::CellPosition *result = 0 ;
47121
47122   {
47123     try {
47124       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
47125     } CALL_CATCH_EXCEPTION(0);
47126   }
47127
47128   jresult = (void *)result;
47129   return jresult;
47130 }
47131
47132
47133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
47134   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
47135   unsigned int arg2 ;
47136
47137   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
47138   arg2 = (unsigned int)jarg2;
47139   if (arg1) (arg1)->rowIndex = arg2;
47140 }
47141
47142
47143 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
47144   unsigned int jresult ;
47145   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
47146   unsigned int result;
47147
47148   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
47149   result = (unsigned int) ((arg1)->rowIndex);
47150   jresult = result;
47151   return jresult;
47152 }
47153
47154
47155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
47156   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
47157   unsigned int arg2 ;
47158
47159   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
47160   arg2 = (unsigned int)jarg2;
47161   if (arg1) (arg1)->columnIndex = arg2;
47162 }
47163
47164
47165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
47166   unsigned int jresult ;
47167   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
47168   unsigned int result;
47169
47170   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
47171   result = (unsigned int) ((arg1)->columnIndex);
47172   jresult = result;
47173   return jresult;
47174 }
47175
47176
47177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
47178   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
47179   unsigned int arg2 ;
47180
47181   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
47182   arg2 = (unsigned int)jarg2;
47183   if (arg1) (arg1)->rowSpan = arg2;
47184 }
47185
47186
47187 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
47188   unsigned int jresult ;
47189   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
47190   unsigned int result;
47191
47192   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
47193   result = (unsigned int) ((arg1)->rowSpan);
47194   jresult = result;
47195   return jresult;
47196 }
47197
47198
47199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
47200   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
47201   unsigned int arg2 ;
47202
47203   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
47204   arg2 = (unsigned int)jarg2;
47205   if (arg1) (arg1)->columnSpan = arg2;
47206 }
47207
47208
47209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
47210   unsigned int jresult ;
47211   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
47212   unsigned int result;
47213
47214   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
47215   result = (unsigned int) ((arg1)->columnSpan);
47216   jresult = result;
47217   return jresult;
47218 }
47219
47220
47221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
47222   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
47223
47224   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
47225   {
47226     try {
47227       delete arg1;
47228     } CALL_CATCH_EXCEPTION();
47229   }
47230
47231 }
47232
47233
47234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
47235   void * jresult ;
47236   Dali::Toolkit::TableView *result = 0 ;
47237
47238   {
47239     try {
47240       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
47241     } CALL_CATCH_EXCEPTION(0);
47242   }
47243
47244   jresult = (void *)result;
47245   return jresult;
47246 }
47247
47248
47249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
47250   void * jresult ;
47251   Dali::Toolkit::TableView *arg1 = 0 ;
47252   Dali::Toolkit::TableView *result = 0 ;
47253
47254   arg1 = (Dali::Toolkit::TableView *)jarg1;
47255   if (!arg1) {
47256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
47257     return 0;
47258   }
47259   {
47260     try {
47261       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
47262     } CALL_CATCH_EXCEPTION(0);
47263   }
47264
47265   jresult = (void *)result;
47266   return jresult;
47267 }
47268
47269
47270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
47271   void * jresult ;
47272   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47273   Dali::Toolkit::TableView *arg2 = 0 ;
47274   Dali::Toolkit::TableView *result = 0 ;
47275
47276   arg1 = (Dali::Toolkit::TableView *)jarg1;
47277   arg2 = (Dali::Toolkit::TableView *)jarg2;
47278   if (!arg2) {
47279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
47280     return 0;
47281   }
47282   {
47283     try {
47284       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
47285     } CALL_CATCH_EXCEPTION(0);
47286   }
47287
47288   jresult = (void *)result;
47289   return jresult;
47290 }
47291
47292
47293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
47294   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47295
47296   arg1 = (Dali::Toolkit::TableView *)jarg1;
47297   {
47298     try {
47299       delete arg1;
47300     } CALL_CATCH_EXCEPTION();
47301   }
47302
47303 }
47304
47305
47306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
47307   void * jresult ;
47308   unsigned int arg1 ;
47309   unsigned int arg2 ;
47310   Dali::Toolkit::TableView result;
47311
47312   arg1 = (unsigned int)jarg1;
47313   arg2 = (unsigned int)jarg2;
47314   {
47315     try {
47316       result = Dali::Toolkit::TableView::New(arg1,arg2);
47317     } CALL_CATCH_EXCEPTION(0);
47318   }
47319
47320   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
47321   return jresult;
47322 }
47323
47324
47325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
47326   void * jresult ;
47327   Dali::BaseHandle arg1 ;
47328   Dali::BaseHandle *argp1 ;
47329   Dali::Toolkit::TableView result;
47330
47331   argp1 = (Dali::BaseHandle *)jarg1;
47332   if (!argp1) {
47333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47334     return 0;
47335   }
47336   arg1 = *argp1;
47337   {
47338     try {
47339       result = Dali::Toolkit::TableView::DownCast(arg1);
47340     } CALL_CATCH_EXCEPTION(0);
47341   }
47342
47343   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
47344   return jresult;
47345 }
47346
47347
47348 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
47349   bool jresult ;
47350   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47351   Dali::Actor arg2 ;
47352   Dali::Toolkit::TableView::CellPosition arg3 ;
47353   Dali::Actor *argp2 ;
47354   Dali::Toolkit::TableView::CellPosition *argp3 ;
47355   bool result;
47356
47357   arg1 = (Dali::Toolkit::TableView *)jarg1;
47358   argp2 = (Dali::Actor *)jarg2;
47359   if (!argp2) {
47360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47361     return 0;
47362   }
47363   arg2 = *argp2;
47364   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
47365   if (!argp3) {
47366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
47367     return 0;
47368   }
47369   arg3 = *argp3;
47370   {
47371     try {
47372       result = (bool)(arg1)->AddChild(arg2,arg3);
47373     } CALL_CATCH_EXCEPTION(0);
47374   }
47375
47376   jresult = result;
47377   return jresult;
47378 }
47379
47380
47381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
47382   void * jresult ;
47383   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47384   Dali::Toolkit::TableView::CellPosition arg2 ;
47385   Dali::Toolkit::TableView::CellPosition *argp2 ;
47386   Dali::Actor result;
47387
47388   arg1 = (Dali::Toolkit::TableView *)jarg1;
47389   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
47390   if (!argp2) {
47391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
47392     return 0;
47393   }
47394   arg2 = *argp2;
47395   {
47396     try {
47397       result = (arg1)->GetChildAt(arg2);
47398     } CALL_CATCH_EXCEPTION(0);
47399   }
47400
47401   jresult = new Dali::Actor((const Dali::Actor &)result);
47402   return jresult;
47403 }
47404
47405
47406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
47407   void * jresult ;
47408   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47409   Dali::Toolkit::TableView::CellPosition arg2 ;
47410   Dali::Toolkit::TableView::CellPosition *argp2 ;
47411   Dali::Actor result;
47412
47413   arg1 = (Dali::Toolkit::TableView *)jarg1;
47414   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
47415   if (!argp2) {
47416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
47417     return 0;
47418   }
47419   arg2 = *argp2;
47420   {
47421     try {
47422       result = (arg1)->RemoveChildAt(arg2);
47423     } CALL_CATCH_EXCEPTION(0);
47424   }
47425
47426   jresult = new Dali::Actor((const Dali::Actor &)result);
47427   return jresult;
47428 }
47429
47430
47431 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
47432   bool jresult ;
47433   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47434   Dali::Actor arg2 ;
47435   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
47436   Dali::Actor *argp2 ;
47437   bool result;
47438
47439   arg1 = (Dali::Toolkit::TableView *)jarg1;
47440   argp2 = (Dali::Actor *)jarg2;
47441   if (!argp2) {
47442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47443     return 0;
47444   }
47445   arg2 = *argp2;
47446   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
47447   if (!arg3) {
47448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
47449     return 0;
47450   }
47451   {
47452     try {
47453       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
47454     } CALL_CATCH_EXCEPTION(0);
47455   }
47456
47457   jresult = result;
47458   return jresult;
47459 }
47460
47461
47462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
47463   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47464   unsigned int arg2 ;
47465
47466   arg1 = (Dali::Toolkit::TableView *)jarg1;
47467   arg2 = (unsigned int)jarg2;
47468   {
47469     try {
47470       (arg1)->InsertRow(arg2);
47471     } CALL_CATCH_EXCEPTION();
47472   }
47473
47474 }
47475
47476
47477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
47478   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47479   unsigned int arg2 ;
47480
47481   arg1 = (Dali::Toolkit::TableView *)jarg1;
47482   arg2 = (unsigned int)jarg2;
47483   {
47484     try {
47485       (arg1)->DeleteRow(arg2);
47486     } CALL_CATCH_EXCEPTION();
47487   }
47488
47489 }
47490
47491
47492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
47493   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47494   unsigned int arg2 ;
47495   std::vector< Dali::Actor > *arg3 = 0 ;
47496
47497   arg1 = (Dali::Toolkit::TableView *)jarg1;
47498   arg2 = (unsigned int)jarg2;
47499   arg3 = (std::vector< Dali::Actor > *)jarg3;
47500   if (!arg3) {
47501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
47502     return ;
47503   }
47504   {
47505     try {
47506       (arg1)->DeleteRow(arg2,*arg3);
47507     } CALL_CATCH_EXCEPTION();
47508   }
47509
47510 }
47511
47512
47513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
47514   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47515   unsigned int arg2 ;
47516
47517   arg1 = (Dali::Toolkit::TableView *)jarg1;
47518   arg2 = (unsigned int)jarg2;
47519   {
47520     try {
47521       (arg1)->InsertColumn(arg2);
47522     } CALL_CATCH_EXCEPTION();
47523   }
47524
47525 }
47526
47527
47528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
47529   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47530   unsigned int arg2 ;
47531
47532   arg1 = (Dali::Toolkit::TableView *)jarg1;
47533   arg2 = (unsigned int)jarg2;
47534   {
47535     try {
47536       (arg1)->DeleteColumn(arg2);
47537     } CALL_CATCH_EXCEPTION();
47538   }
47539
47540 }
47541
47542
47543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
47544   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47545   unsigned int arg2 ;
47546   std::vector< Dali::Actor > *arg3 = 0 ;
47547
47548   arg1 = (Dali::Toolkit::TableView *)jarg1;
47549   arg2 = (unsigned int)jarg2;
47550   arg3 = (std::vector< Dali::Actor > *)jarg3;
47551   if (!arg3) {
47552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
47553     return ;
47554   }
47555   {
47556     try {
47557       (arg1)->DeleteColumn(arg2,*arg3);
47558     } CALL_CATCH_EXCEPTION();
47559   }
47560
47561 }
47562
47563
47564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
47565   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47566   unsigned int arg2 ;
47567   unsigned int arg3 ;
47568
47569   arg1 = (Dali::Toolkit::TableView *)jarg1;
47570   arg2 = (unsigned int)jarg2;
47571   arg3 = (unsigned int)jarg3;
47572   {
47573     try {
47574       (arg1)->Resize(arg2,arg3);
47575     } CALL_CATCH_EXCEPTION();
47576   }
47577
47578 }
47579
47580
47581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
47582   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47583   unsigned int arg2 ;
47584   unsigned int arg3 ;
47585   std::vector< Dali::Actor > *arg4 = 0 ;
47586
47587   arg1 = (Dali::Toolkit::TableView *)jarg1;
47588   arg2 = (unsigned int)jarg2;
47589   arg3 = (unsigned int)jarg3;
47590   arg4 = (std::vector< Dali::Actor > *)jarg4;
47591   if (!arg4) {
47592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
47593     return ;
47594   }
47595   {
47596     try {
47597       (arg1)->Resize(arg2,arg3,*arg4);
47598     } CALL_CATCH_EXCEPTION();
47599   }
47600
47601 }
47602
47603
47604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
47605   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47606   Dali::Size arg2 ;
47607   Dali::Size *argp2 ;
47608
47609   arg1 = (Dali::Toolkit::TableView *)jarg1;
47610   argp2 = (Dali::Size *)jarg2;
47611   if (!argp2) {
47612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
47613     return ;
47614   }
47615   arg2 = *argp2;
47616   {
47617     try {
47618       (arg1)->SetCellPadding(arg2);
47619     } CALL_CATCH_EXCEPTION();
47620   }
47621
47622 }
47623
47624
47625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
47626   void * jresult ;
47627   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47628   Dali::Size result;
47629
47630   arg1 = (Dali::Toolkit::TableView *)jarg1;
47631   {
47632     try {
47633       result = (arg1)->GetCellPadding();
47634     } CALL_CATCH_EXCEPTION(0);
47635   }
47636
47637   jresult = new Dali::Size((const Dali::Size &)result);
47638   return jresult;
47639 }
47640
47641
47642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
47643   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47644   unsigned int arg2 ;
47645
47646   arg1 = (Dali::Toolkit::TableView *)jarg1;
47647   arg2 = (unsigned int)jarg2;
47648   {
47649     try {
47650       (arg1)->SetFitHeight(arg2);
47651     } CALL_CATCH_EXCEPTION();
47652   }
47653
47654 }
47655
47656
47657 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
47658   bool jresult ;
47659   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47660   unsigned int arg2 ;
47661   bool result;
47662
47663   arg1 = (Dali::Toolkit::TableView *)jarg1;
47664   arg2 = (unsigned int)jarg2;
47665   {
47666     try {
47667       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
47668     } CALL_CATCH_EXCEPTION(0);
47669   }
47670
47671   jresult = result;
47672   return jresult;
47673 }
47674
47675
47676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
47677   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47678   unsigned int arg2 ;
47679
47680   arg1 = (Dali::Toolkit::TableView *)jarg1;
47681   arg2 = (unsigned int)jarg2;
47682   {
47683     try {
47684       (arg1)->SetFitWidth(arg2);
47685     } CALL_CATCH_EXCEPTION();
47686   }
47687
47688 }
47689
47690
47691 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
47692   bool jresult ;
47693   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47694   unsigned int arg2 ;
47695   bool result;
47696
47697   arg1 = (Dali::Toolkit::TableView *)jarg1;
47698   arg2 = (unsigned int)jarg2;
47699   {
47700     try {
47701       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
47702     } CALL_CATCH_EXCEPTION(0);
47703   }
47704
47705   jresult = result;
47706   return jresult;
47707 }
47708
47709
47710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
47711   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47712   unsigned int arg2 ;
47713   float arg3 ;
47714
47715   arg1 = (Dali::Toolkit::TableView *)jarg1;
47716   arg2 = (unsigned int)jarg2;
47717   arg3 = (float)jarg3;
47718   {
47719     try {
47720       (arg1)->SetFixedHeight(arg2,arg3);
47721     } CALL_CATCH_EXCEPTION();
47722   }
47723
47724 }
47725
47726
47727 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
47728   float jresult ;
47729   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47730   unsigned int arg2 ;
47731   float result;
47732
47733   arg1 = (Dali::Toolkit::TableView *)jarg1;
47734   arg2 = (unsigned int)jarg2;
47735   {
47736     try {
47737       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
47738     } CALL_CATCH_EXCEPTION(0);
47739   }
47740
47741   jresult = result;
47742   return jresult;
47743 }
47744
47745
47746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
47747   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47748   unsigned int arg2 ;
47749   float arg3 ;
47750
47751   arg1 = (Dali::Toolkit::TableView *)jarg1;
47752   arg2 = (unsigned int)jarg2;
47753   arg3 = (float)jarg3;
47754   {
47755     try {
47756       (arg1)->SetRelativeHeight(arg2,arg3);
47757     } CALL_CATCH_EXCEPTION();
47758   }
47759
47760 }
47761
47762
47763 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
47764   float jresult ;
47765   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47766   unsigned int arg2 ;
47767   float result;
47768
47769   arg1 = (Dali::Toolkit::TableView *)jarg1;
47770   arg2 = (unsigned int)jarg2;
47771   {
47772     try {
47773       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
47774     } CALL_CATCH_EXCEPTION(0);
47775   }
47776
47777   jresult = result;
47778   return jresult;
47779 }
47780
47781
47782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
47783   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47784   unsigned int arg2 ;
47785   float arg3 ;
47786
47787   arg1 = (Dali::Toolkit::TableView *)jarg1;
47788   arg2 = (unsigned int)jarg2;
47789   arg3 = (float)jarg3;
47790   {
47791     try {
47792       (arg1)->SetFixedWidth(arg2,arg3);
47793     } CALL_CATCH_EXCEPTION();
47794   }
47795
47796 }
47797
47798
47799 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
47800   float jresult ;
47801   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47802   unsigned int arg2 ;
47803   float result;
47804
47805   arg1 = (Dali::Toolkit::TableView *)jarg1;
47806   arg2 = (unsigned int)jarg2;
47807   {
47808     try {
47809       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
47810     } CALL_CATCH_EXCEPTION(0);
47811   }
47812
47813   jresult = result;
47814   return jresult;
47815 }
47816
47817
47818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
47819   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47820   unsigned int arg2 ;
47821   float arg3 ;
47822
47823   arg1 = (Dali::Toolkit::TableView *)jarg1;
47824   arg2 = (unsigned int)jarg2;
47825   arg3 = (float)jarg3;
47826   {
47827     try {
47828       (arg1)->SetRelativeWidth(arg2,arg3);
47829     } CALL_CATCH_EXCEPTION();
47830   }
47831
47832 }
47833
47834
47835 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
47836   float jresult ;
47837   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47838   unsigned int arg2 ;
47839   float result;
47840
47841   arg1 = (Dali::Toolkit::TableView *)jarg1;
47842   arg2 = (unsigned int)jarg2;
47843   {
47844     try {
47845       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
47846     } CALL_CATCH_EXCEPTION(0);
47847   }
47848
47849   jresult = result;
47850   return jresult;
47851 }
47852
47853
47854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
47855   unsigned int jresult ;
47856   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47857   unsigned int result;
47858
47859   arg1 = (Dali::Toolkit::TableView *)jarg1;
47860   {
47861     try {
47862       result = (unsigned int)(arg1)->GetRows();
47863     } CALL_CATCH_EXCEPTION(0);
47864   }
47865
47866   jresult = result;
47867   return jresult;
47868 }
47869
47870
47871 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
47872   unsigned int jresult ;
47873   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47874   unsigned int result;
47875
47876   arg1 = (Dali::Toolkit::TableView *)jarg1;
47877   {
47878     try {
47879       result = (unsigned int)(arg1)->GetColumns();
47880     } CALL_CATCH_EXCEPTION(0);
47881   }
47882
47883   jresult = result;
47884   return jresult;
47885 }
47886
47887
47888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
47889   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47890   Dali::Toolkit::TableView::CellPosition arg2 ;
47891   Dali::HorizontalAlignment::Type arg3 ;
47892   Dali::VerticalAlignment::Type arg4 ;
47893   Dali::Toolkit::TableView::CellPosition *argp2 ;
47894
47895   arg1 = (Dali::Toolkit::TableView *)jarg1;
47896   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
47897   if (!argp2) {
47898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
47899     return ;
47900   }
47901   arg2 = *argp2;
47902   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
47903   arg4 = (Dali::VerticalAlignment::Type)jarg4;
47904   {
47905     try {
47906       (arg1)->SetCellAlignment(arg2,arg3,arg4);
47907     } CALL_CATCH_EXCEPTION();
47908   }
47909
47910 }
47911
47912
47913 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
47914   unsigned int jresult ;
47915   unsigned int result;
47916
47917   result = (unsigned int)(unsigned int)Dali::Toolkit::DevelText::DEFAULT_RENDERING_BACKEND;
47918   jresult = result;
47919   return jresult;
47920 }
47921
47922
47923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
47924   int jresult ;
47925   int result;
47926
47927   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
47928   jresult = (int)result;
47929   return jresult;
47930 }
47931
47932
47933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
47934   int jresult ;
47935   int result;
47936
47937   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
47938   jresult = (int)result;
47939   return jresult;
47940 }
47941
47942
47943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
47944   int jresult ;
47945   int result;
47946
47947   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
47948   jresult = (int)result;
47949   return jresult;
47950 }
47951
47952
47953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
47954   int jresult ;
47955   int result;
47956
47957   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
47958   jresult = (int)result;
47959   return jresult;
47960 }
47961
47962
47963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
47964   int jresult ;
47965   int result;
47966
47967   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
47968   jresult = (int)result;
47969   return jresult;
47970 }
47971
47972
47973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
47974   int jresult ;
47975   int result;
47976
47977   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
47978   jresult = (int)result;
47979   return jresult;
47980 }
47981
47982
47983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
47984   int jresult ;
47985   int result;
47986
47987   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
47988   jresult = (int)result;
47989   return jresult;
47990 }
47991
47992
47993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
47994   int jresult ;
47995   int result;
47996
47997   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
47998   jresult = (int)result;
47999   return jresult;
48000 }
48001
48002
48003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
48004   int jresult ;
48005   int result;
48006
48007   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
48008   jresult = (int)result;
48009   return jresult;
48010 }
48011
48012
48013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
48014   int jresult ;
48015   int result;
48016
48017   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
48018   jresult = (int)result;
48019   return jresult;
48020 }
48021
48022
48023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
48024   int jresult ;
48025   int result;
48026
48027   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
48028   jresult = (int)result;
48029   return jresult;
48030 }
48031
48032
48033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
48034   int jresult ;
48035   int result;
48036
48037   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
48038   jresult = (int)result;
48039   return jresult;
48040 }
48041
48042
48043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
48044   int jresult ;
48045   int result;
48046
48047   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
48048   jresult = (int)result;
48049   return jresult;
48050 }
48051
48052
48053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
48054   int jresult ;
48055   int result;
48056
48057   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
48058   jresult = (int)result;
48059   return jresult;
48060 }
48061
48062
48063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
48064   int jresult ;
48065   int result;
48066
48067   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
48068   jresult = (int)result;
48069   return jresult;
48070 }
48071
48072
48073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
48074   int jresult ;
48075   int result;
48076
48077   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
48078   jresult = (int)result;
48079   return jresult;
48080 }
48081
48082
48083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
48084   int jresult ;
48085   int result;
48086
48087   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
48088   jresult = (int)result;
48089   return jresult;
48090 }
48091
48092
48093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
48094   int jresult ;
48095   int result;
48096
48097   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
48098   jresult = (int)result;
48099   return jresult;
48100 }
48101
48102
48103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
48104   void * jresult ;
48105   Dali::Toolkit::TextLabel::Property *result = 0 ;
48106
48107   {
48108     try {
48109       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
48110     } CALL_CATCH_EXCEPTION(0);
48111   }
48112
48113   jresult = (void *)result;
48114   return jresult;
48115 }
48116
48117
48118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
48119   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
48120
48121   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
48122   {
48123     try {
48124       delete arg1;
48125     } CALL_CATCH_EXCEPTION();
48126   }
48127
48128 }
48129
48130
48131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
48132   void * jresult ;
48133   Dali::Toolkit::TextLabel result;
48134
48135   {
48136     try {
48137       result = Dali::Toolkit::TextLabel::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
48138     } CALL_CATCH_EXCEPTION(0);
48139   }
48140
48141   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
48142   return jresult;
48143 }
48144
48145
48146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
48147   void * jresult ;
48148   std::string *arg1 = 0 ;
48149   Dali::Toolkit::TextLabel result;
48150
48151   if (!jarg1) {
48152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48153     return 0;
48154   }
48155   std::string arg1_str(jarg1);
48156   arg1 = &arg1_str;
48157   {
48158     try {
48159       result = Dali::Toolkit::TextLabel::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS, (std::string const &)*arg1);
48160     } CALL_CATCH_EXCEPTION(0);
48161   }
48162
48163   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
48164
48165   //argout typemap for const std::string&
48166
48167   return jresult;
48168 }
48169
48170
48171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
48172   void * jresult ;
48173   Dali::Toolkit::TextLabel *result = 0 ;
48174
48175   {
48176     try {
48177       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
48178     } CALL_CATCH_EXCEPTION(0);
48179   }
48180
48181   jresult = (void *)result;
48182   return jresult;
48183 }
48184
48185
48186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
48187   void * jresult ;
48188   Dali::Toolkit::TextLabel *arg1 = 0 ;
48189   Dali::Toolkit::TextLabel *result = 0 ;
48190
48191   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
48192   if (!arg1) {
48193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
48194     return 0;
48195   }
48196   {
48197     try {
48198       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
48199     } CALL_CATCH_EXCEPTION(0);
48200   }
48201
48202   jresult = (void *)result;
48203   return jresult;
48204 }
48205
48206
48207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
48208   void * jresult ;
48209   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
48210   Dali::Toolkit::TextLabel *arg2 = 0 ;
48211   Dali::Toolkit::TextLabel *result = 0 ;
48212
48213   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
48214   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
48215   if (!arg2) {
48216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
48217     return 0;
48218   }
48219   {
48220     try {
48221       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
48222     } CALL_CATCH_EXCEPTION(0);
48223   }
48224
48225   jresult = (void *)result;
48226   return jresult;
48227 }
48228
48229
48230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
48231   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
48232
48233   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
48234   {
48235     try {
48236       delete arg1;
48237     } CALL_CATCH_EXCEPTION();
48238   }
48239
48240 }
48241
48242
48243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
48244   void * jresult ;
48245   Dali::BaseHandle arg1 ;
48246   Dali::BaseHandle *argp1 ;
48247   Dali::Toolkit::TextLabel result;
48248
48249   argp1 = (Dali::BaseHandle *)jarg1;
48250   if (!argp1) {
48251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48252     return 0;
48253   }
48254   arg1 = *argp1;
48255   {
48256     try {
48257       result = Dali::Toolkit::TextLabel::DownCast(arg1);
48258     } CALL_CATCH_EXCEPTION(0);
48259   }
48260
48261   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
48262   return jresult;
48263 }
48264
48265
48266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
48267   void * jresult ;
48268   Dali::Toolkit::AccessibilityManager *result = 0 ;
48269
48270   {
48271     try {
48272       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
48273     } CALL_CATCH_EXCEPTION(0);
48274   }
48275
48276   jresult = (void *)result;
48277   return jresult;
48278 }
48279
48280
48281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
48282   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48283
48284   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48285   {
48286     try {
48287       delete arg1;
48288     } CALL_CATCH_EXCEPTION();
48289   }
48290
48291 }
48292
48293
48294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
48295   void * jresult ;
48296   Dali::Toolkit::AccessibilityManager result;
48297
48298   {
48299     try {
48300       result = Dali::Toolkit::AccessibilityManager::Get();
48301     } CALL_CATCH_EXCEPTION(0);
48302   }
48303
48304   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
48305   return jresult;
48306 }
48307
48308
48309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
48310   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48311   Dali::Actor arg2 ;
48312   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
48313   std::string *arg4 = 0 ;
48314   Dali::Actor *argp2 ;
48315
48316   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48317   argp2 = (Dali::Actor *)jarg2;
48318   if (!argp2) {
48319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48320     return ;
48321   }
48322   arg2 = *argp2;
48323   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
48324   if (!jarg4) {
48325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48326     return ;
48327   }
48328   std::string arg4_str(jarg4);
48329   arg4 = &arg4_str;
48330   {
48331     try {
48332       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
48333     } CALL_CATCH_EXCEPTION();
48334   }
48335
48336
48337   //argout typemap for const std::string&
48338
48339 }
48340
48341
48342 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
48343   char * jresult ;
48344   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48345   Dali::Actor arg2 ;
48346   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
48347   Dali::Actor *argp2 ;
48348   std::string result;
48349
48350   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48351   argp2 = (Dali::Actor *)jarg2;
48352   if (!argp2) {
48353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48354     return 0;
48355   }
48356   arg2 = *argp2;
48357   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
48358   {
48359     try {
48360       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
48361     } CALL_CATCH_EXCEPTION(0);
48362   }
48363
48364   jresult = SWIG_csharp_string_callback((&result)->c_str());
48365   return jresult;
48366 }
48367
48368
48369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
48370   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48371   Dali::Actor arg2 ;
48372   unsigned int arg3 ;
48373   Dali::Actor *argp2 ;
48374
48375   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48376   argp2 = (Dali::Actor *)jarg2;
48377   if (!argp2) {
48378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48379     return ;
48380   }
48381   arg2 = *argp2;
48382   arg3 = (unsigned int)jarg3;
48383   {
48384     try {
48385       (arg1)->SetFocusOrder(arg2,arg3);
48386     } CALL_CATCH_EXCEPTION();
48387   }
48388
48389 }
48390
48391
48392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
48393   unsigned int jresult ;
48394   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48395   Dali::Actor arg2 ;
48396   Dali::Actor *argp2 ;
48397   unsigned int result;
48398
48399   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48400   argp2 = (Dali::Actor *)jarg2;
48401   if (!argp2) {
48402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48403     return 0;
48404   }
48405   arg2 = *argp2;
48406   {
48407     try {
48408       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
48409     } CALL_CATCH_EXCEPTION(0);
48410   }
48411
48412   jresult = result;
48413   return jresult;
48414 }
48415
48416
48417 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
48418   unsigned int jresult ;
48419   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48420   unsigned int result;
48421
48422   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48423   {
48424     try {
48425       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
48426     } CALL_CATCH_EXCEPTION(0);
48427   }
48428
48429   jresult = result;
48430   return jresult;
48431 }
48432
48433
48434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
48435   void * jresult ;
48436   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48437   unsigned int arg2 ;
48438   Dali::Actor result;
48439
48440   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48441   arg2 = (unsigned int)jarg2;
48442   {
48443     try {
48444       result = (arg1)->GetActorByFocusOrder(arg2);
48445     } CALL_CATCH_EXCEPTION(0);
48446   }
48447
48448   jresult = new Dali::Actor((const Dali::Actor &)result);
48449   return jresult;
48450 }
48451
48452
48453 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
48454   bool jresult ;
48455   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48456   Dali::Actor arg2 ;
48457   Dali::Actor *argp2 ;
48458   bool result;
48459
48460   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48461   argp2 = (Dali::Actor *)jarg2;
48462   if (!argp2) {
48463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48464     return 0;
48465   }
48466   arg2 = *argp2;
48467   {
48468     try {
48469       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
48470     } CALL_CATCH_EXCEPTION(0);
48471   }
48472
48473   jresult = result;
48474   return jresult;
48475 }
48476
48477
48478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
48479   void * jresult ;
48480   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48481   Dali::Actor result;
48482
48483   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48484   {
48485     try {
48486       result = (arg1)->GetCurrentFocusActor();
48487     } CALL_CATCH_EXCEPTION(0);
48488   }
48489
48490   jresult = new Dali::Actor((const Dali::Actor &)result);
48491   return jresult;
48492 }
48493
48494
48495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
48496   void * jresult ;
48497   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48498   Dali::Actor result;
48499
48500   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48501   {
48502     try {
48503       result = (arg1)->GetCurrentFocusGroup();
48504     } CALL_CATCH_EXCEPTION(0);
48505   }
48506
48507   jresult = new Dali::Actor((const Dali::Actor &)result);
48508   return jresult;
48509 }
48510
48511
48512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
48513   unsigned int jresult ;
48514   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48515   unsigned int result;
48516
48517   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48518   {
48519     try {
48520       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
48521     } CALL_CATCH_EXCEPTION(0);
48522   }
48523
48524   jresult = result;
48525   return jresult;
48526 }
48527
48528
48529 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
48530   bool jresult ;
48531   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48532   bool result;
48533
48534   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48535   {
48536     try {
48537       result = (bool)(arg1)->MoveFocusForward();
48538     } CALL_CATCH_EXCEPTION(0);
48539   }
48540
48541   jresult = result;
48542   return jresult;
48543 }
48544
48545
48546 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
48547   bool jresult ;
48548   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48549   bool result;
48550
48551   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48552   {
48553     try {
48554       result = (bool)(arg1)->MoveFocusBackward();
48555     } CALL_CATCH_EXCEPTION(0);
48556   }
48557
48558   jresult = result;
48559   return jresult;
48560 }
48561
48562
48563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
48564   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48565
48566   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48567   {
48568     try {
48569       (arg1)->ClearFocus();
48570     } CALL_CATCH_EXCEPTION();
48571   }
48572
48573 }
48574
48575
48576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
48577   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48578
48579   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48580   {
48581     try {
48582       (arg1)->Reset();
48583     } CALL_CATCH_EXCEPTION();
48584   }
48585
48586 }
48587
48588
48589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, bool jarg3) {
48590   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48591   Dali::Actor arg2 ;
48592   bool arg3 ;
48593   Dali::Actor *argp2 ;
48594
48595   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48596   argp2 = (Dali::Actor *)jarg2;
48597   if (!argp2) {
48598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48599     return ;
48600   }
48601   arg2 = *argp2;
48602   arg3 = jarg3 ? true : false;
48603   {
48604     try {
48605       (arg1)->SetFocusGroup(arg2,arg3);
48606     } CALL_CATCH_EXCEPTION();
48607   }
48608
48609 }
48610
48611
48612 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
48613   bool jresult ;
48614   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48615   Dali::Actor arg2 ;
48616   Dali::Actor *argp2 ;
48617   bool result;
48618
48619   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48620   argp2 = (Dali::Actor *)jarg2;
48621   if (!argp2) {
48622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48623     return 0;
48624   }
48625   arg2 = *argp2;
48626   {
48627     try {
48628       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
48629     } CALL_CATCH_EXCEPTION(0);
48630   }
48631
48632   jresult = result;
48633   return jresult;
48634 }
48635
48636
48637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, bool jarg2) {
48638   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48639   bool arg2 ;
48640
48641   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48642   arg2 = jarg2 ? true : false;
48643   {
48644     try {
48645       (arg1)->SetGroupMode(arg2);
48646     } CALL_CATCH_EXCEPTION();
48647   }
48648
48649 }
48650
48651
48652 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
48653   bool jresult ;
48654   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48655   bool result;
48656
48657   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48658   {
48659     try {
48660       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
48661     } CALL_CATCH_EXCEPTION(0);
48662   }
48663
48664   jresult = result;
48665   return jresult;
48666 }
48667
48668
48669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, bool jarg2) {
48670   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48671   bool arg2 ;
48672
48673   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48674   arg2 = jarg2 ? true : false;
48675   {
48676     try {
48677       (arg1)->SetWrapMode(arg2);
48678     } CALL_CATCH_EXCEPTION();
48679   }
48680
48681 }
48682
48683
48684 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
48685   bool jresult ;
48686   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48687   bool result;
48688
48689   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48690   {
48691     try {
48692       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
48693     } CALL_CATCH_EXCEPTION(0);
48694   }
48695
48696   jresult = result;
48697   return jresult;
48698 }
48699
48700
48701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
48702   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48703   Dali::Actor arg2 ;
48704   Dali::Actor *argp2 ;
48705
48706   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48707   argp2 = (Dali::Actor *)jarg2;
48708   if (!argp2) {
48709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48710     return ;
48711   }
48712   arg2 = *argp2;
48713   {
48714     try {
48715       (arg1)->SetFocusIndicatorActor(arg2);
48716     } CALL_CATCH_EXCEPTION();
48717   }
48718
48719 }
48720
48721
48722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
48723   void * jresult ;
48724   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48725   Dali::Actor result;
48726
48727   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48728   {
48729     try {
48730       result = (arg1)->GetFocusIndicatorActor();
48731     } CALL_CATCH_EXCEPTION(0);
48732   }
48733
48734   jresult = new Dali::Actor((const Dali::Actor &)result);
48735   return jresult;
48736 }
48737
48738
48739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
48740   void * jresult ;
48741   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48742   Dali::Actor arg2 ;
48743   Dali::Actor *argp2 ;
48744   Dali::Actor result;
48745
48746   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48747   argp2 = (Dali::Actor *)jarg2;
48748   if (!argp2) {
48749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48750     return 0;
48751   }
48752   arg2 = *argp2;
48753   {
48754     try {
48755       result = (arg1)->GetFocusGroup(arg2);
48756     } CALL_CATCH_EXCEPTION(0);
48757   }
48758
48759   jresult = new Dali::Actor((const Dali::Actor &)result);
48760   return jresult;
48761 }
48762
48763
48764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
48765   void * jresult ;
48766   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48767   Dali::Vector2 result;
48768
48769   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48770   {
48771     try {
48772       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
48773     } CALL_CATCH_EXCEPTION(0);
48774   }
48775
48776   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
48777   return jresult;
48778 }
48779
48780
48781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
48782   void * jresult ;
48783   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48784   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
48785
48786   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48787   {
48788     try {
48789       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
48790     } CALL_CATCH_EXCEPTION(0);
48791   }
48792
48793   jresult = (void *)result;
48794   return jresult;
48795 }
48796
48797
48798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
48799   void * jresult ;
48800   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48801   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
48802
48803   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48804   {
48805     try {
48806       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
48807     } CALL_CATCH_EXCEPTION(0);
48808   }
48809
48810   jresult = (void *)result;
48811   return jresult;
48812 }
48813
48814
48815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
48816   void * jresult ;
48817   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48818   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
48819
48820   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48821   {
48822     try {
48823       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
48824     } CALL_CATCH_EXCEPTION(0);
48825   }
48826
48827   jresult = (void *)result;
48828   return jresult;
48829 }
48830
48831
48832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
48833   void * jresult ;
48834   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48835   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48836
48837   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48838   {
48839     try {
48840       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
48841     } CALL_CATCH_EXCEPTION(0);
48842   }
48843
48844   jresult = (void *)result;
48845   return jresult;
48846 }
48847
48848
48849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
48850   void * jresult ;
48851   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48852   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48853
48854   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48855   {
48856     try {
48857       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
48858     } CALL_CATCH_EXCEPTION(0);
48859   }
48860
48861   jresult = (void *)result;
48862   return jresult;
48863 }
48864
48865
48866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
48867   void * jresult ;
48868   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48869   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48870
48871   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48872   {
48873     try {
48874       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
48875     } CALL_CATCH_EXCEPTION(0);
48876   }
48877
48878   jresult = (void *)result;
48879   return jresult;
48880 }
48881
48882
48883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
48884   void * jresult ;
48885   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48886   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48887
48888   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48889   {
48890     try {
48891       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
48892     } CALL_CATCH_EXCEPTION(0);
48893   }
48894
48895   jresult = (void *)result;
48896   return jresult;
48897 }
48898
48899
48900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
48901   void * jresult ;
48902   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48903   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48904
48905   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48906   {
48907     try {
48908       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
48909     } CALL_CATCH_EXCEPTION(0);
48910   }
48911
48912   jresult = (void *)result;
48913   return jresult;
48914 }
48915
48916
48917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
48918   void * jresult ;
48919   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48920   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48921
48922   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48923   {
48924     try {
48925       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
48926     } CALL_CATCH_EXCEPTION(0);
48927   }
48928
48929   jresult = (void *)result;
48930   return jresult;
48931 }
48932
48933
48934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
48935   void * jresult ;
48936   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48937   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48938
48939   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48940   {
48941     try {
48942       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
48943     } CALL_CATCH_EXCEPTION(0);
48944   }
48945
48946   jresult = (void *)result;
48947   return jresult;
48948 }
48949
48950
48951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
48952   void * jresult ;
48953   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48954   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48955
48956   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48957   {
48958     try {
48959       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
48960     } CALL_CATCH_EXCEPTION(0);
48961   }
48962
48963   jresult = (void *)result;
48964   return jresult;
48965 }
48966
48967
48968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
48969   void * jresult ;
48970   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48971   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48972
48973   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48974   {
48975     try {
48976       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
48977     } CALL_CATCH_EXCEPTION(0);
48978   }
48979
48980   jresult = (void *)result;
48981   return jresult;
48982 }
48983
48984
48985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
48986   void * jresult ;
48987   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48988   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48989
48990   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48991   {
48992     try {
48993       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
48994     } CALL_CATCH_EXCEPTION(0);
48995   }
48996
48997   jresult = (void *)result;
48998   return jresult;
48999 }
49000
49001
49002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
49003   void * jresult ;
49004   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49005   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49006
49007   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49008   {
49009     try {
49010       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
49011     } CALL_CATCH_EXCEPTION(0);
49012   }
49013
49014   jresult = (void *)result;
49015   return jresult;
49016 }
49017
49018
49019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
49020   void * jresult ;
49021   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49022   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49023
49024   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49025   {
49026     try {
49027       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
49028     } CALL_CATCH_EXCEPTION(0);
49029   }
49030
49031   jresult = (void *)result;
49032   return jresult;
49033 }
49034
49035
49036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
49037   void * jresult ;
49038   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49039   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49040
49041   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49042   {
49043     try {
49044       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
49045     } CALL_CATCH_EXCEPTION(0);
49046   }
49047
49048   jresult = (void *)result;
49049   return jresult;
49050 }
49051
49052
49053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
49054   void * jresult ;
49055   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49056   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49057
49058   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49059   {
49060     try {
49061       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
49062     } CALL_CATCH_EXCEPTION(0);
49063   }
49064
49065   jresult = (void *)result;
49066   return jresult;
49067 }
49068
49069
49070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
49071   void * jresult ;
49072   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49073   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49074
49075   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49076   {
49077     try {
49078       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
49079     } CALL_CATCH_EXCEPTION(0);
49080   }
49081
49082   jresult = (void *)result;
49083   return jresult;
49084 }
49085
49086
49087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
49088   void * jresult ;
49089   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49090   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49091
49092   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49093   {
49094     try {
49095       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
49096     } CALL_CATCH_EXCEPTION(0);
49097   }
49098
49099   jresult = (void *)result;
49100   return jresult;
49101 }
49102
49103
49104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
49105   void * jresult ;
49106   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49107   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49108
49109   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49110   {
49111     try {
49112       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
49113     } CALL_CATCH_EXCEPTION(0);
49114   }
49115
49116   jresult = (void *)result;
49117   return jresult;
49118 }
49119
49120
49121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
49122   void * jresult ;
49123   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49124   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49125
49126   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49127   {
49128     try {
49129       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
49130     } CALL_CATCH_EXCEPTION(0);
49131   }
49132
49133   jresult = (void *)result;
49134   return jresult;
49135 }
49136
49137
49138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
49139   void * jresult ;
49140   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49141   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49142
49143   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49144   {
49145     try {
49146       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
49147     } CALL_CATCH_EXCEPTION(0);
49148   }
49149
49150   jresult = (void *)result;
49151   return jresult;
49152 }
49153
49154
49155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
49156   void * jresult ;
49157   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49158   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49159
49160   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49161   {
49162     try {
49163       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
49164     } CALL_CATCH_EXCEPTION(0);
49165   }
49166
49167   jresult = (void *)result;
49168   return jresult;
49169 }
49170
49171
49172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
49173   void * jresult ;
49174   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49175   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49176
49177   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49178   {
49179     try {
49180       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
49181     } CALL_CATCH_EXCEPTION(0);
49182   }
49183
49184   jresult = (void *)result;
49185   return jresult;
49186 }
49187
49188
49189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
49190   void * jresult ;
49191   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49192   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49193
49194   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49195   {
49196     try {
49197       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
49198     } CALL_CATCH_EXCEPTION(0);
49199   }
49200
49201   jresult = (void *)result;
49202   return jresult;
49203 }
49204
49205
49206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
49207   void * jresult ;
49208   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49209   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49210
49211   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49212   {
49213     try {
49214       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
49215     } CALL_CATCH_EXCEPTION(0);
49216   }
49217
49218   jresult = (void *)result;
49219   return jresult;
49220 }
49221
49222
49223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
49224   void * jresult ;
49225   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49226   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49227
49228   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49229   {
49230     try {
49231       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
49232     } CALL_CATCH_EXCEPTION(0);
49233   }
49234
49235   jresult = (void *)result;
49236   return jresult;
49237 }
49238
49239
49240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
49241   void * jresult ;
49242   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49243   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49244
49245   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49246   {
49247     try {
49248       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
49249     } CALL_CATCH_EXCEPTION(0);
49250   }
49251
49252   jresult = (void *)result;
49253   return jresult;
49254 }
49255
49256
49257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
49258   void * jresult ;
49259   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49260   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
49261
49262   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49263   {
49264     try {
49265       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
49266     } CALL_CATCH_EXCEPTION(0);
49267   }
49268
49269   jresult = (void *)result;
49270   return jresult;
49271 }
49272
49273
49274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
49275   void * jresult ;
49276   Dali::Toolkit::StyleManager *result = 0 ;
49277
49278   {
49279     try {
49280       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
49281     } CALL_CATCH_EXCEPTION(0);
49282   }
49283
49284   jresult = (void *)result;
49285   return jresult;
49286 }
49287
49288
49289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
49290   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
49291
49292   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
49293   {
49294     try {
49295       delete arg1;
49296     } CALL_CATCH_EXCEPTION();
49297   }
49298
49299 }
49300
49301
49302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
49303   void * jresult ;
49304   Dali::Toolkit::StyleManager result;
49305
49306   {
49307     try {
49308       result = Dali::Toolkit::StyleManager::Get();
49309     } CALL_CATCH_EXCEPTION(0);
49310   }
49311
49312   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
49313   return jresult;
49314 }
49315
49316
49317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
49318   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
49319   std::string *arg2 = 0 ;
49320
49321   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
49322   if (!jarg2) {
49323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49324     return ;
49325   }
49326   std::string arg2_str(jarg2);
49327   arg2 = &arg2_str;
49328   {
49329     try {
49330       (arg1)->ApplyTheme((std::string const &)*arg2);
49331     } CALL_CATCH_EXCEPTION();
49332   }
49333
49334
49335   //argout typemap for const std::string&
49336
49337 }
49338
49339
49340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
49341   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
49342
49343   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
49344   {
49345     try {
49346       (arg1)->ApplyDefaultTheme();
49347     } CALL_CATCH_EXCEPTION();
49348   }
49349
49350 }
49351
49352
49353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
49354   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
49355   std::string *arg2 = 0 ;
49356   Dali::Property::Value *arg3 = 0 ;
49357
49358   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
49359   if (!jarg2) {
49360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49361     return ;
49362   }
49363   std::string arg2_str(jarg2);
49364   arg2 = &arg2_str;
49365   arg3 = (Dali::Property::Value *)jarg3;
49366   if (!arg3) {
49367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
49368     return ;
49369   }
49370   {
49371     try {
49372       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
49373     } CALL_CATCH_EXCEPTION();
49374   }
49375
49376
49377   //argout typemap for const std::string&
49378
49379 }
49380
49381
49382 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
49383   bool jresult ;
49384   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
49385   std::string *arg2 = 0 ;
49386   Dali::Property::Value *arg3 = 0 ;
49387   bool result;
49388
49389   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
49390   if (!jarg2) {
49391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49392     return 0;
49393   }
49394   std::string arg2_str(jarg2);
49395   arg2 = &arg2_str;
49396   arg3 = (Dali::Property::Value *)jarg3;
49397   if (!arg3) {
49398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
49399     return 0;
49400   }
49401   {
49402     try {
49403       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
49404     } CALL_CATCH_EXCEPTION(0);
49405   }
49406
49407   jresult = result;
49408
49409   //argout typemap for const std::string&
49410
49411   return jresult;
49412 }
49413
49414
49415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
49416   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
49417   Dali::Toolkit::Control arg2 ;
49418   std::string *arg3 = 0 ;
49419   std::string *arg4 = 0 ;
49420   Dali::Toolkit::Control *argp2 ;
49421
49422   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
49423   argp2 = (Dali::Toolkit::Control *)jarg2;
49424   if (!argp2) {
49425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
49426     return ;
49427   }
49428   arg2 = *argp2;
49429   if (!jarg3) {
49430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49431     return ;
49432   }
49433   std::string arg3_str(jarg3);
49434   arg3 = &arg3_str;
49435   if (!jarg4) {
49436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49437     return ;
49438   }
49439   std::string arg4_str(jarg4);
49440   arg4 = &arg4_str;
49441   {
49442     try {
49443       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
49444     } CALL_CATCH_EXCEPTION();
49445   }
49446
49447
49448   //argout typemap for const std::string&
49449
49450
49451   //argout typemap for const std::string&
49452
49453 }
49454
49455
49456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
49457   void * jresult ;
49458   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
49459   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
49460
49461   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
49462   {
49463     try {
49464       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
49465     } CALL_CATCH_EXCEPTION(0);
49466   }
49467
49468   jresult = (void *)result;
49469   return jresult;
49470 }
49471
49472
49473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
49474   int jresult ;
49475   int result;
49476
49477   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
49478   jresult = (int)result;
49479   return jresult;
49480 }
49481
49482
49483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
49484   int jresult ;
49485   int result;
49486
49487   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
49488   jresult = (int)result;
49489   return jresult;
49490 }
49491
49492
49493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
49494   int jresult ;
49495   int result;
49496
49497   result = (int)Dali::Toolkit::Slider::Property::VALUE;
49498   jresult = (int)result;
49499   return jresult;
49500 }
49501
49502
49503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
49504   int jresult ;
49505   int result;
49506
49507   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
49508   jresult = (int)result;
49509   return jresult;
49510 }
49511
49512
49513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
49514   int jresult ;
49515   int result;
49516
49517   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
49518   jresult = (int)result;
49519   return jresult;
49520 }
49521
49522
49523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
49524   int jresult ;
49525   int result;
49526
49527   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
49528   jresult = (int)result;
49529   return jresult;
49530 }
49531
49532
49533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
49534   int jresult ;
49535   int result;
49536
49537   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
49538   jresult = (int)result;
49539   return jresult;
49540 }
49541
49542
49543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
49544   int jresult ;
49545   int result;
49546
49547   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
49548   jresult = (int)result;
49549   return jresult;
49550 }
49551
49552
49553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
49554   int jresult ;
49555   int result;
49556
49557   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
49558   jresult = (int)result;
49559   return jresult;
49560 }
49561
49562
49563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
49564   int jresult ;
49565   int result;
49566
49567   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
49568   jresult = (int)result;
49569   return jresult;
49570 }
49571
49572
49573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
49574   int jresult ;
49575   int result;
49576
49577   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
49578   jresult = (int)result;
49579   return jresult;
49580 }
49581
49582
49583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
49584   int jresult ;
49585   int result;
49586
49587   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
49588   jresult = (int)result;
49589   return jresult;
49590 }
49591
49592
49593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
49594   int jresult ;
49595   int result;
49596
49597   result = (int)Dali::Toolkit::Slider::Property::MARKS;
49598   jresult = (int)result;
49599   return jresult;
49600 }
49601
49602
49603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
49604   int jresult ;
49605   int result;
49606
49607   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
49608   jresult = (int)result;
49609   return jresult;
49610 }
49611
49612
49613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
49614   int jresult ;
49615   int result;
49616
49617   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
49618   jresult = (int)result;
49619   return jresult;
49620 }
49621
49622
49623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
49624   void * jresult ;
49625   Dali::Toolkit::Slider::Property *result = 0 ;
49626
49627   {
49628     try {
49629       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
49630     } CALL_CATCH_EXCEPTION(0);
49631   }
49632
49633   jresult = (void *)result;
49634   return jresult;
49635 }
49636
49637
49638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
49639   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
49640
49641   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
49642   {
49643     try {
49644       delete arg1;
49645     } CALL_CATCH_EXCEPTION();
49646   }
49647
49648 }
49649
49650
49651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
49652   void * jresult ;
49653   Dali::Toolkit::Slider result;
49654
49655   {
49656     try {
49657       result = Dali::Toolkit::Slider::New();
49658     } CALL_CATCH_EXCEPTION(0);
49659   }
49660
49661   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
49662   return jresult;
49663 }
49664
49665
49666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
49667   void * jresult ;
49668   Dali::Toolkit::Slider *result = 0 ;
49669
49670   {
49671     try {
49672       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
49673     } CALL_CATCH_EXCEPTION(0);
49674   }
49675
49676   jresult = (void *)result;
49677   return jresult;
49678 }
49679
49680
49681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
49682   void * jresult ;
49683   Dali::Toolkit::Slider *arg1 = 0 ;
49684   Dali::Toolkit::Slider *result = 0 ;
49685
49686   arg1 = (Dali::Toolkit::Slider *)jarg1;
49687   if (!arg1) {
49688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
49689     return 0;
49690   }
49691   {
49692     try {
49693       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
49694     } CALL_CATCH_EXCEPTION(0);
49695   }
49696
49697   jresult = (void *)result;
49698   return jresult;
49699 }
49700
49701
49702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
49703   void * jresult ;
49704   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
49705   Dali::Toolkit::Slider *arg2 = 0 ;
49706   Dali::Toolkit::Slider *result = 0 ;
49707
49708   arg1 = (Dali::Toolkit::Slider *)jarg1;
49709   arg2 = (Dali::Toolkit::Slider *)jarg2;
49710   if (!arg2) {
49711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
49712     return 0;
49713   }
49714   {
49715     try {
49716       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
49717     } CALL_CATCH_EXCEPTION(0);
49718   }
49719
49720   jresult = (void *)result;
49721   return jresult;
49722 }
49723
49724
49725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
49726   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
49727
49728   arg1 = (Dali::Toolkit::Slider *)jarg1;
49729   {
49730     try {
49731       delete arg1;
49732     } CALL_CATCH_EXCEPTION();
49733   }
49734
49735 }
49736
49737
49738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
49739   void * jresult ;
49740   Dali::BaseHandle arg1 ;
49741   Dali::BaseHandle *argp1 ;
49742   Dali::Toolkit::Slider result;
49743
49744   argp1 = (Dali::BaseHandle *)jarg1;
49745   if (!argp1) {
49746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49747     return 0;
49748   }
49749   arg1 = *argp1;
49750   {
49751     try {
49752       result = Dali::Toolkit::Slider::DownCast(arg1);
49753     } CALL_CATCH_EXCEPTION(0);
49754   }
49755
49756   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
49757   return jresult;
49758 }
49759
49760
49761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
49762   void * jresult ;
49763   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
49764   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
49765
49766   arg1 = (Dali::Toolkit::Slider *)jarg1;
49767   {
49768     try {
49769       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
49770     } CALL_CATCH_EXCEPTION(0);
49771   }
49772
49773   jresult = (void *)result;
49774   return jresult;
49775 }
49776
49777
49778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
49779   void * jresult ;
49780   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
49781   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
49782
49783   arg1 = (Dali::Toolkit::Slider *)jarg1;
49784   {
49785     try {
49786       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
49787     } CALL_CATCH_EXCEPTION(0);
49788   }
49789
49790   jresult = (void *)result;
49791   return jresult;
49792 }
49793
49794
49795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
49796   void * jresult ;
49797   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
49798   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
49799
49800   arg1 = (Dali::Toolkit::Slider *)jarg1;
49801   {
49802     try {
49803       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
49804     } CALL_CATCH_EXCEPTION(0);
49805   }
49806
49807   jresult = (void *)result;
49808   return jresult;
49809 }
49810
49811
49812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
49813   int jresult ;
49814   int result;
49815
49816   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
49817   jresult = (int)result;
49818   return jresult;
49819 }
49820
49821
49822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
49823   int jresult ;
49824   int result;
49825
49826   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
49827   jresult = (int)result;
49828   return jresult;
49829 }
49830
49831
49832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
49833   int jresult ;
49834   int result;
49835
49836   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
49837   jresult = (int)result;
49838   return jresult;
49839 }
49840
49841
49842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
49843   int jresult ;
49844   int result;
49845
49846   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
49847   jresult = (int)result;
49848   return jresult;
49849 }
49850
49851
49852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
49853   int result;
49854
49855   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
49856
49857   return result;
49858 }
49859
49860
49861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
49862   void * jresult ;
49863   Dali::Toolkit::VideoView::Property *result = 0 ;
49864
49865   {
49866     try {
49867       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
49868     } CALL_CATCH_EXCEPTION(0);
49869   }
49870
49871   jresult = (void *)result;
49872   return jresult;
49873 }
49874
49875
49876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
49877   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
49878
49879   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
49880   {
49881     try {
49882       delete arg1;
49883     } CALL_CATCH_EXCEPTION();
49884   }
49885
49886 }
49887
49888
49889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
49890   void * jresult ;
49891   Dali::Toolkit::VideoView result;
49892
49893   {
49894     try {
49895       result = Dali::Toolkit::VideoView::New();
49896     } CALL_CATCH_EXCEPTION(0);
49897   }
49898
49899   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
49900   return jresult;
49901 }
49902
49903
49904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
49905   void * jresult ;
49906   std::string *arg1 = 0 ;
49907   Dali::Toolkit::VideoView result;
49908
49909   if (!jarg1) {
49910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49911     return 0;
49912   }
49913   std::string arg1_str(jarg1);
49914   arg1 = &arg1_str;
49915   {
49916     try {
49917       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
49918     } CALL_CATCH_EXCEPTION(0);
49919   }
49920
49921   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
49922
49923   //argout typemap for const std::string&
49924
49925   return jresult;
49926 }
49927
49928
49929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
49930   void * jresult ;
49931   Dali::Toolkit::VideoView result;
49932   {
49933     try {
49934       result = Dali::Toolkit::VideoView::New(swCodec);
49935     } CALL_CATCH_EXCEPTION(0);
49936   }
49937
49938   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
49939
49940   //argout typemap for const std::string&
49941
49942   return jresult;
49943 }
49944
49945
49946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
49947   void * jresult ;
49948   std::string *arg1 = 0 ;
49949   Dali::Toolkit::VideoView result;
49950
49951   if (!jarg1) {
49952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49953     return 0;
49954   }
49955   std::string arg1_str(jarg1);
49956   arg1 = &arg1_str;
49957   {
49958     try {
49959       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
49960     } CALL_CATCH_EXCEPTION(0);
49961   }
49962
49963   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
49964
49965   //argout typemap for const std::string&
49966
49967   return jresult;
49968 }
49969
49970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_4(unsigned int jarg1) {
49971   void * jresult ;
49972   Dali::VideoSyncMode syncMode;
49973   Dali::Toolkit::VideoView result;
49974
49975   syncMode = static_cast<Dali::VideoSyncMode>(jarg1);
49976
49977   {
49978     try {
49979       result = Dali::Toolkit::DevelVideoView::New(syncMode);
49980     } CALL_CATCH_EXCEPTION(0);
49981   }
49982
49983   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
49984
49985   return jresult;
49986 }
49987
49988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
49989   void * jresult ;
49990   Dali::Toolkit::VideoView *result = 0 ;
49991
49992   {
49993     try {
49994       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
49995     } CALL_CATCH_EXCEPTION(0);
49996   }
49997
49998   jresult = (void *)result;
49999   return jresult;
50000 }
50001
50002
50003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
50004   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
50005
50006   arg1 = (Dali::Toolkit::VideoView *)jarg1;
50007   {
50008     try {
50009       delete arg1;
50010     } CALL_CATCH_EXCEPTION();
50011   }
50012
50013 }
50014
50015
50016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
50017   void * jresult ;
50018   Dali::Toolkit::VideoView *arg1 = 0 ;
50019   Dali::Toolkit::VideoView *result = 0 ;
50020
50021   arg1 = (Dali::Toolkit::VideoView *)jarg1;
50022   if (!arg1) {
50023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
50024     return 0;
50025   }
50026   {
50027     try {
50028       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
50029     } CALL_CATCH_EXCEPTION(0);
50030   }
50031
50032   jresult = (void *)result;
50033   return jresult;
50034 }
50035
50036
50037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
50038   void * jresult ;
50039   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
50040   Dali::Toolkit::VideoView *arg2 = 0 ;
50041   Dali::Toolkit::VideoView *result = 0 ;
50042
50043   arg1 = (Dali::Toolkit::VideoView *)jarg1;
50044   arg2 = (Dali::Toolkit::VideoView *)jarg2;
50045   if (!arg2) {
50046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
50047     return 0;
50048   }
50049   {
50050     try {
50051       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
50052     } CALL_CATCH_EXCEPTION(0);
50053   }
50054
50055   jresult = (void *)result;
50056   return jresult;
50057 }
50058
50059
50060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
50061   void * jresult ;
50062   Dali::BaseHandle arg1 ;
50063   Dali::BaseHandle *argp1 ;
50064   Dali::Toolkit::VideoView result;
50065
50066   argp1 = (Dali::BaseHandle *)jarg1;
50067   if (!argp1) {
50068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50069     return 0;
50070   }
50071   arg1 = *argp1;
50072   {
50073     try {
50074       result = Dali::Toolkit::VideoView::DownCast(arg1);
50075     } CALL_CATCH_EXCEPTION(0);
50076   }
50077
50078   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
50079   return jresult;
50080 }
50081
50082
50083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
50084   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
50085
50086   arg1 = (Dali::Toolkit::VideoView *)jarg1;
50087   {
50088     try {
50089       (arg1)->Play();
50090     } CALL_CATCH_EXCEPTION();
50091   }
50092
50093 }
50094
50095
50096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
50097   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
50098
50099   arg1 = (Dali::Toolkit::VideoView *)jarg1;
50100   {
50101     try {
50102       (arg1)->Pause();
50103     } CALL_CATCH_EXCEPTION();
50104   }
50105
50106 }
50107
50108
50109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
50110   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
50111
50112   arg1 = (Dali::Toolkit::VideoView *)jarg1;
50113   {
50114     try {
50115       (arg1)->Stop();
50116     } CALL_CATCH_EXCEPTION();
50117   }
50118
50119 }
50120
50121
50122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
50123   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
50124   int arg2 ;
50125
50126   arg1 = (Dali::Toolkit::VideoView *)jarg1;
50127   arg2 = (int)jarg2;
50128   {
50129     try {
50130       (arg1)->Forward(arg2);
50131     } CALL_CATCH_EXCEPTION();
50132   }
50133
50134 }
50135
50136
50137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
50138   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
50139   int arg2 ;
50140
50141   arg1 = (Dali::Toolkit::VideoView *)jarg1;
50142   arg2 = (int)jarg2;
50143   {
50144     try {
50145       (arg1)->Backward(arg2);
50146     } CALL_CATCH_EXCEPTION();
50147   }
50148
50149 }
50150
50151
50152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
50153   void * jresult ;
50154   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
50155   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
50156
50157   arg1 = (Dali::Toolkit::VideoView *)jarg1;
50158   {
50159     try {
50160       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
50161     } CALL_CATCH_EXCEPTION(0);
50162   }
50163
50164   jresult = (void *)result;
50165   return jresult;
50166 }
50167
50168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle(void * jarg1)
50169 {
50170   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
50171   if( arg1 == nullptr )
50172   {
50173     DALI_LOG_ERROR("VideoView is nullptr!");
50174     return nullptr;
50175   }
50176   void * ret = nullptr;
50177   {
50178     try{
50179
50180       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
50181       ret = Dali::AnyCast< void * >( result );
50182
50183     } CALL_CATCH_EXCEPTION(0);
50184   }
50185   return ret;
50186 }
50187
50188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraView_New__SWIG_0(void * jarg1, int jarg2) {
50189   void * jresult ;
50190   Dali::Toolkit::CameraView result;
50191
50192   Dali::Any arg1(jarg1);
50193   Dali::Toolkit::CameraView::DisplayType arg2 = static_cast<Dali::Toolkit::CameraView::DisplayType>(jarg2);
50194   {
50195     try {
50196       result = Dali::Toolkit::CameraView::New(arg1, arg2);
50197     } CALL_CATCH_EXCEPTION(0);
50198   }
50199
50200   jresult = new Dali::Toolkit::CameraView((const Dali::Toolkit::CameraView &)result);
50201   return jresult;
50202 }
50203
50204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraView__SWIG_0() {
50205   void * jresult ;
50206   Dali::Toolkit::CameraView *result = 0 ;
50207
50208   {
50209     try {
50210       result = (Dali::Toolkit::CameraView *)new Dali::Toolkit::CameraView();
50211     } CALL_CATCH_EXCEPTION(0);
50212   }
50213
50214   jresult = (void *)result;
50215   return jresult;
50216 }
50217
50218
50219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraView(void * jarg1) {
50220   Dali::Toolkit::CameraView *arg1 = (Dali::Toolkit::CameraView *) 0 ;
50221
50222   arg1 = (Dali::Toolkit::CameraView *)jarg1;
50223   {
50224     try {
50225       delete arg1;
50226     } CALL_CATCH_EXCEPTION();
50227   }
50228
50229 }
50230
50231
50232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraView__SWIG_1(void * jarg1) {
50233   void * jresult ;
50234   Dali::Toolkit::CameraView *arg1 = 0 ;
50235   Dali::Toolkit::CameraView *result = 0 ;
50236
50237   arg1 = (Dali::Toolkit::CameraView *)jarg1;
50238   if (!arg1) {
50239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CameraView const & type is null", 0);
50240     return 0;
50241   }
50242   {
50243     try {
50244       result = (Dali::Toolkit::CameraView *)new Dali::Toolkit::CameraView((Dali::Toolkit::CameraView const &)*arg1);
50245     } CALL_CATCH_EXCEPTION(0);
50246   }
50247
50248   jresult = (void *)result;
50249   return jresult;
50250 }
50251
50252
50253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraView_Assign(void * jarg1, void * jarg2) {
50254   void * jresult ;
50255   Dali::Toolkit::CameraView *arg1 = (Dali::Toolkit::CameraView *) 0 ;
50256   Dali::Toolkit::CameraView *arg2 = 0 ;
50257   Dali::Toolkit::CameraView *result = 0 ;
50258
50259   arg1 = (Dali::Toolkit::CameraView *)jarg1;
50260   arg2 = (Dali::Toolkit::CameraView *)jarg2;
50261   if (!arg2) {
50262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CameraView const & type is null", 0);
50263     return 0;
50264   }
50265   {
50266     try {
50267       result = (Dali::Toolkit::CameraView *) &(arg1)->operator =((Dali::Toolkit::CameraView const &)*arg2);
50268     } CALL_CATCH_EXCEPTION(0);
50269   }
50270
50271   jresult = (void *)result;
50272   return jresult;
50273 }
50274
50275
50276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraView_DownCast(void * jarg1) {
50277   void * jresult ;
50278   Dali::BaseHandle arg1 ;
50279   Dali::BaseHandle *argp1 ;
50280   Dali::Toolkit::CameraView result;
50281
50282   argp1 = (Dali::BaseHandle *)jarg1;
50283   if (!argp1) {
50284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50285     return 0;
50286   }
50287   arg1 = *argp1;
50288   {
50289     try {
50290       result = Dali::Toolkit::CameraView::DownCast(arg1);
50291     } CALL_CATCH_EXCEPTION(0);
50292   }
50293
50294   jresult = new Dali::Toolkit::CameraView((const Dali::Toolkit::CameraView &)result);
50295   return jresult;
50296 }
50297
50298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraView_Update(void * jarg1) {
50299   Dali::Toolkit::CameraView *arg1 = (Dali::Toolkit::CameraView *) 0 ;
50300
50301   arg1 = (Dali::Toolkit::CameraView *)jarg1;
50302   {
50303     try {
50304       (arg1)->Update();
50305     } CALL_CATCH_EXCEPTION();
50306   }
50307 }
50308
50309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_PlayAnimation(void * jarg1, void * jarg2)
50310 {
50311   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView*)jarg1;
50312   if(arg1 == nullptr)
50313   {
50314     DALI_LOG_ERROR("VideoView is nullptr!");
50315     return;
50316   }
50317   Dali::Animation *arg2 = (Dali::Animation*)jarg2;
50318   if(arg2 == nullptr)
50319   {
50320     DALI_LOG_ERROR("Animation is nullptr!");
50321     return;
50322   }
50323
50324   {
50325     try{
50326
50327       Toolkit::DevelVideoView::PlayAnimation(*arg1, *arg2);
50328     } CALL_CATCH_EXCEPTION();
50329   }
50330
50331 }
50332
50333
50334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
50335   int jresult ;
50336   int result;
50337
50338   result = (int)Dali::Toolkit::Popup::Property::TITLE;
50339   jresult = (int)result;
50340   return jresult;
50341 }
50342
50343
50344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
50345   int jresult ;
50346   int result;
50347
50348   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
50349   jresult = (int)result;
50350   return jresult;
50351 }
50352
50353
50354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
50355   int jresult ;
50356   int result;
50357
50358   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
50359   jresult = (int)result;
50360   return jresult;
50361 }
50362
50363
50364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
50365   int jresult ;
50366   int result;
50367
50368   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
50369   jresult = (int)result;
50370   return jresult;
50371 }
50372
50373
50374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
50375   int jresult ;
50376   int result;
50377
50378   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
50379   jresult = (int)result;
50380   return jresult;
50381 }
50382
50383
50384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
50385   int jresult ;
50386   int result;
50387
50388   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
50389   jresult = (int)result;
50390   return jresult;
50391 }
50392
50393
50394 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
50395   int jresult ;
50396   int result;
50397
50398   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
50399   jresult = (int)result;
50400   return jresult;
50401 }
50402
50403
50404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
50405   int jresult ;
50406   int result;
50407
50408   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
50409   jresult = (int)result;
50410   return jresult;
50411 }
50412
50413
50414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
50415   int jresult ;
50416   int result;
50417
50418   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
50419   jresult = (int)result;
50420   return jresult;
50421 }
50422
50423
50424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
50425   int jresult ;
50426   int result;
50427
50428   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
50429   jresult = (int)result;
50430   return jresult;
50431 }
50432
50433
50434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
50435   int jresult ;
50436   int result;
50437
50438   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
50439   jresult = (int)result;
50440   return jresult;
50441 }
50442
50443
50444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
50445   int jresult ;
50446   int result;
50447
50448   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
50449   jresult = (int)result;
50450   return jresult;
50451 }
50452
50453
50454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
50455   int jresult ;
50456   int result;
50457
50458   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
50459   jresult = (int)result;
50460   return jresult;
50461 }
50462
50463
50464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
50465   int jresult ;
50466   int result;
50467
50468   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
50469   jresult = (int)result;
50470   return jresult;
50471 }
50472
50473
50474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
50475   int jresult ;
50476   int result;
50477
50478   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
50479   jresult = (int)result;
50480   return jresult;
50481 }
50482
50483
50484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
50485   int jresult ;
50486   int result;
50487
50488   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
50489   jresult = (int)result;
50490   return jresult;
50491 }
50492
50493
50494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
50495   int jresult ;
50496   int result;
50497
50498   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
50499   jresult = (int)result;
50500   return jresult;
50501 }
50502
50503
50504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
50505   int jresult ;
50506   int result;
50507
50508   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
50509   jresult = (int)result;
50510   return jresult;
50511 }
50512
50513
50514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
50515   int jresult ;
50516   int result;
50517
50518   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
50519   jresult = (int)result;
50520   return jresult;
50521 }
50522
50523
50524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
50525   int jresult ;
50526   int result;
50527
50528   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
50529   jresult = (int)result;
50530   return jresult;
50531 }
50532
50533
50534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
50535   int jresult ;
50536   int result;
50537
50538   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
50539   jresult = (int)result;
50540   return jresult;
50541 }
50542
50543
50544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
50545   void * jresult ;
50546   Dali::Toolkit::Popup::Property *result = 0 ;
50547
50548   {
50549     try {
50550       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
50551     } CALL_CATCH_EXCEPTION(0);
50552   }
50553
50554   jresult = (void *)result;
50555   return jresult;
50556 }
50557
50558
50559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
50560   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
50561
50562   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
50563   {
50564     try {
50565       delete arg1;
50566     } CALL_CATCH_EXCEPTION();
50567   }
50568
50569 }
50570
50571
50572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
50573   void * jresult ;
50574   Dali::Toolkit::Popup *result = 0 ;
50575
50576   {
50577     try {
50578       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
50579     } CALL_CATCH_EXCEPTION(0);
50580   }
50581
50582   jresult = (void *)result;
50583   return jresult;
50584 }
50585
50586
50587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
50588   void * jresult ;
50589   Dali::Toolkit::Popup result;
50590
50591   {
50592     try {
50593       result = Dali::Toolkit::Popup::New();
50594     } CALL_CATCH_EXCEPTION(0);
50595   }
50596
50597   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
50598   return jresult;
50599 }
50600
50601
50602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
50603   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
50604
50605   arg1 = (Dali::Toolkit::Popup *)jarg1;
50606   {
50607     try {
50608       delete arg1;
50609     } CALL_CATCH_EXCEPTION();
50610   }
50611
50612 }
50613
50614
50615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
50616   void * jresult ;
50617   Dali::Toolkit::Popup *arg1 = 0 ;
50618   Dali::Toolkit::Popup *result = 0 ;
50619
50620   arg1 = (Dali::Toolkit::Popup *)jarg1;
50621   if (!arg1) {
50622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
50623     return 0;
50624   }
50625   {
50626     try {
50627       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
50628     } CALL_CATCH_EXCEPTION(0);
50629   }
50630
50631   jresult = (void *)result;
50632   return jresult;
50633 }
50634
50635
50636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
50637   void * jresult ;
50638   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
50639   Dali::Toolkit::Popup *arg2 = 0 ;
50640   Dali::Toolkit::Popup *result = 0 ;
50641
50642   arg1 = (Dali::Toolkit::Popup *)jarg1;
50643   arg2 = (Dali::Toolkit::Popup *)jarg2;
50644   if (!arg2) {
50645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
50646     return 0;
50647   }
50648   {
50649     try {
50650       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
50651     } CALL_CATCH_EXCEPTION(0);
50652   }
50653
50654   jresult = (void *)result;
50655   return jresult;
50656 }
50657
50658
50659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
50660   void * jresult ;
50661   Dali::BaseHandle arg1 ;
50662   Dali::BaseHandle *argp1 ;
50663   Dali::Toolkit::Popup result;
50664
50665   argp1 = (Dali::BaseHandle *)jarg1;
50666   if (!argp1) {
50667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50668     return 0;
50669   }
50670   arg1 = *argp1;
50671   {
50672     try {
50673       result = Dali::Toolkit::Popup::DownCast(arg1);
50674     } CALL_CATCH_EXCEPTION(0);
50675   }
50676
50677   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
50678   return jresult;
50679 }
50680
50681
50682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
50683   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
50684   Dali::Actor arg2 ;
50685   Dali::Actor *argp2 ;
50686
50687   arg1 = (Dali::Toolkit::Popup *)jarg1;
50688   argp2 = (Dali::Actor *)jarg2;
50689   if (!argp2) {
50690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50691     return ;
50692   }
50693   arg2 = *argp2;
50694   {
50695     try {
50696       (arg1)->SetTitle(arg2);
50697     } CALL_CATCH_EXCEPTION();
50698   }
50699
50700 }
50701
50702
50703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
50704   void * jresult ;
50705   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
50706   Dali::Actor result;
50707
50708   arg1 = (Dali::Toolkit::Popup *)jarg1;
50709   {
50710     try {
50711       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
50712     } CALL_CATCH_EXCEPTION(0);
50713   }
50714
50715   jresult = new Dali::Actor((const Dali::Actor &)result);
50716   return jresult;
50717 }
50718
50719
50720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
50721   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
50722   Dali::Actor arg2 ;
50723   Dali::Actor *argp2 ;
50724
50725   arg1 = (Dali::Toolkit::Popup *)jarg1;
50726   argp2 = (Dali::Actor *)jarg2;
50727   if (!argp2) {
50728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50729     return ;
50730   }
50731   arg2 = *argp2;
50732   {
50733     try {
50734       (arg1)->SetContent(arg2);
50735     } CALL_CATCH_EXCEPTION();
50736   }
50737
50738 }
50739
50740
50741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
50742   void * jresult ;
50743   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
50744   Dali::Actor result;
50745
50746   arg1 = (Dali::Toolkit::Popup *)jarg1;
50747   {
50748     try {
50749       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
50750     } CALL_CATCH_EXCEPTION(0);
50751   }
50752
50753   jresult = new Dali::Actor((const Dali::Actor &)result);
50754   return jresult;
50755 }
50756
50757
50758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
50759   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
50760   Dali::Actor arg2 ;
50761   Dali::Actor *argp2 ;
50762
50763   arg1 = (Dali::Toolkit::Popup *)jarg1;
50764   argp2 = (Dali::Actor *)jarg2;
50765   if (!argp2) {
50766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50767     return ;
50768   }
50769   arg2 = *argp2;
50770   {
50771     try {
50772       (arg1)->SetFooter(arg2);
50773     } CALL_CATCH_EXCEPTION();
50774   }
50775
50776 }
50777
50778
50779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
50780   void * jresult ;
50781   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
50782   Dali::Actor result;
50783
50784   arg1 = (Dali::Toolkit::Popup *)jarg1;
50785   {
50786     try {
50787       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
50788     } CALL_CATCH_EXCEPTION(0);
50789   }
50790
50791   jresult = new Dali::Actor((const Dali::Actor &)result);
50792   return jresult;
50793 }
50794
50795
50796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
50797   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
50798   Dali::Toolkit::Popup::DisplayState arg2 ;
50799
50800   arg1 = (Dali::Toolkit::Popup *)jarg1;
50801   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
50802   {
50803     try {
50804       (arg1)->SetDisplayState(arg2);
50805     } CALL_CATCH_EXCEPTION();
50806   }
50807
50808 }
50809
50810
50811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
50812   int jresult ;
50813   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
50814   Dali::Toolkit::Popup::DisplayState result;
50815
50816   arg1 = (Dali::Toolkit::Popup *)jarg1;
50817   {
50818     try {
50819       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
50820     } CALL_CATCH_EXCEPTION(0);
50821   }
50822
50823   jresult = (int)result;
50824   return jresult;
50825 }
50826
50827
50828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
50829   void * jresult ;
50830   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
50831   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
50832
50833   arg1 = (Dali::Toolkit::Popup *)jarg1;
50834   {
50835     try {
50836       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
50837     } CALL_CATCH_EXCEPTION(0);
50838   }
50839
50840   jresult = (void *)result;
50841   return jresult;
50842 }
50843
50844
50845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
50846   void * jresult ;
50847   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
50848   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
50849
50850   arg1 = (Dali::Toolkit::Popup *)jarg1;
50851   {
50852     try {
50853       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
50854     } CALL_CATCH_EXCEPTION(0);
50855   }
50856
50857   jresult = (void *)result;
50858   return jresult;
50859 }
50860
50861
50862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
50863   void * jresult ;
50864   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
50865   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
50866
50867   arg1 = (Dali::Toolkit::Popup *)jarg1;
50868   {
50869     try {
50870       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
50871     } CALL_CATCH_EXCEPTION(0);
50872   }
50873
50874   jresult = (void *)result;
50875   return jresult;
50876 }
50877
50878
50879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
50880   void * jresult ;
50881   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
50882   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
50883
50884   arg1 = (Dali::Toolkit::Popup *)jarg1;
50885   {
50886     try {
50887       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
50888     } CALL_CATCH_EXCEPTION(0);
50889   }
50890
50891   jresult = (void *)result;
50892   return jresult;
50893 }
50894
50895
50896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
50897   void * jresult ;
50898   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
50899   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
50900
50901   arg1 = (Dali::Toolkit::Popup *)jarg1;
50902   {
50903     try {
50904       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
50905     } CALL_CATCH_EXCEPTION(0);
50906   }
50907
50908   jresult = (void *)result;
50909   return jresult;
50910 }
50911
50912
50913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
50914   int jresult ;
50915   int result;
50916
50917   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
50918   jresult = (int)result;
50919   return jresult;
50920 }
50921
50922
50923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
50924   int jresult ;
50925   int result;
50926
50927   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
50928   jresult = (int)result;
50929   return jresult;
50930 }
50931
50932
50933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
50934   int jresult ;
50935   int result;
50936
50937   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
50938   jresult = (int)result;
50939   return jresult;
50940 }
50941
50942
50943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
50944   int jresult ;
50945   int result;
50946
50947   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
50948   jresult = (int)result;
50949   return jresult;
50950 }
50951
50952
50953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
50954   int jresult ;
50955   int result;
50956
50957   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
50958   jresult = (int)result;
50959   return jresult;
50960 }
50961
50962
50963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
50964   int jresult ;
50965   int result;
50966
50967   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
50968   jresult = (int)result;
50969   return jresult;
50970 }
50971
50972
50973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
50974   int jresult ;
50975   int result;
50976
50977   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
50978   jresult = (int)result;
50979   return jresult;
50980 }
50981
50982
50983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
50984   int jresult ;
50985   int result;
50986
50987   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
50988   jresult = (int)result;
50989   return jresult;
50990 }
50991
50992
50993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
50994   int jresult ;
50995   int result;
50996
50997   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
50998   jresult = (int)result;
50999   return jresult;
51000 }
51001
51002
51003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
51004   void * jresult ;
51005   Dali::Toolkit::ProgressBar::Property *result = 0 ;
51006
51007   {
51008     try {
51009       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
51010     } CALL_CATCH_EXCEPTION(0);
51011   }
51012
51013   jresult = (void *)result;
51014   return jresult;
51015 }
51016
51017
51018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
51019   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
51020
51021   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
51022   {
51023     try {
51024       delete arg1;
51025     } CALL_CATCH_EXCEPTION();
51026   }
51027
51028 }
51029
51030
51031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
51032   void * jresult ;
51033   Dali::Toolkit::ProgressBar result;
51034
51035   {
51036     try {
51037       result = Dali::Toolkit::ProgressBar::New();
51038     } CALL_CATCH_EXCEPTION(0);
51039   }
51040
51041   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
51042   return jresult;
51043 }
51044
51045
51046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
51047   void * jresult ;
51048   Dali::Toolkit::ProgressBar *result = 0 ;
51049
51050   {
51051     try {
51052       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
51053     } CALL_CATCH_EXCEPTION(0);
51054   }
51055
51056   jresult = (void *)result;
51057   return jresult;
51058 }
51059
51060
51061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
51062   void * jresult ;
51063   Dali::Toolkit::ProgressBar *arg1 = 0 ;
51064   Dali::Toolkit::ProgressBar *result = 0 ;
51065
51066   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
51067   if (!arg1) {
51068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
51069     return 0;
51070   }
51071   {
51072     try {
51073       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
51074     } CALL_CATCH_EXCEPTION(0);
51075   }
51076
51077   jresult = (void *)result;
51078   return jresult;
51079 }
51080
51081
51082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
51083   void * jresult ;
51084   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
51085   Dali::Toolkit::ProgressBar *arg2 = 0 ;
51086   Dali::Toolkit::ProgressBar *result = 0 ;
51087
51088   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
51089   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
51090   if (!arg2) {
51091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
51092     return 0;
51093   }
51094   {
51095     try {
51096       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
51097     } CALL_CATCH_EXCEPTION(0);
51098   }
51099
51100   jresult = (void *)result;
51101   return jresult;
51102 }
51103
51104
51105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
51106   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
51107
51108   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
51109   {
51110     try {
51111       delete arg1;
51112     } CALL_CATCH_EXCEPTION();
51113   }
51114
51115 }
51116
51117
51118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
51119   void * jresult ;
51120   Dali::BaseHandle arg1 ;
51121   Dali::BaseHandle *argp1 ;
51122   Dali::Toolkit::ProgressBar result;
51123
51124   argp1 = (Dali::BaseHandle *)jarg1;
51125   if (!argp1) {
51126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51127     return 0;
51128   }
51129   arg1 = *argp1;
51130   {
51131     try {
51132       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
51133     } CALL_CATCH_EXCEPTION(0);
51134   }
51135
51136   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
51137   return jresult;
51138 }
51139
51140
51141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
51142   void * jresult ;
51143   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
51144   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
51145
51146   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
51147   {
51148     try {
51149       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
51150     } CALL_CATCH_EXCEPTION(0);
51151   }
51152
51153   jresult = (void *)result;
51154   return jresult;
51155 }
51156
51157
51158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
51159   void * jresult ;
51160   Dali::Toolkit::GaussianBlurView *result = 0 ;
51161
51162   {
51163     try {
51164       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
51165     } CALL_CATCH_EXCEPTION(0);
51166   }
51167
51168   jresult = (void *)result;
51169   return jresult;
51170 }
51171
51172
51173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
51174   void * jresult ;
51175   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
51176   Dali::Toolkit::GaussianBlurView *result = 0 ;
51177
51178   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
51179   if (!arg1) {
51180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
51181     return 0;
51182   }
51183   {
51184     try {
51185       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
51186     } CALL_CATCH_EXCEPTION(0);
51187   }
51188
51189   jresult = (void *)result;
51190   return jresult;
51191 }
51192
51193
51194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
51195   void * jresult ;
51196   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
51197   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
51198   Dali::Toolkit::GaussianBlurView *result = 0 ;
51199
51200   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
51201   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
51202   if (!arg2) {
51203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
51204     return 0;
51205   }
51206   {
51207     try {
51208       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
51209     } CALL_CATCH_EXCEPTION(0);
51210   }
51211
51212   jresult = (void *)result;
51213   return jresult;
51214 }
51215
51216
51217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
51218   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
51219
51220   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
51221   {
51222     try {
51223       delete arg1;
51224     } CALL_CATCH_EXCEPTION();
51225   }
51226
51227 }
51228
51229
51230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
51231   void * jresult ;
51232   Dali::BaseHandle arg1 ;
51233   Dali::BaseHandle *argp1 ;
51234   Dali::Toolkit::GaussianBlurView result;
51235
51236   argp1 = (Dali::BaseHandle *)jarg1;
51237   if (!argp1) {
51238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51239     return 0;
51240   }
51241   arg1 = *argp1;
51242   {
51243     try {
51244       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
51245     } CALL_CATCH_EXCEPTION(0);
51246   }
51247
51248   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
51249   return jresult;
51250 }
51251
51252
51253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
51254   void * jresult ;
51255   Dali::Toolkit::GaussianBlurView result;
51256
51257   {
51258     try {
51259       result = Dali::Toolkit::GaussianBlurView::New();
51260     } CALL_CATCH_EXCEPTION(0);
51261   }
51262
51263   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
51264   return jresult;
51265 }
51266
51267
51268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, bool jarg6) {
51269   void * jresult ;
51270   unsigned int arg1 ;
51271   float arg2 ;
51272   Dali::Pixel::Format arg3 ;
51273   float arg4 ;
51274   float arg5 ;
51275   bool arg6 ;
51276   Dali::Toolkit::GaussianBlurView result;
51277
51278   arg1 = (unsigned int)jarg1;
51279   arg2 = (float)jarg2;
51280   arg3 = (Dali::Pixel::Format)jarg3;
51281   arg4 = (float)jarg4;
51282   arg5 = (float)jarg5;
51283   arg6 = jarg6 ? true : false;
51284   {
51285     try {
51286       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
51287     } CALL_CATCH_EXCEPTION(0);
51288   }
51289
51290   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
51291   return jresult;
51292 }
51293
51294
51295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
51296   void * jresult ;
51297   unsigned int arg1 ;
51298   float arg2 ;
51299   Dali::Pixel::Format arg3 ;
51300   float arg4 ;
51301   float arg5 ;
51302   Dali::Toolkit::GaussianBlurView result;
51303
51304   arg1 = (unsigned int)jarg1;
51305   arg2 = (float)jarg2;
51306   arg3 = (Dali::Pixel::Format)jarg3;
51307   arg4 = (float)jarg4;
51308   arg5 = (float)jarg5;
51309   {
51310     try {
51311       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
51312     } CALL_CATCH_EXCEPTION(0);
51313   }
51314
51315   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
51316   return jresult;
51317 }
51318
51319
51320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
51321   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
51322   Dali::Actor arg2 ;
51323   Dali::Actor *argp2 ;
51324
51325   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
51326   argp2 = (Dali::Actor *)jarg2;
51327   if (!argp2) {
51328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51329     return ;
51330   }
51331   arg2 = *argp2;
51332   {
51333     try {
51334       (arg1)->Add(arg2);
51335     } CALL_CATCH_EXCEPTION();
51336   }
51337
51338 }
51339
51340
51341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
51342   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
51343   Dali::Actor arg2 ;
51344   Dali::Actor *argp2 ;
51345
51346   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
51347   argp2 = (Dali::Actor *)jarg2;
51348   if (!argp2) {
51349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51350     return ;
51351   }
51352   arg2 = *argp2;
51353   {
51354     try {
51355       (arg1)->Remove(arg2);
51356     } CALL_CATCH_EXCEPTION();
51357   }
51358
51359 }
51360
51361
51362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
51363   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
51364
51365   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
51366   {
51367     try {
51368       (arg1)->Activate();
51369     } CALL_CATCH_EXCEPTION();
51370   }
51371
51372 }
51373
51374
51375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
51376   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
51377
51378   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
51379   {
51380     try {
51381       (arg1)->ActivateOnce();
51382     } CALL_CATCH_EXCEPTION();
51383   }
51384
51385 }
51386
51387
51388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
51389   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
51390
51391   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
51392   {
51393     try {
51394       (arg1)->Deactivate();
51395     } CALL_CATCH_EXCEPTION();
51396   }
51397
51398 }
51399
51400
51401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
51402   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
51403   Dali::Texture arg2 ;
51404   Dali::FrameBuffer arg3 ;
51405   Dali::Texture *argp2 ;
51406   Dali::FrameBuffer *argp3 ;
51407
51408   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
51409   argp2 = (Dali::Texture *)jarg2;
51410   if (!argp2) {
51411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
51412     return ;
51413   }
51414   arg2 = *argp2;
51415   argp3 = (Dali::FrameBuffer *)jarg3;
51416   if (!argp3) {
51417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
51418     return ;
51419   }
51420   arg3 = *argp3;
51421   {
51422     try {
51423       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
51424     } CALL_CATCH_EXCEPTION();
51425   }
51426
51427 }
51428
51429
51430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
51431   int jresult ;
51432   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
51433   Dali::Property::Index result;
51434
51435   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
51436   {
51437     try {
51438       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
51439     } CALL_CATCH_EXCEPTION(0);
51440   }
51441
51442   jresult = result;
51443   return jresult;
51444 }
51445
51446
51447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
51448   void * jresult ;
51449   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
51450   Dali::FrameBuffer result;
51451
51452   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
51453   {
51454     try {
51455       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
51456     } CALL_CATCH_EXCEPTION(0);
51457   }
51458
51459   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
51460   return jresult;
51461 }
51462
51463
51464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
51465   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
51466   Dali::Vector4 *arg2 = 0 ;
51467
51468   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
51469   arg2 = (Dali::Vector4 *)jarg2;
51470   if (!arg2) {
51471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
51472     return ;
51473   }
51474   {
51475     try {
51476       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
51477     } CALL_CATCH_EXCEPTION();
51478   }
51479
51480 }
51481
51482
51483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
51484   void * jresult ;
51485   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
51486   Dali::Vector4 result;
51487
51488   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
51489   {
51490     try {
51491       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
51492     } CALL_CATCH_EXCEPTION(0);
51493   }
51494
51495   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
51496   return jresult;
51497 }
51498
51499
51500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
51501   void * jresult ;
51502   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
51503   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
51504
51505   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
51506   {
51507     try {
51508       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
51509     } CALL_CATCH_EXCEPTION(0);
51510   }
51511
51512   jresult = (void *)result;
51513   return jresult;
51514 }
51515
51516
51517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
51518   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
51519
51520   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
51521   {
51522     try {
51523       delete arg1;
51524     } CALL_CATCH_EXCEPTION();
51525   }
51526
51527 }
51528
51529
51530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
51531   unsigned int jresult ;
51532   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
51533   unsigned int result;
51534
51535   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
51536   {
51537     try {
51538       result = (unsigned int)(arg1)->GetNumberOfPages();
51539     } CALL_CATCH_EXCEPTION(0);
51540   }
51541
51542   jresult = result;
51543   return jresult;
51544 }
51545
51546
51547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
51548   void * jresult ;
51549   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
51550   unsigned int arg2 ;
51551   Dali::Texture result;
51552
51553   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
51554   arg2 = (unsigned int)jarg2;
51555   {
51556     try {
51557       result = (arg1)->NewPage(arg2);
51558     } CALL_CATCH_EXCEPTION(0);
51559   }
51560
51561   jresult = new Dali::Texture((const Dali::Texture &)result);
51562   return jresult;
51563 }
51564
51565
51566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
51567   int jresult ;
51568   int result;
51569
51570   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
51571   jresult = (int)result;
51572   return jresult;
51573 }
51574
51575
51576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
51577   int jresult ;
51578   int result;
51579
51580   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
51581   jresult = (int)result;
51582   return jresult;
51583 }
51584
51585
51586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
51587   int jresult ;
51588   int result;
51589
51590   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
51591   jresult = (int)result;
51592   return jresult;
51593 }
51594
51595
51596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
51597   void * jresult ;
51598   Dali::Toolkit::PageTurnView::Property *result = 0 ;
51599
51600   {
51601     try {
51602       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
51603     } CALL_CATCH_EXCEPTION(0);
51604   }
51605
51606   jresult = (void *)result;
51607   return jresult;
51608 }
51609
51610
51611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
51612   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
51613
51614   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
51615   {
51616     try {
51617       delete arg1;
51618     } CALL_CATCH_EXCEPTION();
51619   }
51620
51621 }
51622
51623
51624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
51625   void * jresult ;
51626   Dali::Toolkit::PageTurnView *result = 0 ;
51627
51628   {
51629     try {
51630       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
51631     } CALL_CATCH_EXCEPTION(0);
51632   }
51633
51634   jresult = (void *)result;
51635   return jresult;
51636 }
51637
51638
51639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
51640   void * jresult ;
51641   Dali::Toolkit::PageTurnView *arg1 = 0 ;
51642   Dali::Toolkit::PageTurnView *result = 0 ;
51643
51644   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
51645   if (!arg1) {
51646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
51647     return 0;
51648   }
51649   {
51650     try {
51651       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
51652     } CALL_CATCH_EXCEPTION(0);
51653   }
51654
51655   jresult = (void *)result;
51656   return jresult;
51657 }
51658
51659
51660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
51661   void * jresult ;
51662   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
51663   Dali::Toolkit::PageTurnView *arg2 = 0 ;
51664   Dali::Toolkit::PageTurnView *result = 0 ;
51665
51666   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
51667   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
51668   if (!arg2) {
51669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
51670     return 0;
51671   }
51672   {
51673     try {
51674       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
51675     } CALL_CATCH_EXCEPTION(0);
51676   }
51677
51678   jresult = (void *)result;
51679   return jresult;
51680 }
51681
51682
51683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
51684   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
51685
51686   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
51687   {
51688     try {
51689       delete arg1;
51690     } CALL_CATCH_EXCEPTION();
51691   }
51692
51693 }
51694
51695
51696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
51697   void * jresult ;
51698   Dali::BaseHandle arg1 ;
51699   Dali::BaseHandle *argp1 ;
51700   Dali::Toolkit::PageTurnView result;
51701
51702   argp1 = (Dali::BaseHandle *)jarg1;
51703   if (!argp1) {
51704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51705     return 0;
51706   }
51707   arg1 = *argp1;
51708   {
51709     try {
51710       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
51711     } CALL_CATCH_EXCEPTION(0);
51712   }
51713
51714   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
51715   return jresult;
51716 }
51717
51718
51719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
51720   void * jresult ;
51721   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
51722   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
51723
51724   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
51725   {
51726     try {
51727       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
51728     } CALL_CATCH_EXCEPTION(0);
51729   }
51730
51731   jresult = (void *)result;
51732   return jresult;
51733 }
51734
51735
51736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
51737   void * jresult ;
51738   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
51739   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
51740
51741   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
51742   {
51743     try {
51744       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
51745     } CALL_CATCH_EXCEPTION(0);
51746   }
51747
51748   jresult = (void *)result;
51749   return jresult;
51750 }
51751
51752
51753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
51754   void * jresult ;
51755   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
51756   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
51757
51758   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
51759   {
51760     try {
51761       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
51762     } CALL_CATCH_EXCEPTION(0);
51763   }
51764
51765   jresult = (void *)result;
51766   return jresult;
51767 }
51768
51769
51770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
51771   void * jresult ;
51772   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
51773   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
51774
51775   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
51776   {
51777     try {
51778       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
51779     } CALL_CATCH_EXCEPTION(0);
51780   }
51781
51782   jresult = (void *)result;
51783   return jresult;
51784 }
51785
51786
51787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
51788   void * jresult ;
51789   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
51790
51791   {
51792     try {
51793       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
51794     } CALL_CATCH_EXCEPTION(0);
51795   }
51796
51797   jresult = (void *)result;
51798   return jresult;
51799 }
51800
51801
51802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
51803   void * jresult ;
51804   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
51805   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
51806
51807   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
51808   if (!arg1) {
51809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
51810     return 0;
51811   }
51812   {
51813     try {
51814       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
51815     } CALL_CATCH_EXCEPTION(0);
51816   }
51817
51818   jresult = (void *)result;
51819   return jresult;
51820 }
51821
51822
51823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
51824   void * jresult ;
51825   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
51826   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
51827   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
51828
51829   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
51830   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
51831   if (!arg2) {
51832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
51833     return 0;
51834   }
51835   {
51836     try {
51837       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
51838     } CALL_CATCH_EXCEPTION(0);
51839   }
51840
51841   jresult = (void *)result;
51842   return jresult;
51843 }
51844
51845
51846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
51847   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
51848
51849   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
51850   {
51851     try {
51852       delete arg1;
51853     } CALL_CATCH_EXCEPTION();
51854   }
51855
51856 }
51857
51858
51859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
51860   void * jresult ;
51861   Dali::Toolkit::PageFactory *arg1 = 0 ;
51862   Dali::Vector2 *arg2 = 0 ;
51863   Dali::Toolkit::PageTurnLandscapeView result;
51864
51865   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
51866   if (!arg1) {
51867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
51868     return 0;
51869   }
51870   arg2 = (Dali::Vector2 *)jarg2;
51871   if (!arg2) {
51872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
51873     return 0;
51874   }
51875   {
51876     try {
51877       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
51878     } CALL_CATCH_EXCEPTION(0);
51879   }
51880
51881   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
51882   return jresult;
51883 }
51884
51885
51886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
51887   void * jresult ;
51888   Dali::BaseHandle arg1 ;
51889   Dali::BaseHandle *argp1 ;
51890   Dali::Toolkit::PageTurnLandscapeView result;
51891
51892   argp1 = (Dali::BaseHandle *)jarg1;
51893   if (!argp1) {
51894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51895     return 0;
51896   }
51897   arg1 = *argp1;
51898   {
51899     try {
51900       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
51901     } CALL_CATCH_EXCEPTION(0);
51902   }
51903
51904   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
51905   return jresult;
51906 }
51907
51908
51909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
51910   void * jresult ;
51911   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
51912
51913   {
51914     try {
51915       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
51916     } CALL_CATCH_EXCEPTION(0);
51917   }
51918
51919   jresult = (void *)result;
51920   return jresult;
51921 }
51922
51923
51924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
51925   void * jresult ;
51926   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
51927   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
51928
51929   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
51930   if (!arg1) {
51931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
51932     return 0;
51933   }
51934   {
51935     try {
51936       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
51937     } CALL_CATCH_EXCEPTION(0);
51938   }
51939
51940   jresult = (void *)result;
51941   return jresult;
51942 }
51943
51944
51945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
51946   void * jresult ;
51947   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
51948   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
51949   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
51950
51951   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
51952   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
51953   if (!arg2) {
51954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
51955     return 0;
51956   }
51957   {
51958     try {
51959       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
51960     } CALL_CATCH_EXCEPTION(0);
51961   }
51962
51963   jresult = (void *)result;
51964   return jresult;
51965 }
51966
51967
51968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
51969   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
51970
51971   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
51972   {
51973     try {
51974       delete arg1;
51975     } CALL_CATCH_EXCEPTION();
51976   }
51977
51978 }
51979
51980
51981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
51982   void * jresult ;
51983   Dali::Toolkit::PageFactory *arg1 = 0 ;
51984   Dali::Vector2 *arg2 = 0 ;
51985   Dali::Toolkit::PageTurnPortraitView result;
51986
51987   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
51988   if (!arg1) {
51989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
51990     return 0;
51991   }
51992   arg2 = (Dali::Vector2 *)jarg2;
51993   if (!arg2) {
51994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
51995     return 0;
51996   }
51997   {
51998     try {
51999       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
52000     } CALL_CATCH_EXCEPTION(0);
52001   }
52002
52003   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
52004   return jresult;
52005 }
52006
52007
52008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
52009   void * jresult ;
52010   Dali::BaseHandle arg1 ;
52011   Dali::BaseHandle *argp1 ;
52012   Dali::Toolkit::PageTurnPortraitView result;
52013
52014   argp1 = (Dali::BaseHandle *)jarg1;
52015   if (!argp1) {
52016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52017     return 0;
52018   }
52019   arg1 = *argp1;
52020   {
52021     try {
52022       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
52023     } CALL_CATCH_EXCEPTION(0);
52024   }
52025
52026   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
52027   return jresult;
52028 }
52029
52030
52031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
52032   int jresult ;
52033   int result;
52034
52035   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
52036   jresult = (int)result;
52037   return jresult;
52038 }
52039
52040
52041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
52042   int jresult ;
52043   int result;
52044
52045   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
52046   jresult = (int)result;
52047   return jresult;
52048 }
52049
52050
52051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
52052   int jresult ;
52053   int result;
52054
52055   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
52056   jresult = (int)result;
52057   return jresult;
52058 }
52059
52060
52061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
52062   void * jresult ;
52063   Dali::Toolkit::ToggleButton::Property *result = 0 ;
52064
52065   {
52066     try {
52067       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
52068     } CALL_CATCH_EXCEPTION(0);
52069   }
52070
52071   jresult = (void *)result;
52072   return jresult;
52073 }
52074
52075
52076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
52077   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
52078
52079   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
52080   {
52081     try {
52082       delete arg1;
52083     } CALL_CATCH_EXCEPTION();
52084   }
52085
52086 }
52087
52088
52089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
52090   void * jresult ;
52091   Dali::Toolkit::ToggleButton *result = 0 ;
52092
52093   {
52094     try {
52095       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
52096     } CALL_CATCH_EXCEPTION(0);
52097   }
52098
52099   jresult = (void *)result;
52100   return jresult;
52101 }
52102
52103
52104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
52105   void * jresult ;
52106   Dali::Toolkit::ToggleButton *arg1 = 0 ;
52107   Dali::Toolkit::ToggleButton *result = 0 ;
52108
52109   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
52110   if (!arg1) {
52111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
52112     return 0;
52113   }
52114   {
52115     try {
52116       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
52117     } CALL_CATCH_EXCEPTION(0);
52118   }
52119
52120   jresult = (void *)result;
52121   return jresult;
52122 }
52123
52124
52125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
52126   void * jresult ;
52127   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
52128   Dali::Toolkit::ToggleButton *arg2 = 0 ;
52129   Dali::Toolkit::ToggleButton *result = 0 ;
52130
52131   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
52132   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
52133   if (!arg2) {
52134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
52135     return 0;
52136   }
52137   {
52138     try {
52139       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
52140     } CALL_CATCH_EXCEPTION(0);
52141   }
52142
52143   jresult = (void *)result;
52144   return jresult;
52145 }
52146
52147
52148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
52149   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
52150
52151   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
52152   {
52153     try {
52154       delete arg1;
52155     } CALL_CATCH_EXCEPTION();
52156   }
52157
52158 }
52159
52160
52161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
52162   void * jresult ;
52163   Dali::Toolkit::ToggleButton result;
52164
52165   {
52166     try {
52167       result = Dali::Toolkit::ToggleButton::New();
52168     } CALL_CATCH_EXCEPTION(0);
52169   }
52170
52171   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
52172   return jresult;
52173 }
52174
52175
52176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
52177   void * jresult ;
52178   Dali::BaseHandle arg1 ;
52179   Dali::BaseHandle *argp1 ;
52180   Dali::Toolkit::ToggleButton result;
52181
52182   argp1 = (Dali::BaseHandle *)jarg1;
52183   if (!argp1) {
52184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52185     return 0;
52186   }
52187   arg1 = *argp1;
52188   {
52189     try {
52190       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
52191     } CALL_CATCH_EXCEPTION(0);
52192   }
52193
52194   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
52195   return jresult;
52196 }
52197
52198
52199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
52200   void * jresult ;
52201   Dali::Toolkit::Visual::Base *result = 0 ;
52202
52203   {
52204     try {
52205       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
52206     } CALL_CATCH_EXCEPTION(0);
52207   }
52208
52209   jresult = (void *)result;
52210   return jresult;
52211 }
52212
52213
52214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
52215   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
52216
52217   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
52218   {
52219     try {
52220       delete arg1;
52221     } CALL_CATCH_EXCEPTION();
52222   }
52223
52224 }
52225
52226
52227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
52228   void * jresult ;
52229   Dali::Toolkit::Visual::Base *arg1 = 0 ;
52230   Dali::Toolkit::Visual::Base *result = 0 ;
52231
52232   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
52233   if (!arg1) {
52234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
52235     return 0;
52236   }
52237   {
52238     try {
52239       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
52240     } CALL_CATCH_EXCEPTION(0);
52241   }
52242
52243   jresult = (void *)result;
52244   return jresult;
52245 }
52246
52247
52248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
52249   void * jresult ;
52250   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
52251   Dali::Toolkit::Visual::Base *arg2 = 0 ;
52252   Dali::Toolkit::Visual::Base *result = 0 ;
52253
52254   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
52255   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
52256   if (!arg2) {
52257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
52258     return 0;
52259   }
52260   {
52261     try {
52262       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
52263     } CALL_CATCH_EXCEPTION(0);
52264   }
52265
52266   jresult = (void *)result;
52267   return jresult;
52268 }
52269
52270
52271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
52272   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
52273   std::string *arg2 = 0 ;
52274
52275   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
52276   if (!jarg2) {
52277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52278     return ;
52279   }
52280   std::string arg2_str(jarg2);
52281   arg2 = &arg2_str;
52282   {
52283     try {
52284       (arg1)->SetName((std::string const &)*arg2);
52285     } CALL_CATCH_EXCEPTION();
52286   }
52287
52288
52289   //argout typemap for const std::string&
52290
52291 }
52292
52293
52294 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
52295   char * jresult ;
52296   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
52297   std::string *result = 0 ;
52298
52299   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
52300   {
52301     try {
52302       result = (std::string *) &(arg1)->GetName();
52303     } CALL_CATCH_EXCEPTION(0);
52304   }
52305
52306   jresult = SWIG_csharp_string_callback(result->c_str());
52307   return jresult;
52308 }
52309
52310
52311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
52312   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
52313   Dali::Property::Map *arg2 = 0 ;
52314   Dali::Size arg3 ;
52315   Dali::Size *argp3 ;
52316
52317   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
52318   arg2 = (Dali::Property::Map *)jarg2;
52319   if (!arg2) {
52320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
52321     return ;
52322   }
52323   argp3 = (Dali::Size *)jarg3;
52324   if (!argp3) {
52325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
52326     return ;
52327   }
52328   arg3 = *argp3;
52329   {
52330     try {
52331       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
52332     } CALL_CATCH_EXCEPTION();
52333   }
52334
52335 }
52336
52337
52338 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
52339   float jresult ;
52340   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
52341   float arg2 ;
52342   float result;
52343
52344   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
52345   arg2 = (float)jarg2;
52346   {
52347     try {
52348       result = (float)(arg1)->GetHeightForWidth(arg2);
52349     } CALL_CATCH_EXCEPTION(0);
52350   }
52351
52352   jresult = result;
52353   return jresult;
52354 }
52355
52356
52357 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
52358   float jresult ;
52359   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
52360   float arg2 ;
52361   float result;
52362
52363   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
52364   arg2 = (float)jarg2;
52365   {
52366     try {
52367       result = (float)(arg1)->GetWidthForHeight(arg2);
52368     } CALL_CATCH_EXCEPTION(0);
52369   }
52370
52371   jresult = result;
52372   return jresult;
52373 }
52374
52375
52376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
52377   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
52378   Dali::Vector2 *arg2 = 0 ;
52379
52380   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
52381   arg2 = (Dali::Vector2 *)jarg2;
52382   if (!arg2) {
52383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
52384     return ;
52385   }
52386   {
52387     try {
52388       (arg1)->GetNaturalSize(*arg2);
52389     } CALL_CATCH_EXCEPTION();
52390   }
52391
52392 }
52393
52394
52395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
52396   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
52397   float arg2 ;
52398
52399   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
52400   arg2 = (int)jarg2;
52401   {
52402     try {
52403       (arg1)->SetDepthIndex(arg2);
52404     } CALL_CATCH_EXCEPTION();
52405   }
52406
52407 }
52408
52409
52410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
52411   int jresult ;
52412   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
52413   int result;
52414
52415   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
52416   {
52417     try {
52418       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
52419     } CALL_CATCH_EXCEPTION(0);
52420   }
52421
52422   jresult = result;
52423   return jresult;
52424 }
52425
52426
52427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
52428   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
52429   Dali::Property::Map *arg2 = 0 ;
52430
52431   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
52432   arg2 = (Dali::Property::Map *)jarg2;
52433   if (!arg2) {
52434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
52435     return ;
52436   }
52437   {
52438     try {
52439       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
52440     } CALL_CATCH_EXCEPTION();
52441   }
52442
52443 }
52444
52445
52446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
52447   void * jresult ;
52448   Dali::Toolkit::VisualFactory result;
52449
52450   {
52451     try {
52452       result = Dali::Toolkit::VisualFactory::Get();
52453     } CALL_CATCH_EXCEPTION(0);
52454   }
52455
52456   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
52457   return jresult;
52458 }
52459
52460
52461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
52462   void * jresult ;
52463   Dali::Toolkit::VisualFactory *result = 0 ;
52464
52465   {
52466     try {
52467       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
52468     } CALL_CATCH_EXCEPTION(0);
52469   }
52470
52471   jresult = (void *)result;
52472   return jresult;
52473 }
52474
52475
52476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
52477   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
52478
52479   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
52480   {
52481     try {
52482       delete arg1;
52483     } CALL_CATCH_EXCEPTION();
52484   }
52485
52486 }
52487
52488
52489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
52490   void * jresult ;
52491   Dali::Toolkit::VisualFactory *arg1 = 0 ;
52492   Dali::Toolkit::VisualFactory *result = 0 ;
52493
52494   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
52495   if (!arg1) {
52496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
52497     return 0;
52498   }
52499   {
52500     try {
52501       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
52502     } CALL_CATCH_EXCEPTION(0);
52503   }
52504
52505   jresult = (void *)result;
52506   return jresult;
52507 }
52508
52509
52510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
52511   void * jresult ;
52512   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
52513   Dali::Toolkit::VisualFactory *arg2 = 0 ;
52514   Dali::Toolkit::VisualFactory *result = 0 ;
52515
52516   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
52517   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
52518   if (!arg2) {
52519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
52520     return 0;
52521   }
52522   {
52523     try {
52524       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
52525     } CALL_CATCH_EXCEPTION(0);
52526   }
52527
52528   jresult = (void *)result;
52529   return jresult;
52530 }
52531
52532
52533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
52534   void * jresult ;
52535   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
52536   Dali::Property::Map *arg2 = 0 ;
52537   Dali::Toolkit::Visual::Base result;
52538
52539   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
52540   arg2 = (Dali::Property::Map *)jarg2;
52541   if (!arg2) {
52542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
52543     return 0;
52544   }
52545   {
52546     try {
52547       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
52548     } CALL_CATCH_EXCEPTION(0);
52549   }
52550
52551   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
52552   return jresult;
52553 }
52554
52555
52556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
52557   void * jresult ;
52558   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
52559   std::string *arg2 = 0 ;
52560   Dali::ImageDimensions arg3 ;
52561   Dali::ImageDimensions *argp3 ;
52562   Dali::Toolkit::Visual::Base result;
52563
52564   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
52565   if (!jarg2) {
52566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52567     return 0;
52568   }
52569   std::string arg2_str(jarg2);
52570   arg2 = &arg2_str;
52571   argp3 = (Dali::ImageDimensions *)jarg3;
52572   if (!argp3) {
52573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
52574     return 0;
52575   }
52576   arg3 = *argp3;
52577   {
52578     try {
52579       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
52580     } CALL_CATCH_EXCEPTION(0);
52581   }
52582
52583   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
52584
52585   //argout typemap for const std::string&
52586
52587   return jresult;
52588 }
52589
52590
52591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
52592   void * jresult ;
52593   Dali::Toolkit::AsyncImageLoader *result = 0 ;
52594
52595   {
52596     try {
52597       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
52598     } CALL_CATCH_EXCEPTION(0);
52599   }
52600
52601   jresult = (void *)result;
52602   return jresult;
52603 }
52604
52605
52606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
52607   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
52608
52609   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
52610   {
52611     try {
52612       delete arg1;
52613     } CALL_CATCH_EXCEPTION();
52614   }
52615
52616 }
52617
52618
52619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
52620   void * jresult ;
52621   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
52622   Dali::Toolkit::AsyncImageLoader *result = 0 ;
52623
52624   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
52625   if (!arg1) {
52626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
52627     return 0;
52628   }
52629   {
52630     try {
52631       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
52632     } CALL_CATCH_EXCEPTION(0);
52633   }
52634
52635   jresult = (void *)result;
52636   return jresult;
52637 }
52638
52639
52640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
52641   void * jresult ;
52642   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
52643   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
52644   Dali::Toolkit::AsyncImageLoader *result = 0 ;
52645
52646   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
52647   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
52648   if (!arg2) {
52649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
52650     return 0;
52651   }
52652   {
52653     try {
52654       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
52655     } CALL_CATCH_EXCEPTION(0);
52656   }
52657
52658   jresult = (void *)result;
52659   return jresult;
52660 }
52661
52662
52663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
52664   void * jresult ;
52665   Dali::Toolkit::AsyncImageLoader result;
52666
52667   {
52668     try {
52669       result = Dali::Toolkit::AsyncImageLoader::New();
52670     } CALL_CATCH_EXCEPTION(0);
52671   }
52672
52673   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
52674   return jresult;
52675 }
52676
52677
52678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
52679   void * jresult ;
52680   Dali::BaseHandle arg1 ;
52681   Dali::BaseHandle *argp1 ;
52682   Dali::Toolkit::AsyncImageLoader result;
52683
52684   argp1 = (Dali::BaseHandle *)jarg1;
52685   if (!argp1) {
52686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52687     return 0;
52688   }
52689   arg1 = *argp1;
52690   {
52691     try {
52692       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
52693     } CALL_CATCH_EXCEPTION(0);
52694   }
52695
52696   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
52697   return jresult;
52698 }
52699
52700
52701 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
52702   unsigned int jresult ;
52703   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
52704   std::string *arg2 = 0 ;
52705   uint32_t result;
52706
52707   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
52708   if (!jarg2) {
52709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52710     return 0;
52711   }
52712   std::string arg2_str(jarg2);
52713   arg2 = &arg2_str;
52714   {
52715     try {
52716       result = (arg1)->Load((std::string const &)*arg2);
52717     } CALL_CATCH_EXCEPTION(0);
52718   }
52719
52720   jresult = result;
52721
52722   //argout typemap for const std::string&
52723
52724   return jresult;
52725 }
52726
52727
52728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
52729   unsigned int jresult ;
52730   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
52731   std::string *arg2 = 0 ;
52732   Dali::ImageDimensions arg3 ;
52733   Dali::ImageDimensions *argp3 ;
52734   uint32_t result;
52735
52736   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
52737   if (!jarg2) {
52738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52739     return 0;
52740   }
52741   std::string arg2_str(jarg2);
52742   arg2 = &arg2_str;
52743   argp3 = (Dali::ImageDimensions *)jarg3;
52744   if (!argp3) {
52745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
52746     return 0;
52747   }
52748   arg3 = *argp3;
52749   {
52750     try {
52751       result = (arg1)->Load((std::string const &)*arg2,arg3);
52752     } CALL_CATCH_EXCEPTION(0);
52753   }
52754
52755   jresult = result;
52756
52757   //argout typemap for const std::string&
52758
52759   return jresult;
52760 }
52761
52762
52763 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, bool jarg6) {
52764   unsigned int jresult ;
52765   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
52766   std::string *arg2 = 0 ;
52767   Dali::ImageDimensions arg3 ;
52768   Dali::FittingMode::Type arg4 ;
52769   Dali::SamplingMode::Type arg5 ;
52770   bool arg6 ;
52771   Dali::ImageDimensions *argp3 ;
52772   uint32_t result;
52773
52774   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
52775   if (!jarg2) {
52776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52777     return 0;
52778   }
52779   std::string arg2_str(jarg2);
52780   arg2 = &arg2_str;
52781   argp3 = (Dali::ImageDimensions *)jarg3;
52782   if (!argp3) {
52783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
52784     return 0;
52785   }
52786   arg3 = *argp3;
52787   arg4 = (Dali::FittingMode::Type)jarg4;
52788   arg5 = (Dali::SamplingMode::Type)jarg5;
52789   arg6 = jarg6 ? true : false;
52790   {
52791     try {
52792       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
52793     } CALL_CATCH_EXCEPTION(0);
52794   }
52795
52796   jresult = result;
52797
52798   //argout typemap for const std::string&
52799
52800   return jresult;
52801 }
52802
52803
52804 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
52805   bool jresult ;
52806   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
52807   uint32_t arg2 ;
52808   bool result;
52809
52810   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
52811   arg2 = (uint32_t)jarg2;
52812   {
52813     try {
52814       result = (bool)(arg1)->Cancel(arg2);
52815     } CALL_CATCH_EXCEPTION(0);
52816   }
52817
52818   jresult = result;
52819   return jresult;
52820 }
52821
52822
52823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
52824   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
52825
52826   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
52827   {
52828     try {
52829       (arg1)->CancelAll();
52830     } CALL_CATCH_EXCEPTION();
52831   }
52832
52833 }
52834
52835
52836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
52837   void * jresult ;
52838   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
52839   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
52840
52841   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
52842   {
52843     try {
52844       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
52845     } CALL_CATCH_EXCEPTION(0);
52846   }
52847
52848   jresult = (void *)result;
52849   return jresult;
52850 }
52851
52852
52853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
52854   void * jresult ;
52855   std::string *arg1 = 0 ;
52856   Dali::PixelData result;
52857
52858   if (!jarg1) {
52859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52860     return 0;
52861   }
52862   std::string arg1_str(jarg1);
52863   arg1 = &arg1_str;
52864   {
52865     try {
52866       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
52867     } CALL_CATCH_EXCEPTION(0);
52868   }
52869
52870   jresult = new Dali::PixelData((const Dali::PixelData &)result);
52871
52872   //argout typemap for const std::string&
52873
52874   return jresult;
52875 }
52876
52877
52878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
52879   void * jresult ;
52880   std::string *arg1 = 0 ;
52881   Dali::ImageDimensions arg2 ;
52882   Dali::ImageDimensions *argp2 ;
52883   Dali::PixelData result;
52884
52885   if (!jarg1) {
52886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52887     return 0;
52888   }
52889   std::string arg1_str(jarg1);
52890   arg1 = &arg1_str;
52891   argp2 = (Dali::ImageDimensions *)jarg2;
52892   if (!argp2) {
52893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
52894     return 0;
52895   }
52896   arg2 = *argp2;
52897   {
52898     try {
52899       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
52900     } CALL_CATCH_EXCEPTION(0);
52901   }
52902
52903   jresult = new Dali::PixelData((const Dali::PixelData &)result);
52904
52905   //argout typemap for const std::string&
52906
52907   return jresult;
52908 }
52909
52910
52911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
52912   void * jresult ;
52913   std::string *arg1 = 0 ;
52914   Dali::ImageDimensions arg2 ;
52915   Dali::FittingMode::Type arg3 ;
52916   Dali::SamplingMode::Type arg4 ;
52917   bool arg5 ;
52918   Dali::ImageDimensions *argp2 ;
52919   Dali::PixelData result;
52920
52921   if (!jarg1) {
52922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52923     return 0;
52924   }
52925   std::string arg1_str(jarg1);
52926   arg1 = &arg1_str;
52927   argp2 = (Dali::ImageDimensions *)jarg2;
52928   if (!argp2) {
52929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
52930     return 0;
52931   }
52932   arg2 = *argp2;
52933   arg3 = (Dali::FittingMode::Type)jarg3;
52934   arg4 = (Dali::SamplingMode::Type)jarg4;
52935   arg5 = jarg5 ? true : false;
52936   {
52937     try {
52938       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
52939     } CALL_CATCH_EXCEPTION(0);
52940   }
52941
52942   jresult = new Dali::PixelData((const Dali::PixelData &)result);
52943
52944   //argout typemap for const std::string&
52945
52946   return jresult;
52947 }
52948
52949
52950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
52951   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
52952
52953   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
52954   {
52955     try {
52956       delete arg1;
52957     } CALL_CATCH_EXCEPTION();
52958   }
52959
52960 }
52961
52962
52963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * customAlgorithmInterface, void * currentFocusedActor, void * proposedActorToFocus, int direction, char * deviceName) {
52964   void * jresult ;
52965   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
52966   Dali::Actor arg2 ;
52967   Dali::Actor arg3 ;
52968   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
52969   std::string *arg5 = 0 ;
52970   Dali::Actor *argp2 ;
52971   Dali::Actor *argp3 ;
52972   Dali::Actor result;
52973
52974   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)customAlgorithmInterface;
52975   argp2 = (Dali::Actor *)currentFocusedActor;
52976   if (!argp2) {
52977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52978     return 0;
52979   }
52980   arg2 = *argp2;
52981   argp3 = (Dali::Actor *)proposedActorToFocus;
52982   if (!argp3) {
52983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52984     return 0;
52985   }
52986   arg3 = *argp3;
52987   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)direction;
52988
52989   std::string arg5_str(deviceName);
52990   arg5 = &arg5_str;
52991
52992   {
52993     try {
52994       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4,(std::string const &)*arg5);
52995     } CALL_CATCH_EXCEPTION(0);
52996   }
52997
52998   jresult = new Dali::Actor((const Dali::Actor &)result);
52999   return jresult;
53000 }
53001
53002
53003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
53004   void * jresult ;
53005   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
53006
53007   {
53008     try {
53009       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
53010     } CALL_CATCH_EXCEPTION(0);
53011   }
53012
53013   jresult = (void *)result;
53014   return jresult;
53015 }
53016
53017
53018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback0_t callback0) {
53019   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg;
53020   SwigDirector_FrameCallbackInterface *director = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
53021   if (director) {
53022     director->swig_connect_director(callback0);
53023   }
53024 }
53025
53026
53027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameCallbackInterface() {
53028   void * jresult ;
53029   Dali::FrameCallbackInterface *result = 0 ;
53030
53031   {
53032     try {
53033       result =(Dali::FrameCallbackInterface *) new SwigDirector_FrameCallbackInterface();
53034     } CALL_CATCH_EXCEPTION(0);
53035   }
53036
53037   jresult = (void *)result;
53038   return jresult;
53039 }
53040
53041 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPosition(void * updateProxy, unsigned int id,  void* position) {
53042   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
53043   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
53044   return proxy->GetPosition(id, *vector3);
53045 }
53046
53047 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetPosition(void * updateProxy, unsigned int id, void* position) {
53048   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
53049   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
53050   return proxy->SetPosition(id, *vector3);
53051 }
53052
53053 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakePosition(void * updateProxy, unsigned int id, void* position) {
53054   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
53055   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
53056   return proxy->BakePosition(id, *vector3);
53057 }
53058
53059 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetSize(void * updateProxy, unsigned int id, void* size) {
53060   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
53061   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
53062   return proxy->GetSize(id, *vector3);
53063 }
53064
53065 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetSize(void * updateProxy, unsigned int id, void* size) {
53066   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
53067   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
53068   return proxy->SetSize(id, *vector3);
53069 }
53070 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeSize(void * updateProxy, unsigned int id, void* size) {
53071   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
53072   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
53073   return proxy->BakeSize(id, *vector3);
53074 }
53075
53076 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPositionAndSize(void * updateProxy, unsigned int id, void* position, void* size) {
53077   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
53078   Dali::Vector3* vector3_pos = (Dali::Vector3 *)position;
53079   Dali::Vector3* vector3_size = (Dali::Vector3 *)size;
53080   return proxy->GetPositionAndSize(id, *vector3_pos, *vector3_size);
53081 }
53082
53083 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetScale(void * updateProxy, unsigned int id, void* scale) {
53084   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
53085   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
53086   return proxy->GetScale(id,* vector3);
53087 }
53088
53089 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetScale(void * updateProxy, unsigned int id, void* scale) {
53090   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
53091   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
53092   return proxy->SetScale(id, *vector3);
53093 }
53094
53095 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeScale(void * updateProxy, unsigned int id, void* scale) {
53096   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
53097   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
53098   return proxy->BakeScale(id, *vector3);
53099 }
53100
53101 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetColor(void * updateProxy, unsigned int id, void* color) {
53102   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
53103   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
53104   return proxy->GetColor(id, *vector4);
53105 }
53106
53107 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetColor(void * updateProxy, unsigned int id, void* color) {
53108   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
53109   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
53110   return proxy->SetColor(id, *vector4);
53111 }
53112
53113 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeColor(void * updateProxy, unsigned int id, void* color) {
53114   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
53115   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
53116   return proxy->BakeColor(id, *vector4);
53117 }
53118
53119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_AddFrameCallback(void * jarg1, void* jarg2, void* jarg3) {
53120   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
53121   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
53122
53123   Dali::Stage *arg1 = (Dali::Stage *) 0;
53124   Dali::Actor *arg3 = 0;
53125
53126   arg1 = (Dali::Stage *)jarg1;
53127   arg3 = (Dali::Actor *)jarg3;
53128
53129   DevelStage::AddFrameCallback( *arg1, *arg2, *arg3 );
53130   return;
53131 }
53132
53133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_RemoveFrameCallback(void * jarg1, void* jarg2) {
53134
53135   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
53136   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
53137
53138   Dali::Stage *arg1 = (Dali::Stage *) 0;
53139
53140   arg1 = (Dali::Stage *)jarg1;
53141
53142   DevelStage::RemoveFrameCallback( *arg1, *arg2 );
53143   return;
53144 }
53145
53146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
53147   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
53148   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
53149   if (director) {
53150     director->swig_connect_director(callback0);
53151   }
53152 }
53153
53154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
53155   KeyboardFocusManager arg1 ;
53156   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
53157   KeyboardFocusManager *argp1 ;
53158
53159   argp1 = (KeyboardFocusManager *)jarg1;
53160   if (!argp1) {
53161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
53162     return ;
53163   }
53164   arg1 = *argp1;
53165   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
53166   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
53167   {
53168     try {
53169       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
53170     } CALL_CATCH_EXCEPTION();
53171   }
53172
53173 }
53174
53175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_EnableDefaultAlgorithm(void * jarg1, bool jarg2) {
53176   KeyboardFocusManager arg1 ;
53177   bool arg2 ;
53178   KeyboardFocusManager *argp1 ;
53179
53180   argp1 = (KeyboardFocusManager *)jarg1;
53181   if (!argp1) {
53182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
53183     return ;
53184   }
53185   arg1 = *argp1;
53186   arg2 = jarg2;
53187   {
53188     try {
53189       Dali::Toolkit::DevelKeyboardFocusManager::EnableDefaultAlgorithm(arg1, arg2);
53190     } CALL_CATCH_EXCEPTION();
53191   }
53192 }
53193
53194 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_IsDefaultAlgorithmEnabled(void * jarg1) {
53195   bool jresult ;
53196   KeyboardFocusManager arg1 ;
53197   KeyboardFocusManager *argp1 ;
53198   bool result;
53199
53200   argp1 = (KeyboardFocusManager *)jarg1;
53201   if (!argp1) {
53202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
53203     return false;
53204   }
53205   arg1 = *argp1;
53206   {
53207     try {
53208       result = Dali::Toolkit::DevelKeyboardFocusManager::IsDefaultAlgorithmEnabled(arg1);
53209     } CALL_CATCH_EXCEPTION(0);
53210   }
53211   jresult = result;
53212   return jresult;
53213 }
53214
53215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_SetFocusFinderRootActor(void * manager, void * actor) {
53216   if (!manager) {
53217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
53218     return ;
53219   }
53220   if (!actor) {
53221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
53222     return ;
53223   }
53224   {
53225     try {
53226       Dali::Toolkit::DevelKeyboardFocusManager::SetFocusFinderRootActor(*(KeyboardFocusManager *)manager, *(Dali::Actor *)actor);
53227     } CALL_CATCH_EXCEPTION();
53228   }
53229 }
53230
53231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_ResetFocusFinderRootActor(void * manager) {
53232   if (!manager) {
53233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
53234     return ;
53235   }
53236   {
53237     try {
53238       Dali::Toolkit::DevelKeyboardFocusManager::ResetFocusFinderRootActor(*(KeyboardFocusManager *)manager);
53239     } CALL_CATCH_EXCEPTION();
53240   }
53241 }
53242
53243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
53244   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53245
53246   arg1 = (std::vector< unsigned int > *)jarg1;
53247   {
53248     try {
53249       (arg1)->clear();
53250     } CALL_CATCH_EXCEPTION();
53251   }
53252
53253 }
53254
53255
53256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
53257   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53258   unsigned int *arg2 = 0 ;
53259   unsigned int temp2 ;
53260
53261   arg1 = (std::vector< unsigned int > *)jarg1;
53262   temp2 = (unsigned int)jarg2;
53263   arg2 = &temp2;
53264   {
53265     try {
53266       (arg1)->push_back((unsigned int const &)*arg2);
53267     } CALL_CATCH_EXCEPTION();
53268   }
53269
53270 }
53271
53272
53273 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
53274   unsigned long jresult ;
53275   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53276   std::vector< unsigned int >::size_type result;
53277
53278   arg1 = (std::vector< unsigned int > *)jarg1;
53279   {
53280     try {
53281       result = ((std::vector< unsigned int > const *)arg1)->size();
53282     } CALL_CATCH_EXCEPTION(0);
53283   }
53284
53285   jresult = (unsigned long)result;
53286   return jresult;
53287 }
53288
53289
53290 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
53291   unsigned long jresult ;
53292   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53293   std::vector< unsigned int >::size_type result;
53294
53295   arg1 = (std::vector< unsigned int > *)jarg1;
53296   {
53297     try {
53298       result = ((std::vector< unsigned int > const *)arg1)->capacity();
53299     } CALL_CATCH_EXCEPTION(0);
53300   }
53301
53302   jresult = (unsigned long)result;
53303   return jresult;
53304 }
53305
53306
53307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
53308   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53309   std::vector< unsigned int >::size_type arg2 ;
53310
53311   arg1 = (std::vector< unsigned int > *)jarg1;
53312   arg2 = (std::vector< unsigned int >::size_type)jarg2;
53313   {
53314     try {
53315       (arg1)->reserve(arg2);
53316     } CALL_CATCH_EXCEPTION();
53317   }
53318
53319 }
53320
53321
53322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
53323   void * jresult ;
53324   std::vector< unsigned int > *result = 0 ;
53325
53326   {
53327     try {
53328       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
53329     } CALL_CATCH_EXCEPTION(0);
53330   }
53331
53332   jresult = (void *)result;
53333   return jresult;
53334 }
53335
53336
53337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
53338   void * jresult ;
53339   std::vector< unsigned int > *arg1 = 0 ;
53340   std::vector< unsigned int > *result = 0 ;
53341
53342   arg1 = (std::vector< unsigned int > *)jarg1;
53343   if (!arg1) {
53344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
53345     return 0;
53346   }
53347   {
53348     try {
53349       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
53350     } CALL_CATCH_EXCEPTION(0);
53351   }
53352
53353   jresult = (void *)result;
53354   return jresult;
53355 }
53356
53357
53358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
53359   void * jresult ;
53360   int arg1 ;
53361   std::vector< unsigned int > *result = 0 ;
53362
53363   arg1 = (int)jarg1;
53364   {
53365     try {
53366       try {
53367         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
53368       }
53369       catch(std::out_of_range &_e) {
53370         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53371         return 0;
53372       }
53373
53374     } CALL_CATCH_EXCEPTION(0);
53375   }
53376
53377   jresult = (void *)result;
53378   return jresult;
53379 }
53380
53381
53382 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
53383   unsigned int jresult ;
53384   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53385   int arg2 ;
53386   unsigned int result;
53387
53388   arg1 = (std::vector< unsigned int > *)jarg1;
53389   arg2 = (int)jarg2;
53390   {
53391     try {
53392       try {
53393         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
53394       }
53395       catch(std::out_of_range &_e) {
53396         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53397         return 0;
53398       }
53399
53400     } CALL_CATCH_EXCEPTION(0);
53401   }
53402
53403   jresult = result;
53404   return jresult;
53405 }
53406
53407
53408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
53409   unsigned int jresult ;
53410   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53411   int arg2 ;
53412   unsigned int *result = 0 ;
53413
53414   arg1 = (std::vector< unsigned int > *)jarg1;
53415   arg2 = (int)jarg2;
53416   {
53417     try {
53418       try {
53419         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
53420       }
53421       catch(std::out_of_range &_e) {
53422         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53423         return 0;
53424       }
53425
53426     } CALL_CATCH_EXCEPTION(0);
53427   }
53428
53429   jresult = *result;
53430   return jresult;
53431 }
53432
53433
53434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
53435   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53436   int arg2 ;
53437   unsigned int *arg3 = 0 ;
53438   unsigned int temp3 ;
53439
53440   arg1 = (std::vector< unsigned int > *)jarg1;
53441   arg2 = (int)jarg2;
53442   temp3 = (unsigned int)jarg3;
53443   arg3 = &temp3;
53444   {
53445     try {
53446       try {
53447         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
53448       }
53449       catch(std::out_of_range &_e) {
53450         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53451         return ;
53452       }
53453
53454     } CALL_CATCH_EXCEPTION();
53455   }
53456
53457 }
53458
53459
53460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
53461   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53462   std::vector< unsigned int > *arg2 = 0 ;
53463
53464   arg1 = (std::vector< unsigned int > *)jarg1;
53465   arg2 = (std::vector< unsigned int > *)jarg2;
53466   if (!arg2) {
53467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
53468     return ;
53469   }
53470   {
53471     try {
53472       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
53473     } CALL_CATCH_EXCEPTION();
53474   }
53475
53476 }
53477
53478
53479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
53480   void * jresult ;
53481   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53482   int arg2 ;
53483   int arg3 ;
53484   std::vector< unsigned int > *result = 0 ;
53485
53486   arg1 = (std::vector< unsigned int > *)jarg1;
53487   arg2 = (int)jarg2;
53488   arg3 = (int)jarg3;
53489   {
53490     try {
53491       try {
53492         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
53493       }
53494       catch(std::out_of_range &_e) {
53495         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53496         return 0;
53497       }
53498       catch(std::invalid_argument &_e) {
53499         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53500         return 0;
53501       }
53502
53503     } CALL_CATCH_EXCEPTION(0);
53504   }
53505
53506   jresult = (void *)result;
53507   return jresult;
53508 }
53509
53510
53511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
53512   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53513   int arg2 ;
53514   unsigned int *arg3 = 0 ;
53515   unsigned int temp3 ;
53516
53517   arg1 = (std::vector< unsigned int > *)jarg1;
53518   arg2 = (int)jarg2;
53519   temp3 = (unsigned int)jarg3;
53520   arg3 = &temp3;
53521   {
53522     try {
53523       try {
53524         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
53525       }
53526       catch(std::out_of_range &_e) {
53527         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53528         return ;
53529       }
53530
53531     } CALL_CATCH_EXCEPTION();
53532   }
53533
53534 }
53535
53536
53537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
53538   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53539   int arg2 ;
53540   std::vector< unsigned int > *arg3 = 0 ;
53541
53542   arg1 = (std::vector< unsigned int > *)jarg1;
53543   arg2 = (int)jarg2;
53544   arg3 = (std::vector< unsigned int > *)jarg3;
53545   if (!arg3) {
53546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
53547     return ;
53548   }
53549   {
53550     try {
53551       try {
53552         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
53553       }
53554       catch(std::out_of_range &_e) {
53555         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53556         return ;
53557       }
53558
53559     } CALL_CATCH_EXCEPTION();
53560   }
53561
53562 }
53563
53564
53565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
53566   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53567   int arg2 ;
53568
53569   arg1 = (std::vector< unsigned int > *)jarg1;
53570   arg2 = (int)jarg2;
53571   {
53572     try {
53573       try {
53574         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
53575       }
53576       catch(std::out_of_range &_e) {
53577         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53578         return ;
53579       }
53580
53581     } CALL_CATCH_EXCEPTION();
53582   }
53583
53584 }
53585
53586
53587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
53588   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53589   int arg2 ;
53590   int arg3 ;
53591
53592   arg1 = (std::vector< unsigned int > *)jarg1;
53593   arg2 = (int)jarg2;
53594   arg3 = (int)jarg3;
53595   {
53596     try {
53597       try {
53598         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
53599       }
53600       catch(std::out_of_range &_e) {
53601         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53602         return ;
53603       }
53604       catch(std::invalid_argument &_e) {
53605         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53606         return ;
53607       }
53608
53609     } CALL_CATCH_EXCEPTION();
53610   }
53611
53612 }
53613
53614
53615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
53616   void * jresult ;
53617   unsigned int *arg1 = 0 ;
53618   int arg2 ;
53619   unsigned int temp1 ;
53620   std::vector< unsigned int > *result = 0 ;
53621
53622   temp1 = (unsigned int)jarg1;
53623   arg1 = &temp1;
53624   arg2 = (int)jarg2;
53625   {
53626     try {
53627       try {
53628         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
53629       }
53630       catch(std::out_of_range &_e) {
53631         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53632         return 0;
53633       }
53634
53635     } CALL_CATCH_EXCEPTION(0);
53636   }
53637
53638   jresult = (void *)result;
53639   return jresult;
53640 }
53641
53642
53643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
53644   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53645
53646   arg1 = (std::vector< unsigned int > *)jarg1;
53647   {
53648     try {
53649       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
53650     } CALL_CATCH_EXCEPTION();
53651   }
53652
53653 }
53654
53655
53656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
53657   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53658   int arg2 ;
53659   int arg3 ;
53660
53661   arg1 = (std::vector< unsigned int > *)jarg1;
53662   arg2 = (int)jarg2;
53663   arg3 = (int)jarg3;
53664   {
53665     try {
53666       try {
53667         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
53668       }
53669       catch(std::out_of_range &_e) {
53670         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53671         return ;
53672       }
53673       catch(std::invalid_argument &_e) {
53674         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53675         return ;
53676       }
53677
53678     } CALL_CATCH_EXCEPTION();
53679   }
53680
53681 }
53682
53683
53684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
53685   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53686   int arg2 ;
53687   std::vector< unsigned int > *arg3 = 0 ;
53688
53689   arg1 = (std::vector< unsigned int > *)jarg1;
53690   arg2 = (int)jarg2;
53691   arg3 = (std::vector< unsigned int > *)jarg3;
53692   if (!arg3) {
53693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
53694     return ;
53695   }
53696   {
53697     try {
53698       try {
53699         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
53700       }
53701       catch(std::out_of_range &_e) {
53702         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53703         return ;
53704       }
53705
53706     } CALL_CATCH_EXCEPTION();
53707   }
53708
53709 }
53710
53711
53712 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
53713   bool jresult ;
53714   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53715   unsigned int *arg2 = 0 ;
53716   unsigned int temp2 ;
53717   bool result;
53718
53719   arg1 = (std::vector< unsigned int > *)jarg1;
53720   temp2 = (unsigned int)jarg2;
53721   arg2 = &temp2;
53722   {
53723     try {
53724       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
53725     } CALL_CATCH_EXCEPTION(0);
53726   }
53727
53728   jresult = result;
53729   return jresult;
53730 }
53731
53732
53733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
53734   int jresult ;
53735   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53736   unsigned int *arg2 = 0 ;
53737   unsigned int temp2 ;
53738   int result;
53739
53740   arg1 = (std::vector< unsigned int > *)jarg1;
53741   temp2 = (unsigned int)jarg2;
53742   arg2 = &temp2;
53743   {
53744     try {
53745       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
53746     } CALL_CATCH_EXCEPTION(0);
53747   }
53748
53749   jresult = result;
53750   return jresult;
53751 }
53752
53753
53754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
53755   int jresult ;
53756   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53757   unsigned int *arg2 = 0 ;
53758   unsigned int temp2 ;
53759   int result;
53760
53761   arg1 = (std::vector< unsigned int > *)jarg1;
53762   temp2 = (unsigned int)jarg2;
53763   arg2 = &temp2;
53764   {
53765     try {
53766       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
53767     } CALL_CATCH_EXCEPTION(0);
53768   }
53769
53770   jresult = result;
53771   return jresult;
53772 }
53773
53774
53775 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
53776   bool jresult ;
53777   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53778   unsigned int *arg2 = 0 ;
53779   unsigned int temp2 ;
53780   bool result;
53781
53782   arg1 = (std::vector< unsigned int > *)jarg1;
53783   temp2 = (unsigned int)jarg2;
53784   arg2 = &temp2;
53785   {
53786     try {
53787       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
53788     } CALL_CATCH_EXCEPTION(0);
53789   }
53790
53791   jresult = result;
53792   return jresult;
53793 }
53794
53795
53796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
53797   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53798
53799   arg1 = (std::vector< unsigned int > *)jarg1;
53800   {
53801     try {
53802       delete arg1;
53803     } CALL_CATCH_EXCEPTION();
53804   }
53805
53806 }
53807
53808
53809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
53810   void * jresult ;
53811   std::pair< unsigned int,Dali::Actor > *result = 0 ;
53812
53813   {
53814     try {
53815       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
53816     } CALL_CATCH_EXCEPTION(0);
53817   }
53818
53819   jresult = (void *)result;
53820   return jresult;
53821 }
53822
53823
53824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
53825   void * jresult ;
53826   unsigned int arg1 ;
53827   Dali::Actor arg2 ;
53828   Dali::Actor *argp2 ;
53829   std::pair< unsigned int,Dali::Actor > *result = 0 ;
53830
53831   arg1 = (unsigned int)jarg1;
53832   argp2 = (Dali::Actor *)jarg2;
53833   if (!argp2) {
53834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53835     return 0;
53836   }
53837   arg2 = *argp2;
53838   {
53839     try {
53840       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
53841     } CALL_CATCH_EXCEPTION(0);
53842   }
53843
53844   jresult = (void *)result;
53845   return jresult;
53846 }
53847
53848
53849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
53850   void * jresult ;
53851   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
53852   std::pair< unsigned int,Dali::Actor > *result = 0 ;
53853
53854   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
53855   if (!arg1) {
53856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
53857     return 0;
53858   }
53859   {
53860     try {
53861       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
53862     } CALL_CATCH_EXCEPTION(0);
53863   }
53864
53865   jresult = (void *)result;
53866   return jresult;
53867 }
53868
53869
53870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
53871   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
53872   unsigned int arg2 ;
53873
53874   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
53875   arg2 = (unsigned int)jarg2;
53876   if (arg1) (arg1)->first = arg2;
53877 }
53878
53879
53880 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
53881   unsigned int jresult ;
53882   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
53883   unsigned int result;
53884
53885   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
53886   result = (unsigned int) ((arg1)->first);
53887   jresult = result;
53888   return jresult;
53889 }
53890
53891
53892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
53893   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
53894   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
53895
53896   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
53897   arg2 = (Dali::Actor *)jarg2;
53898   if (arg1) (arg1)->second = *arg2;
53899 }
53900
53901
53902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
53903   void * jresult ;
53904   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
53905   Dali::Actor *result = 0 ;
53906
53907   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
53908   result = (Dali::Actor *)& ((arg1)->second);
53909   jresult = (void *)result;
53910   return jresult;
53911 }
53912
53913
53914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
53915   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
53916
53917   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
53918   {
53919     try {
53920       delete arg1;
53921     } CALL_CATCH_EXCEPTION();
53922   }
53923
53924 }
53925
53926
53927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
53928   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53929
53930   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53931   {
53932     try {
53933       (arg1)->clear();
53934     } CALL_CATCH_EXCEPTION();
53935   }
53936
53937 }
53938
53939
53940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
53941   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53942   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
53943
53944   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53945   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
53946   if (!arg2) {
53947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
53948     return ;
53949   }
53950   {
53951     try {
53952       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
53953     } CALL_CATCH_EXCEPTION();
53954   }
53955
53956 }
53957
53958
53959 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
53960   unsigned long jresult ;
53961   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53962   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
53963
53964   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53965   {
53966     try {
53967       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
53968     } CALL_CATCH_EXCEPTION(0);
53969   }
53970
53971   jresult = (unsigned long)result;
53972   return jresult;
53973 }
53974
53975
53976 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
53977   unsigned long jresult ;
53978   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53979   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
53980
53981   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53982   {
53983     try {
53984       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
53985     } CALL_CATCH_EXCEPTION(0);
53986   }
53987
53988   jresult = (unsigned long)result;
53989   return jresult;
53990 }
53991
53992
53993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
53994   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53995   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
53996
53997   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53998   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
53999   {
54000     try {
54001       (arg1)->reserve(arg2);
54002     } CALL_CATCH_EXCEPTION();
54003   }
54004
54005 }
54006
54007
54008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
54009   void * jresult ;
54010   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
54011
54012   {
54013     try {
54014       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
54015     } CALL_CATCH_EXCEPTION(0);
54016   }
54017
54018   jresult = (void *)result;
54019   return jresult;
54020 }
54021
54022
54023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
54024   void * jresult ;
54025   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
54026   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
54027
54028   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54029   if (!arg1) {
54030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
54031     return 0;
54032   }
54033   {
54034     try {
54035       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);
54036     } CALL_CATCH_EXCEPTION(0);
54037   }
54038
54039   jresult = (void *)result;
54040   return jresult;
54041 }
54042
54043
54044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
54045   void * jresult ;
54046   int arg1 ;
54047   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
54048
54049   arg1 = (int)jarg1;
54050   {
54051     try {
54052       try {
54053         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);
54054       }
54055       catch(std::out_of_range &_e) {
54056         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54057         return 0;
54058       }
54059
54060     } CALL_CATCH_EXCEPTION(0);
54061   }
54062
54063   jresult = (void *)result;
54064   return jresult;
54065 }
54066
54067
54068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
54069   void * jresult ;
54070   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54071   int arg2 ;
54072   std::pair< unsigned int,Dali::Actor > result;
54073
54074   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54075   arg2 = (int)jarg2;
54076   {
54077     try {
54078       try {
54079         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
54080       }
54081       catch(std::out_of_range &_e) {
54082         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54083         return 0;
54084       }
54085
54086     } CALL_CATCH_EXCEPTION(0);
54087   }
54088
54089   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
54090   return jresult;
54091 }
54092
54093
54094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
54095   void * jresult ;
54096   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54097   int arg2 ;
54098   std::pair< unsigned int,Dali::Actor > *result = 0 ;
54099
54100   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54101   arg2 = (int)jarg2;
54102   {
54103     try {
54104       try {
54105         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
54106       }
54107       catch(std::out_of_range &_e) {
54108         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54109         return 0;
54110       }
54111
54112     } CALL_CATCH_EXCEPTION(0);
54113   }
54114
54115   jresult = (void *)result;
54116   return jresult;
54117 }
54118
54119
54120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
54121   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54122   int arg2 ;
54123   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
54124
54125   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54126   arg2 = (int)jarg2;
54127   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
54128   if (!arg3) {
54129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
54130     return ;
54131   }
54132   {
54133     try {
54134       try {
54135         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);
54136       }
54137       catch(std::out_of_range &_e) {
54138         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54139         return ;
54140       }
54141
54142     } CALL_CATCH_EXCEPTION();
54143   }
54144
54145 }
54146
54147
54148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
54149   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54150   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
54151
54152   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54153   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
54154   if (!arg2) {
54155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
54156     return ;
54157   }
54158   {
54159     try {
54160       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);
54161     } CALL_CATCH_EXCEPTION();
54162   }
54163
54164 }
54165
54166
54167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
54168   void * jresult ;
54169   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54170   int arg2 ;
54171   int arg3 ;
54172   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
54173
54174   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54175   arg2 = (int)jarg2;
54176   arg3 = (int)jarg3;
54177   {
54178     try {
54179       try {
54180         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);
54181       }
54182       catch(std::out_of_range &_e) {
54183         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54184         return 0;
54185       }
54186       catch(std::invalid_argument &_e) {
54187         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
54188         return 0;
54189       }
54190
54191     } CALL_CATCH_EXCEPTION(0);
54192   }
54193
54194   jresult = (void *)result;
54195   return jresult;
54196 }
54197
54198
54199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
54200   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54201   int arg2 ;
54202   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
54203
54204   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54205   arg2 = (int)jarg2;
54206   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
54207   if (!arg3) {
54208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
54209     return ;
54210   }
54211   {
54212     try {
54213       try {
54214         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);
54215       }
54216       catch(std::out_of_range &_e) {
54217         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54218         return ;
54219       }
54220
54221     } CALL_CATCH_EXCEPTION();
54222   }
54223
54224 }
54225
54226
54227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
54228   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54229   int arg2 ;
54230   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
54231
54232   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54233   arg2 = (int)jarg2;
54234   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
54235   if (!arg3) {
54236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
54237     return ;
54238   }
54239   {
54240     try {
54241       try {
54242         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);
54243       }
54244       catch(std::out_of_range &_e) {
54245         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54246         return ;
54247       }
54248
54249     } CALL_CATCH_EXCEPTION();
54250   }
54251
54252 }
54253
54254
54255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
54256   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54257   int arg2 ;
54258
54259   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54260   arg2 = (int)jarg2;
54261   {
54262     try {
54263       try {
54264         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
54265       }
54266       catch(std::out_of_range &_e) {
54267         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54268         return ;
54269       }
54270
54271     } CALL_CATCH_EXCEPTION();
54272   }
54273
54274 }
54275
54276
54277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
54278   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54279   int arg2 ;
54280   int arg3 ;
54281
54282   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54283   arg2 = (int)jarg2;
54284   arg3 = (int)jarg3;
54285   {
54286     try {
54287       try {
54288         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
54289       }
54290       catch(std::out_of_range &_e) {
54291         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54292         return ;
54293       }
54294       catch(std::invalid_argument &_e) {
54295         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
54296         return ;
54297       }
54298
54299     } CALL_CATCH_EXCEPTION();
54300   }
54301
54302 }
54303
54304
54305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
54306   void * jresult ;
54307   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
54308   int arg2 ;
54309   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
54310
54311   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
54312   if (!arg1) {
54313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
54314     return 0;
54315   }
54316   arg2 = (int)jarg2;
54317   {
54318     try {
54319       try {
54320         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);
54321       }
54322       catch(std::out_of_range &_e) {
54323         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54324         return 0;
54325       }
54326
54327     } CALL_CATCH_EXCEPTION(0);
54328   }
54329
54330   jresult = (void *)result;
54331   return jresult;
54332 }
54333
54334
54335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
54336   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54337
54338   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54339   {
54340     try {
54341       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
54342     } CALL_CATCH_EXCEPTION();
54343   }
54344
54345 }
54346
54347
54348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
54349   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54350   int arg2 ;
54351   int arg3 ;
54352
54353   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54354   arg2 = (int)jarg2;
54355   arg3 = (int)jarg3;
54356   {
54357     try {
54358       try {
54359         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
54360       }
54361       catch(std::out_of_range &_e) {
54362         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54363         return ;
54364       }
54365       catch(std::invalid_argument &_e) {
54366         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
54367         return ;
54368       }
54369
54370     } CALL_CATCH_EXCEPTION();
54371   }
54372
54373 }
54374
54375
54376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
54377   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54378   int arg2 ;
54379   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
54380
54381   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54382   arg2 = (int)jarg2;
54383   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
54384   if (!arg3) {
54385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
54386     return ;
54387   }
54388   {
54389     try {
54390       try {
54391         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);
54392       }
54393       catch(std::out_of_range &_e) {
54394         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54395         return ;
54396       }
54397
54398     } CALL_CATCH_EXCEPTION();
54399   }
54400
54401 }
54402
54403
54404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
54405   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54406
54407   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54408   {
54409     try {
54410       delete arg1;
54411     } CALL_CATCH_EXCEPTION();
54412   }
54413
54414 }
54415
54416
54417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
54418   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54419
54420   arg1 = (std::vector< Dali::Actor > *)jarg1;
54421   {
54422     try {
54423       (arg1)->clear();
54424     } CALL_CATCH_EXCEPTION();
54425   }
54426
54427 }
54428
54429
54430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
54431   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54432   Dali::Actor *arg2 = 0 ;
54433
54434   arg1 = (std::vector< Dali::Actor > *)jarg1;
54435   arg2 = (Dali::Actor *)jarg2;
54436   if (!arg2) {
54437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
54438     return ;
54439   }
54440   {
54441     try {
54442       (arg1)->push_back((Dali::Actor const &)*arg2);
54443     } CALL_CATCH_EXCEPTION();
54444   }
54445
54446 }
54447
54448
54449 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
54450   unsigned long jresult ;
54451   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54452   std::vector< Dali::Actor >::size_type result;
54453
54454   arg1 = (std::vector< Dali::Actor > *)jarg1;
54455   {
54456     try {
54457       result = ((std::vector< Dali::Actor > const *)arg1)->size();
54458     } CALL_CATCH_EXCEPTION(0);
54459   }
54460
54461   jresult = (unsigned long)result;
54462   return jresult;
54463 }
54464
54465
54466 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
54467   unsigned long jresult ;
54468   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54469   std::vector< Dali::Actor >::size_type result;
54470
54471   arg1 = (std::vector< Dali::Actor > *)jarg1;
54472   {
54473     try {
54474       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
54475     } CALL_CATCH_EXCEPTION(0);
54476   }
54477
54478   jresult = (unsigned long)result;
54479   return jresult;
54480 }
54481
54482
54483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
54484   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54485   std::vector< Dali::Actor >::size_type arg2 ;
54486
54487   arg1 = (std::vector< Dali::Actor > *)jarg1;
54488   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
54489   {
54490     try {
54491       (arg1)->reserve(arg2);
54492     } CALL_CATCH_EXCEPTION();
54493   }
54494
54495 }
54496
54497
54498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
54499   void * jresult ;
54500   std::vector< Dali::Actor > *result = 0 ;
54501
54502   {
54503     try {
54504       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
54505     } CALL_CATCH_EXCEPTION(0);
54506   }
54507
54508   jresult = (void *)result;
54509   return jresult;
54510 }
54511
54512
54513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
54514   void * jresult ;
54515   std::vector< Dali::Actor > *arg1 = 0 ;
54516   std::vector< Dali::Actor > *result = 0 ;
54517
54518   arg1 = (std::vector< Dali::Actor > *)jarg1;
54519   if (!arg1) {
54520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
54521     return 0;
54522   }
54523   {
54524     try {
54525       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
54526     } CALL_CATCH_EXCEPTION(0);
54527   }
54528
54529   jresult = (void *)result;
54530   return jresult;
54531 }
54532
54533
54534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
54535   void * jresult ;
54536   int arg1 ;
54537   std::vector< Dali::Actor > *result = 0 ;
54538
54539   arg1 = (int)jarg1;
54540   {
54541     try {
54542       try {
54543         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
54544       }
54545       catch(std::out_of_range &_e) {
54546         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54547         return 0;
54548       }
54549
54550     } CALL_CATCH_EXCEPTION(0);
54551   }
54552
54553   jresult = (void *)result;
54554   return jresult;
54555 }
54556
54557
54558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
54559   void * jresult ;
54560   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54561   int arg2 ;
54562   Dali::Actor result;
54563
54564   arg1 = (std::vector< Dali::Actor > *)jarg1;
54565   arg2 = (int)jarg2;
54566   {
54567     try {
54568       try {
54569         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
54570       }
54571       catch(std::out_of_range &_e) {
54572         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54573         return 0;
54574       }
54575
54576     } CALL_CATCH_EXCEPTION(0);
54577   }
54578
54579   jresult = new Dali::Actor((const Dali::Actor &)result);
54580   return jresult;
54581 }
54582
54583
54584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
54585   void * jresult ;
54586   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54587   int arg2 ;
54588   Dali::Actor *result = 0 ;
54589
54590   arg1 = (std::vector< Dali::Actor > *)jarg1;
54591   arg2 = (int)jarg2;
54592   {
54593     try {
54594       try {
54595         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
54596       }
54597       catch(std::out_of_range &_e) {
54598         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54599         return 0;
54600       }
54601
54602     } CALL_CATCH_EXCEPTION(0);
54603   }
54604
54605   jresult = (void *)result;
54606   return jresult;
54607 }
54608
54609
54610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
54611   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54612   int arg2 ;
54613   Dali::Actor *arg3 = 0 ;
54614
54615   arg1 = (std::vector< Dali::Actor > *)jarg1;
54616   arg2 = (int)jarg2;
54617   arg3 = (Dali::Actor *)jarg3;
54618   if (!arg3) {
54619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
54620     return ;
54621   }
54622   {
54623     try {
54624       try {
54625         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
54626       }
54627       catch(std::out_of_range &_e) {
54628         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54629         return ;
54630       }
54631
54632     } CALL_CATCH_EXCEPTION();
54633   }
54634
54635 }
54636
54637
54638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
54639   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54640   std::vector< Dali::Actor > *arg2 = 0 ;
54641
54642   arg1 = (std::vector< Dali::Actor > *)jarg1;
54643   arg2 = (std::vector< Dali::Actor > *)jarg2;
54644   if (!arg2) {
54645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
54646     return ;
54647   }
54648   {
54649     try {
54650       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
54651     } CALL_CATCH_EXCEPTION();
54652   }
54653
54654 }
54655
54656
54657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
54658   void * jresult ;
54659   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54660   int arg2 ;
54661   int arg3 ;
54662   std::vector< Dali::Actor > *result = 0 ;
54663
54664   arg1 = (std::vector< Dali::Actor > *)jarg1;
54665   arg2 = (int)jarg2;
54666   arg3 = (int)jarg3;
54667   {
54668     try {
54669       try {
54670         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
54671       }
54672       catch(std::out_of_range &_e) {
54673         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54674         return 0;
54675       }
54676       catch(std::invalid_argument &_e) {
54677         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
54678         return 0;
54679       }
54680
54681     } CALL_CATCH_EXCEPTION(0);
54682   }
54683
54684   jresult = (void *)result;
54685   return jresult;
54686 }
54687
54688
54689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
54690   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54691   int arg2 ;
54692   Dali::Actor *arg3 = 0 ;
54693
54694   arg1 = (std::vector< Dali::Actor > *)jarg1;
54695   arg2 = (int)jarg2;
54696   arg3 = (Dali::Actor *)jarg3;
54697   if (!arg3) {
54698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
54699     return ;
54700   }
54701   {
54702     try {
54703       try {
54704         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
54705       }
54706       catch(std::out_of_range &_e) {
54707         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54708         return ;
54709       }
54710
54711     } CALL_CATCH_EXCEPTION();
54712   }
54713
54714 }
54715
54716
54717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
54718   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54719   int arg2 ;
54720   std::vector< Dali::Actor > *arg3 = 0 ;
54721
54722   arg1 = (std::vector< Dali::Actor > *)jarg1;
54723   arg2 = (int)jarg2;
54724   arg3 = (std::vector< Dali::Actor > *)jarg3;
54725   if (!arg3) {
54726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
54727     return ;
54728   }
54729   {
54730     try {
54731       try {
54732         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
54733       }
54734       catch(std::out_of_range &_e) {
54735         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54736         return ;
54737       }
54738
54739     } CALL_CATCH_EXCEPTION();
54740   }
54741
54742 }
54743
54744
54745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
54746   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54747   int arg2 ;
54748
54749   arg1 = (std::vector< Dali::Actor > *)jarg1;
54750   arg2 = (int)jarg2;
54751   {
54752     try {
54753       try {
54754         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
54755       }
54756       catch(std::out_of_range &_e) {
54757         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54758         return ;
54759       }
54760
54761     } CALL_CATCH_EXCEPTION();
54762   }
54763
54764 }
54765
54766
54767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
54768   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54769   int arg2 ;
54770   int arg3 ;
54771
54772   arg1 = (std::vector< Dali::Actor > *)jarg1;
54773   arg2 = (int)jarg2;
54774   arg3 = (int)jarg3;
54775   {
54776     try {
54777       try {
54778         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
54779       }
54780       catch(std::out_of_range &_e) {
54781         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54782         return ;
54783       }
54784       catch(std::invalid_argument &_e) {
54785         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
54786         return ;
54787       }
54788
54789     } CALL_CATCH_EXCEPTION();
54790   }
54791
54792 }
54793
54794
54795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
54796   void * jresult ;
54797   Dali::Actor *arg1 = 0 ;
54798   int arg2 ;
54799   std::vector< Dali::Actor > *result = 0 ;
54800
54801   arg1 = (Dali::Actor *)jarg1;
54802   if (!arg1) {
54803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
54804     return 0;
54805   }
54806   arg2 = (int)jarg2;
54807   {
54808     try {
54809       try {
54810         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
54811       }
54812       catch(std::out_of_range &_e) {
54813         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54814         return 0;
54815       }
54816
54817     } CALL_CATCH_EXCEPTION(0);
54818   }
54819
54820   jresult = (void *)result;
54821   return jresult;
54822 }
54823
54824
54825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
54826   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54827
54828   arg1 = (std::vector< Dali::Actor > *)jarg1;
54829   {
54830     try {
54831       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
54832     } CALL_CATCH_EXCEPTION();
54833   }
54834
54835 }
54836
54837
54838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
54839   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54840   int arg2 ;
54841   int arg3 ;
54842
54843   arg1 = (std::vector< Dali::Actor > *)jarg1;
54844   arg2 = (int)jarg2;
54845   arg3 = (int)jarg3;
54846   {
54847     try {
54848       try {
54849         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
54850       }
54851       catch(std::out_of_range &_e) {
54852         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54853         return ;
54854       }
54855       catch(std::invalid_argument &_e) {
54856         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
54857         return ;
54858       }
54859
54860     } CALL_CATCH_EXCEPTION();
54861   }
54862
54863 }
54864
54865
54866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
54867   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54868   int arg2 ;
54869   std::vector< Dali::Actor > *arg3 = 0 ;
54870
54871   arg1 = (std::vector< Dali::Actor > *)jarg1;
54872   arg2 = (int)jarg2;
54873   arg3 = (std::vector< Dali::Actor > *)jarg3;
54874   if (!arg3) {
54875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
54876     return ;
54877   }
54878   {
54879     try {
54880       try {
54881         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
54882       }
54883       catch(std::out_of_range &_e) {
54884         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54885         return ;
54886       }
54887
54888     } CALL_CATCH_EXCEPTION();
54889   }
54890
54891 }
54892
54893
54894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
54895   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54896
54897   arg1 = (std::vector< Dali::Actor > *)jarg1;
54898   {
54899     try {
54900       delete arg1;
54901     } CALL_CATCH_EXCEPTION();
54902   }
54903
54904 }
54905
54906
54907 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
54908   bool jresult ;
54909   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
54910   bool result;
54911
54912   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
54913   {
54914     try {
54915       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
54916     } CALL_CATCH_EXCEPTION(0);
54917   }
54918
54919   jresult = result;
54920   return jresult;
54921 }
54922
54923
54924 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
54925   unsigned long jresult ;
54926   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
54927   std::size_t result;
54928
54929   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
54930   {
54931     try {
54932       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
54933     } CALL_CATCH_EXCEPTION(0);
54934   }
54935
54936   jresult = (unsigned long)result;
54937   return jresult;
54938 }
54939
54940
54941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
54942   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
54943   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
54944
54945   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
54946   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
54947   {
54948     try {
54949       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
54950     } CALL_CATCH_EXCEPTION();
54951   }
54952
54953 }
54954
54955
54956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
54957   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
54958   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
54959
54960   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
54961   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
54962   {
54963     try {
54964       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
54965     } CALL_CATCH_EXCEPTION();
54966   }
54967
54968 }
54969
54970
54971 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
54972   bool jresult ;
54973   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
54974   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
54975   bool result;
54976
54977   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
54978   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
54979   if (!arg2) {
54980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
54981     return 0;
54982   }
54983   {
54984     try {
54985       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
54986     } CALL_CATCH_EXCEPTION(0);
54987   }
54988
54989   jresult = result;
54990   return jresult;
54991 }
54992
54993
54994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
54995   void * jresult ;
54996   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
54997
54998   {
54999     try {
55000       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
55001     } CALL_CATCH_EXCEPTION(0);
55002   }
55003
55004   jresult = (void *)result;
55005   return jresult;
55006 }
55007
55008
55009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
55010   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
55011
55012   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
55013   {
55014     try {
55015       delete arg1;
55016     } CALL_CATCH_EXCEPTION();
55017   }
55018
55019 }
55020
55021
55022 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
55023   bool jresult ;
55024   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
55025   bool result;
55026
55027   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
55028   {
55029     try {
55030       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);
55031     } CALL_CATCH_EXCEPTION(0);
55032   }
55033
55034   jresult = result;
55035   return jresult;
55036 }
55037
55038
55039 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
55040   unsigned long jresult ;
55041   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
55042   std::size_t result;
55043
55044   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
55045   {
55046     try {
55047       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);
55048     } CALL_CATCH_EXCEPTION(0);
55049   }
55050
55051   jresult = (unsigned long)result;
55052   return jresult;
55053 }
55054
55055
55056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
55057   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
55058   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
55059
55060   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
55061   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
55062   {
55063     try {
55064       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
55065     } CALL_CATCH_EXCEPTION();
55066   }
55067
55068 }
55069
55070
55071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
55072   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
55073   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
55074
55075   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
55076   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
55077   {
55078     try {
55079       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
55080     } CALL_CATCH_EXCEPTION();
55081   }
55082
55083 }
55084
55085
55086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
55087   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
55088   Dali::Actor arg2 ;
55089   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
55090   Dali::Actor *argp2 ;
55091
55092   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
55093   argp2 = (Dali::Actor *)jarg2;
55094   if (!argp2) {
55095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55096     return ;
55097   }
55098   arg2 = *argp2;
55099   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
55100   {
55101     try {
55102       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
55103     } CALL_CATCH_EXCEPTION();
55104   }
55105
55106 }
55107
55108
55109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
55110   void * jresult ;
55111   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
55112
55113   {
55114     try {
55115       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
55116     } CALL_CATCH_EXCEPTION(0);
55117   }
55118
55119   jresult = (void *)result;
55120   return jresult;
55121 }
55122
55123
55124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
55125   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
55126
55127   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
55128   {
55129     try {
55130       delete arg1;
55131     } CALL_CATCH_EXCEPTION();
55132   }
55133
55134 }
55135
55136
55137 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
55138   bool jresult ;
55139   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
55140   bool result;
55141
55142   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
55143   {
55144     try {
55145       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
55146     } CALL_CATCH_EXCEPTION(0);
55147   }
55148
55149   jresult = result;
55150   return jresult;
55151 }
55152
55153
55154 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
55155   unsigned long jresult ;
55156   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
55157   std::size_t result;
55158
55159   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
55160   {
55161     try {
55162       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
55163     } CALL_CATCH_EXCEPTION(0);
55164   }
55165
55166   jresult = (unsigned long)result;
55167   return jresult;
55168 }
55169
55170
55171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
55172   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
55173   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
55174
55175   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
55176   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
55177   {
55178     try {
55179       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
55180     } CALL_CATCH_EXCEPTION();
55181   }
55182
55183 }
55184
55185
55186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
55187   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
55188   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
55189
55190   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
55191   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
55192   {
55193     try {
55194       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
55195     } CALL_CATCH_EXCEPTION();
55196   }
55197
55198 }
55199
55200
55201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55202   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
55203   Dali::Actor arg2 ;
55204   Dali::Actor arg3 ;
55205   Dali::Actor *argp2 ;
55206   Dali::Actor *argp3 ;
55207
55208   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
55209   argp2 = (Dali::Actor *)jarg2;
55210   if (!argp2) {
55211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55212     return ;
55213   }
55214   arg2 = *argp2;
55215   argp3 = (Dali::Actor *)jarg3;
55216   if (!argp3) {
55217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55218     return ;
55219   }
55220   arg3 = *argp3;
55221   {
55222     try {
55223       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
55224     } CALL_CATCH_EXCEPTION();
55225   }
55226
55227 }
55228
55229
55230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
55231   void * jresult ;
55232   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
55233
55234   {
55235     try {
55236       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
55237     } CALL_CATCH_EXCEPTION(0);
55238   }
55239
55240   jresult = (void *)result;
55241   return jresult;
55242 }
55243
55244
55245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
55246   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
55247
55248   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
55249   {
55250     try {
55251       delete arg1;
55252     } CALL_CATCH_EXCEPTION();
55253   }
55254
55255 }
55256
55257
55258 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
55259   bool jresult ;
55260   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
55261   bool result;
55262
55263   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
55264   {
55265     try {
55266       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
55267     } CALL_CATCH_EXCEPTION(0);
55268   }
55269
55270   jresult = result;
55271   return jresult;
55272 }
55273
55274
55275 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
55276   unsigned long jresult ;
55277   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
55278   std::size_t result;
55279
55280   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
55281   {
55282     try {
55283       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
55284     } CALL_CATCH_EXCEPTION(0);
55285   }
55286
55287   jresult = (unsigned long)result;
55288   return jresult;
55289 }
55290
55291
55292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
55293   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
55294   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
55295
55296   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
55297   arg2 = (void (*)(Dali::Actor,bool))jarg2;
55298   {
55299     try {
55300       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
55301     } CALL_CATCH_EXCEPTION();
55302   }
55303
55304 }
55305
55306
55307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
55308   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
55309   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
55310
55311   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
55312   arg2 = (void (*)(Dali::Actor,bool))jarg2;
55313   {
55314     try {
55315       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
55316     } CALL_CATCH_EXCEPTION();
55317   }
55318
55319 }
55320
55321
55322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, bool jarg3) {
55323   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
55324   Dali::Actor arg2 ;
55325   bool arg3 ;
55326   Dali::Actor *argp2 ;
55327
55328   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
55329   argp2 = (Dali::Actor *)jarg2;
55330   if (!argp2) {
55331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55332     return ;
55333   }
55334   arg2 = *argp2;
55335   arg3 = jarg3 ? true : false;
55336   {
55337     try {
55338       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
55339     } CALL_CATCH_EXCEPTION();
55340   }
55341
55342 }
55343
55344
55345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
55346   void * jresult ;
55347   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
55348
55349   {
55350     try {
55351       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
55352     } CALL_CATCH_EXCEPTION(0);
55353   }
55354
55355   jresult = (void *)result;
55356   return jresult;
55357 }
55358
55359
55360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
55361   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
55362
55363   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
55364   {
55365     try {
55366       delete arg1;
55367     } CALL_CATCH_EXCEPTION();
55368   }
55369
55370 }
55371
55372
55373 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
55374   bool jresult ;
55375   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
55376   bool result;
55377
55378   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
55379   {
55380     try {
55381       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);
55382     } CALL_CATCH_EXCEPTION(0);
55383   }
55384
55385   jresult = result;
55386   return jresult;
55387 }
55388
55389
55390 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
55391   unsigned long jresult ;
55392   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
55393   std::size_t result;
55394
55395   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
55396   {
55397     try {
55398       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);
55399     } CALL_CATCH_EXCEPTION(0);
55400   }
55401
55402   jresult = (unsigned long)result;
55403   return jresult;
55404 }
55405
55406
55407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
55408   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
55409   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
55410
55411   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
55412   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
55413   {
55414     try {
55415       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
55416     } CALL_CATCH_EXCEPTION();
55417   }
55418
55419 }
55420
55421
55422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
55423   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
55424   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
55425
55426   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
55427   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
55428   {
55429     try {
55430       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
55431     } CALL_CATCH_EXCEPTION();
55432   }
55433
55434 }
55435
55436
55437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
55438   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
55439   Dali::Toolkit::StyleManager arg2 ;
55440   Dali::StyleChange::Type arg3 ;
55441   Dali::Toolkit::StyleManager *argp2 ;
55442
55443   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
55444   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
55445   if (!argp2) {
55446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
55447     return ;
55448   }
55449   arg2 = *argp2;
55450   arg3 = (Dali::StyleChange::Type)jarg3;
55451   {
55452     try {
55453       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
55454     } CALL_CATCH_EXCEPTION();
55455   }
55456
55457 }
55458
55459
55460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
55461   void * jresult ;
55462   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
55463
55464   {
55465     try {
55466       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
55467     } CALL_CATCH_EXCEPTION(0);
55468   }
55469
55470   jresult = (void *)result;
55471   return jresult;
55472 }
55473
55474
55475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
55476   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
55477
55478   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
55479   {
55480     try {
55481       delete arg1;
55482     } CALL_CATCH_EXCEPTION();
55483   }
55484
55485 }
55486
55487
55488 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
55489   bool jresult ;
55490   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
55491   bool result;
55492
55493   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
55494   {
55495     try {
55496       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
55497     } CALL_CATCH_EXCEPTION(0);
55498   }
55499
55500   jresult = result;
55501   return jresult;
55502 }
55503
55504
55505 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
55506   unsigned long jresult ;
55507   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
55508   std::size_t result;
55509
55510   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
55511   {
55512     try {
55513       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
55514     } CALL_CATCH_EXCEPTION(0);
55515   }
55516
55517   jresult = (unsigned long)result;
55518   return jresult;
55519 }
55520
55521
55522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
55523   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
55524   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
55525
55526   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
55527   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
55528   {
55529     try {
55530       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
55531     } CALL_CATCH_EXCEPTION();
55532   }
55533
55534 }
55535
55536
55537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
55538   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
55539   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
55540
55541   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
55542   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
55543   {
55544     try {
55545       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
55546     } CALL_CATCH_EXCEPTION();
55547   }
55548
55549 }
55550
55551
55552 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
55553   bool jresult ;
55554   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
55555   Dali::Toolkit::Button arg2 ;
55556   Dali::Toolkit::Button *argp2 ;
55557   bool result;
55558
55559   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
55560   argp2 = (Dali::Toolkit::Button *)jarg2;
55561   if (!argp2) {
55562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
55563     return 0;
55564   }
55565   arg2 = *argp2;
55566   {
55567     try {
55568       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
55569     } CALL_CATCH_EXCEPTION(0);
55570   }
55571
55572   jresult = result;
55573   return jresult;
55574 }
55575
55576
55577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
55578   void * jresult ;
55579   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
55580
55581   {
55582     try {
55583       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
55584     } CALL_CATCH_EXCEPTION(0);
55585   }
55586
55587   jresult = (void *)result;
55588   return jresult;
55589 }
55590
55591
55592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
55593   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
55594
55595   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
55596   {
55597     try {
55598       delete arg1;
55599     } CALL_CATCH_EXCEPTION();
55600   }
55601
55602 }
55603
55604
55605 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
55606   bool jresult ;
55607   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
55608   bool result;
55609
55610   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
55611   {
55612     try {
55613       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
55614     } CALL_CATCH_EXCEPTION(0);
55615   }
55616
55617   jresult = result;
55618   return jresult;
55619 }
55620
55621
55622 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
55623   unsigned long jresult ;
55624   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
55625   std::size_t result;
55626
55627   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
55628   {
55629     try {
55630       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
55631     } CALL_CATCH_EXCEPTION(0);
55632   }
55633
55634   jresult = (unsigned long)result;
55635   return jresult;
55636 }
55637
55638
55639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
55640   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
55641   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
55642
55643   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
55644   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
55645   {
55646     try {
55647       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
55648     } CALL_CATCH_EXCEPTION();
55649   }
55650
55651 }
55652
55653
55654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
55655   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
55656   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
55657
55658   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
55659   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
55660   {
55661     try {
55662       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
55663     } CALL_CATCH_EXCEPTION();
55664   }
55665
55666 }
55667
55668
55669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
55670   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
55671   Dali::Toolkit::GaussianBlurView arg2 ;
55672   Dali::Toolkit::GaussianBlurView *argp2 ;
55673
55674   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
55675   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
55676   if (!argp2) {
55677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
55678     return ;
55679   }
55680   arg2 = *argp2;
55681   {
55682     try {
55683       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
55684     } CALL_CATCH_EXCEPTION();
55685   }
55686
55687 }
55688
55689
55690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
55691   void * jresult ;
55692   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
55693
55694   {
55695     try {
55696       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
55697     } CALL_CATCH_EXCEPTION(0);
55698   }
55699
55700   jresult = (void *)result;
55701   return jresult;
55702 }
55703
55704
55705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
55706   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
55707
55708   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
55709   {
55710     try {
55711       delete arg1;
55712     } CALL_CATCH_EXCEPTION();
55713   }
55714
55715 }
55716
55717
55718 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
55719   bool jresult ;
55720   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
55721   bool result;
55722
55723   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
55724   {
55725     try {
55726       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);
55727     } CALL_CATCH_EXCEPTION(0);
55728   }
55729
55730   jresult = result;
55731   return jresult;
55732 }
55733
55734
55735 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
55736   unsigned long jresult ;
55737   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
55738   std::size_t result;
55739
55740   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
55741   {
55742     try {
55743       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);
55744     } CALL_CATCH_EXCEPTION(0);
55745   }
55746
55747   jresult = (unsigned long)result;
55748   return jresult;
55749 }
55750
55751
55752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
55753   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
55754   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
55755
55756   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
55757   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
55758   {
55759     try {
55760       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
55761     } CALL_CATCH_EXCEPTION();
55762   }
55763
55764 }
55765
55766
55767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
55768   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
55769   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
55770
55771   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
55772   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
55773   {
55774     try {
55775       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
55776     } CALL_CATCH_EXCEPTION();
55777   }
55778
55779 }
55780
55781
55782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, bool jarg4) {
55783   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
55784   Dali::Toolkit::PageTurnView arg2 ;
55785   unsigned int arg3 ;
55786   bool arg4 ;
55787   Dali::Toolkit::PageTurnView *argp2 ;
55788
55789   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
55790   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
55791   if (!argp2) {
55792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
55793     return ;
55794   }
55795   arg2 = *argp2;
55796   arg3 = (unsigned int)jarg3;
55797   arg4 = jarg4 ? true : false;
55798   {
55799     try {
55800       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
55801     } CALL_CATCH_EXCEPTION();
55802   }
55803
55804 }
55805
55806
55807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
55808   void * jresult ;
55809   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
55810
55811   {
55812     try {
55813       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
55814     } CALL_CATCH_EXCEPTION(0);
55815   }
55816
55817   jresult = (void *)result;
55818   return jresult;
55819 }
55820
55821
55822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
55823   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
55824
55825   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
55826   {
55827     try {
55828       delete arg1;
55829     } CALL_CATCH_EXCEPTION();
55830   }
55831
55832 }
55833
55834
55835 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
55836   bool jresult ;
55837   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
55838   bool result;
55839
55840   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
55841   {
55842     try {
55843       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
55844     } CALL_CATCH_EXCEPTION(0);
55845   }
55846
55847   jresult = result;
55848   return jresult;
55849 }
55850
55851
55852 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
55853   unsigned long jresult ;
55854   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
55855   std::size_t result;
55856
55857   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
55858   {
55859     try {
55860       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
55861     } CALL_CATCH_EXCEPTION(0);
55862   }
55863
55864   jresult = (unsigned long)result;
55865   return jresult;
55866 }
55867
55868
55869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
55870   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
55871   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
55872
55873   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
55874   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
55875   {
55876     try {
55877       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
55878     } CALL_CATCH_EXCEPTION();
55879   }
55880 }
55881
55882
55883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
55884   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
55885   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
55886
55887   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
55888   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
55889   {
55890     try {
55891       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
55892     } CALL_CATCH_EXCEPTION();
55893   }
55894 }
55895
55896
55897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
55898   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
55899   Dali::Toolkit::PageTurnView arg2 ;
55900   Dali::Toolkit::PageTurnView *argp2 ;
55901
55902   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
55903   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
55904   if (!argp2) {
55905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
55906     return ;
55907   }
55908   arg2 = *argp2;
55909   {
55910     try {
55911       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
55912     } CALL_CATCH_EXCEPTION();
55913   }
55914 }
55915
55916
55917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
55918   void * jresult ;
55919   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
55920
55921   {
55922     try {
55923       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
55924     } CALL_CATCH_EXCEPTION(0);
55925   }
55926
55927   jresult = (void *)result;
55928   return jresult;
55929 }
55930
55931
55932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
55933   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
55934
55935   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
55936   {
55937     try {
55938       delete arg1;
55939     } CALL_CATCH_EXCEPTION();
55940   }
55941
55942 }
55943
55944
55945 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
55946   bool jresult ;
55947   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
55948   bool result;
55949
55950   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
55951   {
55952     try {
55953       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);
55954     } CALL_CATCH_EXCEPTION(0);
55955   }
55956
55957   jresult = result;
55958   return jresult;
55959 }
55960
55961
55962 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
55963   unsigned long jresult ;
55964   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
55965   std::size_t result;
55966
55967   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
55968   {
55969     try {
55970       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);
55971     } CALL_CATCH_EXCEPTION(0);
55972   }
55973
55974   jresult = (unsigned long)result;
55975   return jresult;
55976 }
55977
55978
55979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
55980   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
55981   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
55982
55983   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
55984   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
55985   {
55986     try {
55987       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
55988     } CALL_CATCH_EXCEPTION();
55989   }
55990
55991 }
55992
55993
55994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
55995   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
55996   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
55997
55998   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
55999   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
56000   {
56001     try {
56002       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
56003     } CALL_CATCH_EXCEPTION();
56004   }
56005
56006 }
56007
56008
56009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
56010   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
56011   Dali::Toolkit::ProgressBar arg2 ;
56012   float arg3 ;
56013   float arg4 ;
56014   Dali::Toolkit::ProgressBar *argp2 ;
56015
56016   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
56017   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
56018   if (!argp2) {
56019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
56020     return ;
56021   }
56022   arg2 = *argp2;
56023   arg3 = (float)jarg3;
56024   arg4 = (float)jarg4;
56025   {
56026     try {
56027       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
56028     } CALL_CATCH_EXCEPTION();
56029   }
56030
56031 }
56032
56033
56034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
56035   void * jresult ;
56036   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
56037
56038   {
56039     try {
56040       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
56041     } CALL_CATCH_EXCEPTION(0);
56042   }
56043
56044   jresult = (void *)result;
56045   return jresult;
56046 }
56047
56048
56049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
56050   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
56051
56052   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
56053   {
56054     try {
56055       delete arg1;
56056     } CALL_CATCH_EXCEPTION();
56057   }
56058
56059 }
56060
56061
56062 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
56063   bool jresult ;
56064   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
56065   bool result;
56066
56067   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
56068   {
56069     try {
56070       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);
56071     } CALL_CATCH_EXCEPTION(0);
56072   }
56073
56074   jresult = result;
56075   return jresult;
56076 }
56077
56078
56079 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
56080   unsigned long jresult ;
56081   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
56082   std::size_t result;
56083
56084   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
56085   {
56086     try {
56087       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);
56088     } CALL_CATCH_EXCEPTION(0);
56089   }
56090
56091   jresult = (unsigned long)result;
56092   return jresult;
56093 }
56094
56095
56096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
56097   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
56098   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
56099
56100   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
56101   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
56102   {
56103     try {
56104       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56105     } CALL_CATCH_EXCEPTION();
56106   }
56107
56108 }
56109
56110
56111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
56112   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
56113   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
56114
56115   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
56116   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
56117   {
56118     try {
56119       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56120     } CALL_CATCH_EXCEPTION();
56121   }
56122
56123 }
56124
56125
56126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
56127   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
56128   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
56129
56130   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
56131   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
56132   if (!arg2) {
56133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
56134     return ;
56135   }
56136   {
56137     try {
56138       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
56139     } CALL_CATCH_EXCEPTION();
56140   }
56141
56142 }
56143
56144
56145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
56146   void * jresult ;
56147   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
56148
56149   {
56150     try {
56151       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
56152     } CALL_CATCH_EXCEPTION(0);
56153   }
56154
56155   jresult = (void *)result;
56156   return jresult;
56157 }
56158
56159
56160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
56161   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
56162
56163   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
56164   {
56165     try {
56166       delete arg1;
56167     } CALL_CATCH_EXCEPTION();
56168   }
56169
56170 }
56171
56172
56173 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
56174   bool jresult ;
56175   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
56176   bool result;
56177
56178   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
56179   {
56180     try {
56181       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
56182     } CALL_CATCH_EXCEPTION(0);
56183   }
56184
56185   jresult = result;
56186   return jresult;
56187 }
56188
56189
56190 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
56191   unsigned long jresult ;
56192   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
56193   std::size_t result;
56194
56195   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
56196   {
56197     try {
56198       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
56199     } CALL_CATCH_EXCEPTION(0);
56200   }
56201
56202   jresult = (unsigned long)result;
56203   return jresult;
56204 }
56205
56206
56207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
56208   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
56209   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
56210
56211   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
56212   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
56213   {
56214     try {
56215       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56216     } CALL_CATCH_EXCEPTION();
56217   }
56218
56219 }
56220
56221
56222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
56223   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
56224   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
56225
56226   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
56227   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
56228   {
56229     try {
56230       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56231     } CALL_CATCH_EXCEPTION();
56232   }
56233
56234 }
56235
56236
56237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
56238   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
56239   Dali::Vector2 *arg2 = 0 ;
56240
56241   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
56242   arg2 = (Dali::Vector2 *)jarg2;
56243   if (!arg2) {
56244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
56245     return ;
56246   }
56247   {
56248     try {
56249       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
56250     } CALL_CATCH_EXCEPTION();
56251   }
56252
56253 }
56254
56255
56256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
56257   void * jresult ;
56258   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
56259
56260   {
56261     try {
56262       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
56263     } CALL_CATCH_EXCEPTION(0);
56264   }
56265
56266   jresult = (void *)result;
56267   return jresult;
56268 }
56269
56270
56271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
56272   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
56273
56274   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
56275   {
56276     try {
56277       delete arg1;
56278     } CALL_CATCH_EXCEPTION();
56279   }
56280
56281 }
56282
56283
56284
56285 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
56286   bool jresult ;
56287   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
56288   bool result;
56289
56290   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
56291   {
56292     try {
56293       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);
56294     } CALL_CATCH_EXCEPTION(0);
56295   }
56296
56297   jresult = result;
56298   return jresult;
56299 }
56300
56301
56302 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
56303   unsigned long jresult ;
56304   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
56305   std::size_t result;
56306
56307   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
56308   {
56309     try {
56310       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);
56311     } CALL_CATCH_EXCEPTION(0);
56312   }
56313
56314   jresult = (unsigned long)result;
56315   return jresult;
56316 }
56317
56318
56319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
56320   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
56321   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
56322
56323   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
56324   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
56325   {
56326     try {
56327       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56328     } CALL_CATCH_EXCEPTION();
56329   }
56330
56331 }
56332
56333
56334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
56335   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
56336   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
56337
56338   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
56339   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
56340   {
56341     try {
56342       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56343     } CALL_CATCH_EXCEPTION();
56344   }
56345
56346 }
56347
56348
56349 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
56350   bool jresult ;
56351   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
56352   Dali::Toolkit::Control arg2 ;
56353   Dali::KeyEvent *arg3 = 0 ;
56354   Dali::Toolkit::Control *argp2 ;
56355   bool result;
56356
56357   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
56358   argp2 = (Dali::Toolkit::Control *)jarg2;
56359   if (!argp2) {
56360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
56361     return 0;
56362   }
56363   arg2 = *argp2;
56364   arg3 = (Dali::KeyEvent *)jarg3;
56365   if (!arg3) {
56366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56367     return 0;
56368   }
56369   {
56370     try {
56371       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);
56372     } CALL_CATCH_EXCEPTION(0);
56373   }
56374
56375   jresult = result;
56376   return jresult;
56377 }
56378
56379
56380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
56381   void * jresult ;
56382   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
56383
56384   {
56385     try {
56386       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
56387     } CALL_CATCH_EXCEPTION(0);
56388   }
56389
56390   jresult = (void *)result;
56391   return jresult;
56392 }
56393
56394
56395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
56396   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
56397
56398   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
56399   {
56400     try {
56401       delete arg1;
56402     } CALL_CATCH_EXCEPTION();
56403   }
56404
56405 }
56406
56407
56408 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
56409   bool jresult ;
56410   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56411   bool result;
56412
56413   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56414   {
56415     try {
56416       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
56417     } CALL_CATCH_EXCEPTION(0);
56418   }
56419
56420   jresult = result;
56421   return jresult;
56422 }
56423
56424
56425 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
56426   unsigned long jresult ;
56427   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56428   std::size_t result;
56429
56430   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56431   {
56432     try {
56433       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
56434     } CALL_CATCH_EXCEPTION(0);
56435   }
56436
56437   jresult = (unsigned long)result;
56438   return jresult;
56439 }
56440
56441
56442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
56443   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56444   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
56445
56446   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56447   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
56448   {
56449     try {
56450       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
56451     } CALL_CATCH_EXCEPTION();
56452   }
56453
56454 }
56455
56456
56457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
56458   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56459   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
56460
56461   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56462   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
56463   {
56464     try {
56465       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
56466     } CALL_CATCH_EXCEPTION();
56467   }
56468
56469 }
56470
56471
56472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
56473   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56474   Dali::Toolkit::Control arg2 ;
56475   Dali::Toolkit::Control *argp2 ;
56476
56477   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56478   argp2 = (Dali::Toolkit::Control *)jarg2;
56479   if (!argp2) {
56480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
56481     return ;
56482   }
56483   arg2 = *argp2;
56484   {
56485     try {
56486       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
56487     } CALL_CATCH_EXCEPTION();
56488   }
56489
56490 }
56491
56492
56493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
56494   void * jresult ;
56495   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
56496
56497   {
56498     try {
56499       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
56500     } CALL_CATCH_EXCEPTION(0);
56501   }
56502
56503   jresult = (void *)result;
56504   return jresult;
56505 }
56506
56507
56508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
56509   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56510
56511   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56512   {
56513     try {
56514       delete arg1;
56515     } CALL_CATCH_EXCEPTION();
56516   }
56517
56518 }
56519
56520
56521 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
56522   bool jresult ;
56523   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
56524   bool result;
56525
56526   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
56527   {
56528     try {
56529       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
56530     } CALL_CATCH_EXCEPTION(0);
56531   }
56532
56533   jresult = result;
56534   return jresult;
56535 }
56536
56537
56538 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
56539   unsigned long jresult ;
56540   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
56541   std::size_t result;
56542
56543   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
56544   {
56545     try {
56546       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
56547     } CALL_CATCH_EXCEPTION(0);
56548   }
56549
56550   jresult = (unsigned long)result;
56551   return jresult;
56552 }
56553
56554
56555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
56556   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
56557   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
56558
56559   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
56560   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
56561   {
56562     try {
56563       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
56564     } CALL_CATCH_EXCEPTION();
56565   }
56566
56567 }
56568
56569
56570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
56571   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
56572   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
56573
56574   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
56575   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
56576   {
56577     try {
56578       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
56579     } CALL_CATCH_EXCEPTION();
56580   }
56581
56582 }
56583
56584
56585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
56586   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
56587   Dali::Toolkit::VideoView *arg2 = 0 ;
56588
56589   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
56590   arg2 = (Dali::Toolkit::VideoView *)jarg2;
56591   if (!arg2) {
56592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
56593     return ;
56594   }
56595   {
56596     try {
56597       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
56598     } CALL_CATCH_EXCEPTION();
56599   }
56600
56601 }
56602
56603
56604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
56605   void * jresult ;
56606   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
56607
56608   {
56609     try {
56610       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
56611     } CALL_CATCH_EXCEPTION(0);
56612   }
56613
56614   jresult = (void *)result;
56615   return jresult;
56616 }
56617
56618
56619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
56620   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
56621
56622   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
56623   {
56624     try {
56625       delete arg1;
56626     } CALL_CATCH_EXCEPTION();
56627   }
56628
56629 }
56630
56631
56632 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
56633   bool jresult ;
56634   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
56635   bool result;
56636
56637   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
56638   {
56639     try {
56640       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
56641     } CALL_CATCH_EXCEPTION(0);
56642   }
56643
56644   jresult = result;
56645   return jresult;
56646 }
56647
56648
56649 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
56650   unsigned long jresult ;
56651   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
56652   std::size_t result;
56653
56654   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
56655   {
56656     try {
56657       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
56658     } CALL_CATCH_EXCEPTION(0);
56659   }
56660
56661   jresult = (unsigned long)result;
56662   return jresult;
56663 }
56664
56665
56666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
56667   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
56668   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
56669
56670   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
56671   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
56672   {
56673     try {
56674       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
56675     } CALL_CATCH_EXCEPTION();
56676   }
56677
56678 }
56679
56680
56681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
56682   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
56683   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
56684
56685   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
56686   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
56687   {
56688     try {
56689       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
56690     } CALL_CATCH_EXCEPTION();
56691   }
56692
56693 }
56694
56695
56696 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
56697   bool jresult ;
56698   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
56699   Dali::Toolkit::Slider arg2 ;
56700   float arg3 ;
56701   Dali::Toolkit::Slider *argp2 ;
56702   bool result;
56703
56704   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
56705   argp2 = (Dali::Toolkit::Slider *)jarg2;
56706   if (!argp2) {
56707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
56708     return 0;
56709   }
56710   arg2 = *argp2;
56711   arg3 = (float)jarg3;
56712   {
56713     try {
56714       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
56715     } CALL_CATCH_EXCEPTION(0);
56716   }
56717
56718   jresult = result;
56719   return jresult;
56720 }
56721
56722
56723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
56724   void * jresult ;
56725   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
56726
56727   {
56728     try {
56729       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
56730     } CALL_CATCH_EXCEPTION(0);
56731   }
56732
56733   jresult = (void *)result;
56734   return jresult;
56735 }
56736
56737
56738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
56739   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
56740
56741   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
56742   {
56743     try {
56744       delete arg1;
56745     } CALL_CATCH_EXCEPTION();
56746   }
56747
56748 }
56749
56750
56751 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
56752   bool jresult ;
56753   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
56754   bool result;
56755
56756   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
56757   {
56758     try {
56759       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
56760     } CALL_CATCH_EXCEPTION(0);
56761   }
56762
56763   jresult = result;
56764   return jresult;
56765 }
56766
56767
56768 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
56769   unsigned long jresult ;
56770   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
56771   std::size_t result;
56772
56773   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
56774   {
56775     try {
56776       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
56777     } CALL_CATCH_EXCEPTION(0);
56778   }
56779
56780   jresult = (unsigned long)result;
56781   return jresult;
56782 }
56783
56784
56785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
56786   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
56787   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
56788
56789   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
56790   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
56791   {
56792     try {
56793       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
56794     } CALL_CATCH_EXCEPTION();
56795   }
56796
56797 }
56798
56799
56800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
56801   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
56802   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
56803
56804   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
56805   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
56806   {
56807     try {
56808       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
56809     } CALL_CATCH_EXCEPTION();
56810   }
56811
56812 }
56813
56814
56815 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
56816   bool jresult ;
56817   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
56818   Dali::Toolkit::Slider arg2 ;
56819   int arg3 ;
56820   Dali::Toolkit::Slider *argp2 ;
56821   bool result;
56822
56823   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
56824   argp2 = (Dali::Toolkit::Slider *)jarg2;
56825   if (!argp2) {
56826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
56827     return 0;
56828   }
56829   arg2 = *argp2;
56830   arg3 = (int)jarg3;
56831   {
56832     try {
56833       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
56834     } CALL_CATCH_EXCEPTION(0);
56835   }
56836
56837   jresult = result;
56838   return jresult;
56839 }
56840
56841
56842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
56843   void * jresult ;
56844   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
56845
56846   {
56847     try {
56848       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
56849     } CALL_CATCH_EXCEPTION(0);
56850   }
56851
56852   jresult = (void *)result;
56853   return jresult;
56854 }
56855
56856
56857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
56858   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
56859
56860   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
56861   {
56862     try {
56863       delete arg1;
56864     } CALL_CATCH_EXCEPTION();
56865   }
56866
56867 }
56868
56869
56870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
56871   void * jresult ;
56872   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
56873
56874   {
56875     try {
56876       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
56877     } CALL_CATCH_EXCEPTION(0);
56878   }
56879
56880   jresult = (void *)result;
56881   return jresult;
56882 }
56883
56884
56885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
56886   void * jresult ;
56887   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
56888   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
56889
56890   arg1 = (Dali::Toolkit::Ruler *)jarg1;
56891   {
56892     try {
56893       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
56894     } CALL_CATCH_EXCEPTION(0);
56895   }
56896
56897   jresult = (void *)result;
56898   return jresult;
56899 }
56900
56901
56902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
56903   void * jresult ;
56904   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
56905   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
56906
56907   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56908   if (!arg1) {
56909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
56910     return 0;
56911   }
56912   {
56913     try {
56914       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
56915     } CALL_CATCH_EXCEPTION(0);
56916   }
56917
56918   jresult = (void *)result;
56919   return jresult;
56920 }
56921
56922
56923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
56924   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56925
56926   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56927   {
56928     try {
56929       delete arg1;
56930     } CALL_CATCH_EXCEPTION();
56931   }
56932
56933 }
56934
56935
56936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
56937   void * jresult ;
56938   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56939   Dali::Toolkit::Ruler *result = 0 ;
56940
56941   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56942   {
56943     try {
56944       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
56945     } CALL_CATCH_EXCEPTION(0);
56946   }
56947
56948   jresult = (void *)result;
56949   return jresult;
56950 }
56951
56952
56953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
56954   void * jresult ;
56955   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56956   Dali::Toolkit::Ruler *result = 0 ;
56957
56958   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56959   {
56960     try {
56961       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
56962     } CALL_CATCH_EXCEPTION(0);
56963   }
56964
56965   jresult = (void *)result;
56966   return jresult;
56967 }
56968
56969
56970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
56971   void * jresult ;
56972   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56973   Dali::Toolkit::Ruler *result = 0 ;
56974
56975   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56976   {
56977     try {
56978       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
56979     } CALL_CATCH_EXCEPTION(0);
56980   }
56981
56982   jresult = (void *)result;
56983   return jresult;
56984 }
56985
56986
56987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
56988   void * jresult ;
56989   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56990   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
56991   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
56992
56993   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56994   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
56995   if (!arg2) {
56996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
56997     return 0;
56998   }
56999   {
57000     try {
57001       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
57002     } CALL_CATCH_EXCEPTION(0);
57003   }
57004
57005   jresult = (void *)result;
57006   return jresult;
57007 }
57008
57009
57010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
57011   void * jresult ;
57012   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57013   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
57014   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
57015
57016   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57017   arg2 = (Dali::Toolkit::Ruler *)jarg2;
57018   {
57019     try {
57020       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
57021     } CALL_CATCH_EXCEPTION(0);
57022   }
57023
57024   jresult = (void *)result;
57025   return jresult;
57026 }
57027
57028
57029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
57030   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57031
57032   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57033   {
57034     try {
57035       (arg1)->Reset();
57036     } CALL_CATCH_EXCEPTION();
57037   }
57038
57039 }
57040
57041
57042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
57043   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57044   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
57045
57046   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57047   arg2 = (Dali::Toolkit::Ruler *)jarg2;
57048   {
57049     try {
57050       (arg1)->Reset(arg2);
57051     } CALL_CATCH_EXCEPTION();
57052   }
57053
57054 }
57055
57056
57057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
57058   void * jresult ;
57059   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57060   Dali::Toolkit::Ruler *result = 0 ;
57061
57062   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57063   {
57064     try {
57065       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
57066     } CALL_CATCH_EXCEPTION(0);
57067   }
57068
57069   jresult = (void *)result;
57070   return jresult;
57071 }
57072
57073
57074 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
57075   float jresult ;
57076   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57077   float arg2 ;
57078   float arg3 ;
57079   float result;
57080
57081   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57082   arg2 = (float)jarg2;
57083   arg3 = (float)jarg3;
57084   {
57085     try {
57086       result = (float)(*arg1)->Snap(arg2,arg3);
57087     } CALL_CATCH_EXCEPTION(0);
57088   }
57089
57090   jresult = result;
57091   return jresult;
57092 }
57093
57094
57095 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
57096   float jresult ;
57097   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57098   float arg2 ;
57099   float result;
57100
57101   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57102   arg2 = (float)jarg2;
57103   {
57104     try {
57105       result = (float)(*arg1)->Snap(arg2);
57106     } CALL_CATCH_EXCEPTION(0);
57107   }
57108
57109   jresult = result;
57110   return jresult;
57111 }
57112
57113
57114 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) {
57115   float jresult ;
57116   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57117   unsigned int arg2 ;
57118   unsigned int *arg3 = 0 ;
57119   bool arg4 ;
57120   float result;
57121
57122   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57123   arg2 = (unsigned int)jarg2;
57124   arg3 = (unsigned int *)jarg3;
57125   arg4 = jarg4 ? true : false;
57126   {
57127     try {
57128       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
57129     } CALL_CATCH_EXCEPTION(0);
57130   }
57131
57132   jresult = result;
57133   return jresult;
57134 }
57135
57136
57137 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) {
57138   unsigned int jresult ;
57139   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57140   float arg2 ;
57141   bool arg3 ;
57142   unsigned int result;
57143
57144   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57145   arg2 = (float)jarg2;
57146   arg3 = jarg3 ? true : false;
57147   {
57148     try {
57149       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
57150     } CALL_CATCH_EXCEPTION(0);
57151   }
57152
57153   jresult = result;
57154   return jresult;
57155 }
57156
57157
57158 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
57159   unsigned int jresult ;
57160   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57161   unsigned int result;
57162
57163   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57164   {
57165     try {
57166       result = (unsigned int)(*arg1)->GetTotalPages();
57167     } CALL_CATCH_EXCEPTION(0);
57168   }
57169
57170   jresult = result;
57171   return jresult;
57172 }
57173
57174
57175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
57176   int jresult ;
57177   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57178   Dali::Toolkit::Ruler::RulerType result;
57179
57180   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57181   {
57182     try {
57183       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
57184     } CALL_CATCH_EXCEPTION(0);
57185   }
57186
57187   jresult = (int)result;
57188   return jresult;
57189 }
57190
57191
57192 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
57193   bool jresult ;
57194   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57195   bool result;
57196
57197   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57198   {
57199     try {
57200       result = (bool)(*arg1)->IsEnabled();
57201     } CALL_CATCH_EXCEPTION(0);
57202   }
57203
57204   jresult = result;
57205   return jresult;
57206 }
57207
57208
57209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
57210   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57211
57212   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57213   {
57214     try {
57215       (*arg1)->Enable();
57216     } CALL_CATCH_EXCEPTION();
57217   }
57218
57219 }
57220
57221
57222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
57223   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57224
57225   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57226   {
57227     try {
57228       (*arg1)->Disable();
57229     } CALL_CATCH_EXCEPTION();
57230   }
57231
57232 }
57233
57234
57235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
57236   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57237   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
57238   Dali::Toolkit::RulerDomain *argp2 ;
57239
57240   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57241   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
57242   if (!argp2) {
57243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
57244     return ;
57245   }
57246   arg2 = *argp2;
57247   {
57248     try {
57249       (*arg1)->SetDomain(arg2);
57250     } CALL_CATCH_EXCEPTION();
57251   }
57252
57253 }
57254
57255
57256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
57257   void * jresult ;
57258   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57259   Dali::Toolkit::RulerDomain *result = 0 ;
57260
57261   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57262   {
57263     try {
57264       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
57265     } CALL_CATCH_EXCEPTION(0);
57266   }
57267
57268   jresult = (void *)result;
57269   return jresult;
57270 }
57271
57272
57273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
57274   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57275
57276   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57277   {
57278     try {
57279       (*arg1)->DisableDomain();
57280     } CALL_CATCH_EXCEPTION();
57281   }
57282
57283 }
57284
57285
57286 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
57287   float jresult ;
57288   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57289   float arg2 ;
57290   float arg3 ;
57291   float arg4 ;
57292   float result;
57293
57294   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57295   arg2 = (float)jarg2;
57296   arg3 = (float)jarg3;
57297   arg4 = (float)jarg4;
57298   {
57299     try {
57300       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
57301     } CALL_CATCH_EXCEPTION(0);
57302   }
57303
57304   jresult = result;
57305   return jresult;
57306 }
57307
57308
57309 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
57310   float jresult ;
57311   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57312   float arg2 ;
57313   float arg3 ;
57314   float result;
57315
57316   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57317   arg2 = (float)jarg2;
57318   arg3 = (float)jarg3;
57319   {
57320     try {
57321       result = (float)(*arg1)->Clamp(arg2,arg3);
57322     } CALL_CATCH_EXCEPTION(0);
57323   }
57324
57325   jresult = result;
57326   return jresult;
57327 }
57328
57329
57330 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
57331   float jresult ;
57332   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57333   float arg2 ;
57334   float result;
57335
57336   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57337   arg2 = (float)jarg2;
57338   {
57339     try {
57340       result = (float)(*arg1)->Clamp(arg2);
57341     } CALL_CATCH_EXCEPTION(0);
57342   }
57343
57344   jresult = result;
57345   return jresult;
57346 }
57347
57348
57349 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
57350   float jresult ;
57351   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57352   float arg2 ;
57353   float arg3 ;
57354   float arg4 ;
57355   Dali::Toolkit::ClampState *arg5 = 0 ;
57356   float result;
57357
57358   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57359   arg2 = (float)jarg2;
57360   arg3 = (float)jarg3;
57361   arg4 = (float)jarg4;
57362   arg5 = (Dali::Toolkit::ClampState *)jarg5;
57363   if (!arg5) {
57364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
57365     return 0;
57366   }
57367   {
57368     try {
57369       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
57370     } CALL_CATCH_EXCEPTION(0);
57371   }
57372
57373   jresult = result;
57374   return jresult;
57375 }
57376
57377
57378 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
57379   float jresult ;
57380   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57381   float arg2 ;
57382   float arg3 ;
57383   float arg4 ;
57384   float arg5 ;
57385   float result;
57386
57387   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57388   arg2 = (float)jarg2;
57389   arg3 = (float)jarg3;
57390   arg4 = (float)jarg4;
57391   arg5 = (float)jarg5;
57392   {
57393     try {
57394       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
57395     } CALL_CATCH_EXCEPTION(0);
57396   }
57397
57398   jresult = result;
57399   return jresult;
57400 }
57401
57402
57403 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
57404   float jresult ;
57405   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57406   float arg2 ;
57407   float arg3 ;
57408   float arg4 ;
57409   float result;
57410
57411   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57412   arg2 = (float)jarg2;
57413   arg3 = (float)jarg3;
57414   arg4 = (float)jarg4;
57415   {
57416     try {
57417       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
57418     } CALL_CATCH_EXCEPTION(0);
57419   }
57420
57421   jresult = result;
57422   return jresult;
57423 }
57424
57425
57426 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
57427   float jresult ;
57428   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57429   float arg2 ;
57430   float arg3 ;
57431   float result;
57432
57433   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57434   arg2 = (float)jarg2;
57435   arg3 = (float)jarg3;
57436   {
57437     try {
57438       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
57439     } CALL_CATCH_EXCEPTION(0);
57440   }
57441
57442   jresult = result;
57443   return jresult;
57444 }
57445
57446
57447 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
57448   float jresult ;
57449   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57450   float arg2 ;
57451   float result;
57452
57453   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57454   arg2 = (float)jarg2;
57455   {
57456     try {
57457       result = (float)(*arg1)->SnapAndClamp(arg2);
57458     } CALL_CATCH_EXCEPTION(0);
57459   }
57460
57461   jresult = result;
57462   return jresult;
57463 }
57464
57465
57466 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
57467   float jresult ;
57468   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57469   float arg2 ;
57470   float arg3 ;
57471   float arg4 ;
57472   float arg5 ;
57473   Dali::Toolkit::ClampState *arg6 = 0 ;
57474   float result;
57475
57476   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57477   arg2 = (float)jarg2;
57478   arg3 = (float)jarg3;
57479   arg4 = (float)jarg4;
57480   arg5 = (float)jarg5;
57481   arg6 = (Dali::Toolkit::ClampState *)jarg6;
57482   if (!arg6) {
57483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
57484     return 0;
57485   }
57486   {
57487     try {
57488       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
57489     } CALL_CATCH_EXCEPTION(0);
57490   }
57491
57492   jresult = result;
57493   return jresult;
57494 }
57495
57496
57497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
57498   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57499
57500   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57501   {
57502     try {
57503       (*arg1)->Reference();
57504     } CALL_CATCH_EXCEPTION();
57505   }
57506
57507 }
57508
57509
57510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
57511   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57512
57513   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57514   {
57515     try {
57516       (*arg1)->Unreference();
57517     } CALL_CATCH_EXCEPTION();
57518   }
57519
57520 }
57521
57522
57523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
57524   int jresult ;
57525   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57526   int result;
57527
57528   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57529   {
57530     try {
57531       result = (int)(*arg1)->ReferenceCount();
57532     } CALL_CATCH_EXCEPTION(0);
57533   }
57534
57535   jresult = result;
57536   return jresult;
57537 }
57538
57539
57540 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
57541   bool jresult ;
57542   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
57543   bool result;
57544
57545   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
57546   {
57547     try {
57548       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
57549     } CALL_CATCH_EXCEPTION(0);
57550   }
57551
57552   jresult = result;
57553   return jresult;
57554 }
57555
57556
57557 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
57558   unsigned long jresult ;
57559   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
57560   std::size_t result;
57561
57562   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
57563   {
57564     try {
57565       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
57566     } CALL_CATCH_EXCEPTION(0);
57567   }
57568
57569   jresult = (unsigned long)result;
57570   return jresult;
57571 }
57572
57573
57574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
57575   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
57576   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
57577
57578   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
57579   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
57580   {
57581     try {
57582       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
57583     } CALL_CATCH_EXCEPTION();
57584   }
57585
57586 }
57587
57588
57589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
57590   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
57591   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
57592
57593   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
57594   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
57595   {
57596     try {
57597       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
57598     } CALL_CATCH_EXCEPTION();
57599   }
57600
57601 }
57602
57603
57604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
57605   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
57606   Dali::Toolkit::Control arg2 ;
57607   Dali::Toolkit::Control *argp2 ;
57608
57609   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
57610   argp2 = (Dali::Toolkit::Control *)jarg2;
57611   if (!argp2) {
57612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
57613     return ;
57614   }
57615   arg2 = *argp2;
57616   {
57617     try {
57618       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
57619     } CALL_CATCH_EXCEPTION();
57620   }
57621
57622 }
57623
57624
57625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
57626   void * jresult ;
57627   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
57628
57629   {
57630     try {
57631       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
57632     } CALL_CATCH_EXCEPTION(0);
57633   }
57634
57635   jresult = (void *)result;
57636   return jresult;
57637 }
57638
57639
57640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
57641   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
57642
57643   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
57644   {
57645     try {
57646       delete arg1;
57647     } CALL_CATCH_EXCEPTION();
57648   }
57649
57650 }
57651
57652 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
57653   Dali::RefObject *result = NULL;
57654
57655   if (arg1)
57656   {
57657     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
57658   }
57659   return result;
57660 }
57661
57662 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
57663     return (Dali::RefObject *)jarg1;
57664 }
57665
57666 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
57667     return (Dali::SignalObserver *)jarg1;
57668 }
57669
57670 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
57671     return (Dali::ConnectionTrackerInterface *)jarg1;
57672 }
57673
57674 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
57675     return (Dali::BaseHandle *)jarg1;
57676 }
57677
57678 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
57679     return (Dali::BaseHandle *)jarg1;
57680 }
57681
57682 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
57683     return (Dali::BaseHandle *)jarg1;
57684 }
57685
57686 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
57687     return (Dali::BaseHandle *)jarg1;
57688 }
57689
57690 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
57691     return (Dali::BaseHandle *)jarg1;
57692 }
57693
57694 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
57695     return (Dali::BaseHandle *)jarg1;
57696 }
57697
57698 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
57699     return (Dali::BaseHandle *)jarg1;
57700 }
57701
57702 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
57703     return (Dali::BaseHandle *)jarg1;
57704 }
57705
57706 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
57707     return (Dali::BaseHandle *)jarg1;
57708 }
57709
57710 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
57711     return (Dali::BaseHandle *)jarg1;
57712 }
57713
57714 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VertexBuffer_SWIGUpcast(Dali::VertexBuffer *jarg1) {
57715     return (Dali::BaseHandle *)jarg1;
57716 }
57717
57718 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
57719     return (Dali::BaseHandle *)jarg1;
57720 }
57721
57722 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
57723     return (Dali::Handle *)jarg1;
57724 }
57725
57726 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
57727     return (Dali::Handle *)jarg1;
57728 }
57729
57730 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
57731     return (Dali::BaseHandle *)jarg1;
57732 }
57733
57734 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
57735     return (Dali::BaseHandle *)jarg1;
57736 }
57737
57738 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
57739     return (Dali::Handle *)jarg1;
57740 }
57741
57742 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchEvent *jarg1) {
57743     return (Dali::BaseHandle *)jarg1;
57744 }
57745
57746 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Hover_SWIGUpcast(Dali::HoverEvent *jarg1) {
57747     return (Dali::BaseHandle *)jarg1;
57748 }
57749
57750 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Wheel_SWIGUpcast(Dali::WheelEvent *jarg1) {
57751     return (Dali::BaseHandle *)jarg1;
57752 }
57753
57754 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Key_SWIGUpcast(Dali::KeyEvent *jarg1) {
57755     return (Dali::BaseHandle *)jarg1;
57756 }
57757
57758 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Gesture_SWIGUpcast(Dali::Gesture *jarg1) {
57759     return (Dali::BaseHandle *)jarg1;
57760 }
57761
57762 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
57763     return (Dali::Handle *)jarg1;
57764 }
57765
57766 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
57767     return (Dali::GestureDetector *)jarg1;
57768 }
57769
57770 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
57771     return (Dali::Gesture *)jarg1;
57772 }
57773
57774 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
57775     return (Dali::Handle *)jarg1;
57776 }
57777
57778 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
57779     return (Dali::Actor *)jarg1;
57780 }
57781
57782 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
57783     return (Dali::RefObject *)jarg1;
57784 }
57785
57786 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
57787     return (Dali::Actor *)jarg1;
57788 }
57789
57790 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
57791     return (Dali::GestureDetector *)jarg1;
57792 }
57793
57794 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
57795     return (Dali::Gesture *)jarg1;
57796 }
57797
57798 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
57799     return (Dali::GestureDetector *)jarg1;
57800 }
57801
57802 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
57803     return (Dali::Gesture *)jarg1;
57804 }
57805
57806 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
57807     return (Dali::GestureDetector *)jarg1;
57808 }
57809
57810 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
57811     return (Dali::Gesture *)jarg1;
57812 }
57813
57814 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
57815     return (Dali::BaseHandle *)jarg1;
57816 }
57817
57818 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
57819     return (Dali::Handle *)jarg1;
57820 }
57821
57822 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
57823     return (Dali::Handle *)jarg1;
57824 }
57825
57826 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
57827     return (Dali::Handle *)jarg1;
57828 }
57829
57830 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
57831     return (Dali::RefObject *)jarg1;
57832 }
57833
57834 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
57835     return (Dali::Actor *)jarg1;
57836 }
57837
57838 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
57839     return (Dali::BaseHandle *)jarg1;
57840 }
57841
57842 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
57843     return (Dali::BaseHandle *)jarg1;
57844 }
57845
57846 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
57847     return (Dali::BaseHandle *)jarg1;
57848 }
57849
57850 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
57851     return (Dali::CustomActorImpl *)jarg1;
57852 }
57853
57854 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
57855     return (Dali::CustomActor *)jarg1;
57856 }
57857
57858 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
57859     return (Dali::BaseHandle *)jarg1;
57860 }
57861
57862 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
57863     return (Dali::Toolkit::Control *)jarg1;
57864 }
57865
57866 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
57867     return (Dali::Toolkit::Control *)jarg1;
57868 }
57869
57870 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
57871     return (Dali::Toolkit::Button *)jarg1;
57872 }
57873
57874 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
57875     return (Dali::Toolkit::Button *)jarg1;
57876 }
57877
57878 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
57879     return (Dali::Toolkit::Button *)jarg1;
57880 }
57881
57882 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
57883     return (Dali::Toolkit::Control *)jarg1;
57884 }
57885
57886 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
57887     return (Dali::Toolkit::Control *)jarg1;
57888 }
57889
57890 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
57891     return (Dali::Toolkit::Control *)jarg1;
57892 }
57893
57894 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
57895     return (Dali::Toolkit::Control *)jarg1;
57896 }
57897
57898 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
57899     return (Dali::Toolkit::Control *)jarg1;
57900 }
57901
57902 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
57903     return (Dali::RefObject *)jarg1;
57904 }
57905
57906 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
57907     return (Dali::Toolkit::Scrollable *)jarg1;
57908 }
57909
57910 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
57911     return (Dali::BaseHandle *)jarg1;
57912 }
57913
57914 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
57915     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
57916 }
57917
57918 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
57919     return (Dali::RefObject *)jarg1;
57920 }
57921
57922 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
57923     return (Dali::Toolkit::Ruler *)jarg1;
57924 }
57925
57926 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
57927     return (Dali::Toolkit::Ruler *)jarg1;
57928 }
57929
57930 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
57931     return (Dali::Toolkit::Scrollable *)jarg1;
57932 }
57933
57934 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
57935     return (Dali::Toolkit::Control *)jarg1;
57936 }
57937
57938
57939 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
57940     return (Dali::Toolkit::Control *)jarg1;
57941 }
57942
57943 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
57944     return (Dali::BaseHandle *)jarg1;
57945 }
57946
57947 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
57948     return (Dali::BaseHandle *)jarg1;
57949 }
57950
57951 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
57952     return (Dali::Toolkit::Control *)jarg1;
57953 }
57954
57955 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
57956     return (Dali::Toolkit::Control *)jarg1;
57957 }
57958
57959 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_CameraView_SWIGUpcast(Dali::Toolkit::CameraView *jarg1) {
57960     return (Dali::Toolkit::Control *)jarg1;
57961 }
57962
57963 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
57964     return (Dali::Toolkit::Control *)jarg1;
57965 }
57966
57967 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
57968     return (Dali::Toolkit::Control *)jarg1;
57969 }
57970
57971 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
57972     return (Dali::Toolkit::Control *)jarg1;
57973 }
57974
57975 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
57976     return (Dali::Toolkit::Control *)jarg1;
57977 }
57978
57979 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
57980     return (Dali::Toolkit::PageTurnView *)jarg1;
57981 }
57982
57983 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
57984     return (Dali::Toolkit::PageTurnView *)jarg1;
57985 }
57986
57987 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
57988     return (Dali::Toolkit::Button *)jarg1;
57989 }
57990
57991 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
57992     return (Dali::BaseHandle *)jarg1;
57993 }
57994
57995 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
57996     return (Dali::BaseHandle *)jarg1;
57997 }
57998
57999 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
58000     return (Dali::BaseHandle *)jarg1;
58001 }
58002
58003 /*
58004  * Widget binding
58005  */
58006 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
58007     return (Dali::BaseHandle *)jarg1;
58008 }
58009
58010 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
58011     return (Dali::BaseObject *)jarg1;
58012 }
58013
58014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
58015   void * jresult ;
58016   Dali::Widget result;
58017
58018   {
58019     try {
58020       result = Dali::Widget::New();
58021     } CALL_CATCH_EXCEPTION(0);
58022   }
58023
58024   jresult = new Dali::Widget((const Dali::Widget &)result);
58025   return jresult;
58026 }
58027
58028
58029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
58030   void * jresult ;
58031   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
58032   Dali::Widget result;
58033
58034   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58035
58036   if (!arg1) {
58037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
58038     return 0;
58039   }
58040   {
58041     try {
58042       jresult = new Dali::Widget(arg1);
58043     } CALL_CATCH_EXCEPTION(0);
58044   }
58045   return jresult;
58046 }
58047
58048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
58049   void * jresult ;
58050   Dali::Widget *result = 0 ;
58051
58052   {
58053     try {
58054       result = (Dali::Widget *)new Dali::Widget();
58055     } CALL_CATCH_EXCEPTION(0);
58056   }
58057   jresult = (void *)result;
58058   return jresult;
58059 }
58060
58061
58062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
58063   void * jresult ;
58064   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
58065   Dali::Widget *arg2 = 0 ;
58066   Dali::Widget *result = 0 ;
58067
58068   arg1 = (Dali::Widget *)jarg1;
58069   arg2 = (Dali::Widget *)jarg2;
58070   if (!arg2) {
58071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
58072     return 0;
58073   }
58074   {
58075     try {
58076       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
58077     } CALL_CATCH_EXCEPTION(0);
58078   }
58079   jresult = (void *)result;
58080   return jresult;
58081 }
58082
58083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
58084   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
58085
58086   arg1 = (Dali::Widget *)jarg1;
58087   {
58088     try {
58089       delete arg1;
58090     } CALL_CATCH_EXCEPTION();
58091   }
58092 }
58093
58094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
58095   void * jresult ;
58096   SwigDirector_WidgetImpl* result;
58097   {
58098     try {
58099       result = new SwigDirector_WidgetImpl();
58100     } CALL_CATCH_EXCEPTION(0);
58101   }
58102   jresult = result;
58103   return jresult;
58104 }
58105
58106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
58107   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58108   std::string *arg2 = 0 ;
58109   Dali::Window arg3 ;
58110   Dali::Window *argp3 ;
58111
58112   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58113   if (!jarg2) {
58114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58115     return ;
58116   }
58117   std::string arg2_str(jarg2);
58118   arg2 = &arg2_str;
58119   argp3 = (Dali::Window *)jarg3;
58120   if (!argp3) {
58121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
58122     return ;
58123   }
58124   arg3 = *argp3;
58125   {
58126     try {
58127       (arg1)->OnCreate((std::string const &)*arg2,arg3);
58128     } CALL_CATCH_EXCEPTION();
58129   }
58130 }
58131
58132
58133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
58134   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58135   std::string *arg2 = 0 ;
58136   Dali::Window arg3 ;
58137   Dali::Window *argp3 ;
58138
58139   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58140   if (!jarg2) {
58141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58142     return ;
58143   }
58144   std::string arg2_str(jarg2);
58145   arg2 = &arg2_str;
58146   argp3 = (Dali::Window *)jarg3;
58147   if (!argp3) {
58148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
58149     return ;
58150   }
58151   arg3 = *argp3;
58152   {
58153     try {
58154       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
58155     } CALL_CATCH_EXCEPTION();
58156   }
58157 }
58158
58159
58160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
58161   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58162   std::string *arg2 = 0 ;
58163   Dali::Widget::Termination arg3 ;
58164
58165   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58166   if (!jarg2) {
58167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58168     return ;
58169   }
58170   std::string arg2_str(jarg2);
58171   arg2 = &arg2_str;
58172   arg3 = (Dali::Widget::Termination)jarg3;
58173   {
58174     try {
58175       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
58176     } CALL_CATCH_EXCEPTION();
58177   }
58178 }
58179
58180
58181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
58182   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58183   std::string *arg2 = 0 ;
58184   Dali::Widget::Termination arg3 ;
58185
58186   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58187   if (!jarg2) {
58188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58189     return ;
58190   }
58191   std::string arg2_str(jarg2);
58192   arg2 = &arg2_str;
58193   arg3 = (Dali::Widget::Termination)jarg3;
58194   {
58195     try {
58196       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
58197     } CALL_CATCH_EXCEPTION();
58198   }
58199 }
58200
58201
58202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
58203   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58204
58205   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58206   {
58207     try {
58208       (arg1)->OnPause();
58209     } CALL_CATCH_EXCEPTION();
58210   }
58211 }
58212
58213
58214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
58215   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58216
58217   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58218   {
58219     try {
58220       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
58221     } CALL_CATCH_EXCEPTION();
58222   }
58223 }
58224
58225
58226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
58227   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58228
58229   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58230   {
58231     try {
58232       (arg1)->OnResume();
58233     } CALL_CATCH_EXCEPTION();
58234   }
58235 }
58236
58237
58238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
58239   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58240
58241   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58242   {
58243     try {
58244       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
58245     } CALL_CATCH_EXCEPTION();
58246   }
58247 }
58248
58249
58250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
58251   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58252   Dali::Window arg2 ;
58253   Dali::Window *argp2 ;
58254
58255   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58256   argp2 = (Dali::Window *)jarg2;
58257   if (!argp2) {
58258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
58259     return ;
58260   }
58261   arg2 = *argp2;
58262   {
58263     try {
58264       (arg1)->OnResize(arg2);
58265     } CALL_CATCH_EXCEPTION();
58266   }
58267 }
58268
58269
58270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
58271   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58272   Dali::Window arg2 ;
58273   Dali::Window *argp2 ;
58274
58275   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58276   argp2 = (Dali::Window *)jarg2;
58277   if (!argp2) {
58278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
58279     return ;
58280   }
58281   arg2 = *argp2;
58282   {
58283     try {
58284       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
58285     } CALL_CATCH_EXCEPTION();
58286   }
58287 }
58288
58289
58290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
58291   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58292   std::string *arg2 = 0 ;
58293   int arg3 ;
58294
58295   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58296   if (!jarg2) {
58297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58298     return ;
58299   }
58300   std::string arg2_str(jarg2);
58301   arg2 = &arg2_str;
58302   arg3 = (int)jarg3;
58303   {
58304     try {
58305       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
58306     } CALL_CATCH_EXCEPTION();
58307   }
58308 }
58309
58310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
58311   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58312   std::string *arg2 = 0 ;
58313   int arg3 ;
58314
58315   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58316   if (!jarg2) {
58317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58318     return ;
58319   }
58320   std::string arg2_str(jarg2);
58321   arg2 = &arg2_str;
58322   arg3 = (int)jarg3;
58323   {
58324     try {
58325       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
58326     } CALL_CATCH_EXCEPTION();
58327   }
58328 }
58329
58330
58331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
58332   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58333   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58334   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58335
58336   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58337   arg2 = (Dali::SlotObserver *)jarg2;
58338   arg3 = (Dali::CallbackBase *)jarg3;
58339   {
58340     try {
58341       (arg1)->SignalConnected(arg2,arg3);
58342     } CALL_CATCH_EXCEPTION();
58343   }
58344 }
58345
58346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
58347   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58348   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58349   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58350
58351   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58352   arg2 = (Dali::SlotObserver *)jarg2;
58353   arg3 = (Dali::CallbackBase *)jarg3;
58354   {
58355     try {
58356       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
58357     } CALL_CATCH_EXCEPTION();
58358   }
58359 }
58360
58361
58362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
58363   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58364   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58365   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58366
58367   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58368   arg2 = (Dali::SlotObserver *)jarg2;
58369   arg3 = (Dali::CallbackBase *)jarg3;
58370   {
58371     try {
58372       (arg1)->SignalDisconnected(arg2,arg3);
58373     } CALL_CATCH_EXCEPTION();
58374   }
58375 }
58376
58377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
58378   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58379   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58380   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58381
58382   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58383   arg2 = (Dali::SlotObserver *)jarg2;
58384   arg3 = (Dali::CallbackBase *)jarg3;
58385   {
58386     try {
58387       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
58388     } CALL_CATCH_EXCEPTION();
58389   }
58390 }
58391
58392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
58393   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58394   std::string *arg2 = 0 ;
58395
58396   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58397   if (!jarg2) {
58398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58399     return ;
58400   }
58401   std::string arg2_str(jarg2);
58402   arg2 = &arg2_str;
58403   {
58404     try {
58405       (arg1)->SetContentInfo((std::string const &)*arg2);
58406     } CALL_CATCH_EXCEPTION();
58407   }
58408 }
58409
58410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetUsingKeyEvent(void * jwidget, bool jflag) {
58411   Dali::Internal::Adaptor::Widget *widget = (Dali::Internal::Adaptor::Widget *) 0 ;
58412   bool flag;
58413
58414   widget = (Dali::Internal::Adaptor::Widget *)jwidget;
58415   flag = jflag ? true : false;
58416   {
58417     try {
58418       (widget)->SetUsingKeyEvent(flag);
58419     } CALL_CATCH_EXCEPTION();
58420   }
58421 }
58422
58423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
58424   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58425   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
58426
58427   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58428   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
58429   {
58430     try {
58431       (arg1)->SetImpl(arg2);
58432     } CALL_CATCH_EXCEPTION();
58433   }
58434 }
58435
58436
58437 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) {
58438   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
58439   if (director) {
58440     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
58441   }
58442 }
58443
58444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
58445   void * jresult ;
58446   Dali::Widget *arg1 = 0 ;
58447   SwigDirector_WidgetImpl *result = 0 ;
58448
58449   arg1 = (Dali::Widget *)jarg1;
58450   if (!arg1) {
58451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
58452     return 0;
58453   }
58454   {
58455     try {
58456       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
58457     } CALL_CATCH_EXCEPTION(0);
58458   }
58459   jresult = (void*) result;
58460   return jresult;
58461 }
58462
58463
58464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
58465   void * jresult ;
58466   int *arg1 = (int *) 0 ;
58467   char ***arg2 ;
58468   std::string *arg3 = 0 ;
58469   Dali::WidgetApplication result;
58470   {
58471     int index = 0;
58472     int length = 0;
58473     char *retPtr;
58474     char *nextPtr;
58475     argWidgetC = jarg1;
58476     argWidgetV = new char*[jarg1 + 1];
58477
58478     retPtr = strtok_r( jarg2, " ", &nextPtr);
58479     if( retPtr )
58480     {
58481       length = strlen(retPtr);
58482     }
58483     argWidgetV[index] = new char[length + 1];
58484     if( retPtr )
58485     {
58486       strncpy(argWidgetV[index], retPtr, length);
58487     }
58488     argWidgetV[index][length] = '\0';
58489     index++;
58490
58491     while (index < jarg1)
58492     {
58493       length = 0;
58494       retPtr = strtok_r(NULL, " ", &nextPtr);
58495       if( retPtr )
58496       {
58497         length = strlen(retPtr);
58498       }
58499       argWidgetV[index] = new char[length + 1];
58500       if( retPtr )
58501       {
58502         strncpy(argWidgetV[index], retPtr, length);
58503       }
58504       argWidgetV[index][length] = '\0';
58505       index++;
58506     }
58507
58508     argWidgetV[jarg1] = NULL;
58509     argWidgetC = jarg1;
58510
58511     arg1 = &argWidgetC;
58512     arg2 = &argWidgetV;
58513   }
58514
58515   if (!jarg3) {
58516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58517     return 0;
58518   }
58519   std::string arg3_str(jarg3);
58520   arg3 = &arg3_str;
58521   {
58522     try {
58523       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
58524     } CALL_CATCH_EXCEPTION(0);
58525   }
58526   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
58527   return jresult;
58528 }
58529
58530
58531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
58532   void * jresult ;
58533   Dali::WidgetApplication *result = 0 ;
58534
58535   {
58536     try {
58537       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
58538     } CALL_CATCH_EXCEPTION(0);
58539   }
58540   jresult = (void *)result;
58541   return jresult;
58542 }
58543
58544
58545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
58546   void * jresult ;
58547   Dali::WidgetApplication *arg1 = 0 ;
58548   Dali::WidgetApplication *result = 0 ;
58549
58550   arg1 = (Dali::WidgetApplication *)jarg1;
58551   if (!arg1) {
58552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
58553     return 0;
58554   }
58555   {
58556     try {
58557       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
58558     } CALL_CATCH_EXCEPTION(0);
58559   }
58560   jresult = (void *)result;
58561   return jresult;
58562 }
58563
58564
58565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
58566   void * jresult ;
58567   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
58568   Dali::WidgetApplication *arg2 = 0 ;
58569   Dali::WidgetApplication *result = 0 ;
58570
58571   arg1 = (Dali::WidgetApplication *)jarg1;
58572   arg2 = (Dali::WidgetApplication *)jarg2;
58573   if (!arg2) {
58574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
58575     return 0;
58576   }
58577   {
58578     try {
58579       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
58580     } CALL_CATCH_EXCEPTION(0);
58581   }
58582   jresult = (void *)result;
58583   return jresult;
58584 }
58585
58586
58587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
58588   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
58589
58590   arg1 = (Dali::WidgetApplication *)jarg1;
58591   {
58592     try {
58593       delete arg1;
58594       if( argWidgetV )
58595       {
58596         // free string data
58597         for( int i=0; i < argWidgetC+1; i++)
58598         {
58599           delete [] argWidgetV[i];
58600         }
58601         delete [] argWidgetV;
58602       }
58603     } CALL_CATCH_EXCEPTION();
58604   }
58605 }
58606
58607
58608 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
58609 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
58610
58611 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
58612 {
58613   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
58614   return *widget;
58615 }
58616
58617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
58618   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
58619   std::string *arg2 = 0 ;
58620
58621   arg1 = (Dali::WidgetApplication *)jarg1;
58622   if (!jarg2) {
58623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58624     return ;
58625   }
58626   std::string arg2_str(*jarg2);
58627   arg2 = &arg2_str;
58628
58629   if(!_CSharpCreateWidgetFunction)
58630   {
58631     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
58632   }
58633
58634   {
58635     try {
58636       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
58637     } CALL_CATCH_EXCEPTION();
58638   }
58639   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
58640 }
58641
58642
58643 //for PixelBuffer and ImageLoading
58644
58645 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
58646     return (Dali::BaseHandle *)jarg1;
58647 }
58648
58649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
58650   void * jresult ;
58651   unsigned int arg1 ;
58652   unsigned int arg2 ;
58653   Dali::Pixel::Format arg3 ;
58654   Dali::Devel::PixelBuffer result;
58655
58656   arg1 = (unsigned int)jarg1;
58657   arg2 = (unsigned int)jarg2;
58658   arg3 = (Dali::Pixel::Format)jarg3;
58659   {
58660     try {
58661       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
58662     } CALL_CATCH_EXCEPTION(0);
58663   }
58664   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58665   return jresult;
58666 }
58667
58668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
58669   void * jresult ;
58670   Dali::Devel::PixelBuffer *result = 0 ;
58671
58672   {
58673     try {
58674       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
58675     } CALL_CATCH_EXCEPTION(0);
58676   }
58677   jresult = (void *)result;
58678   return jresult;
58679 }
58680
58681
58682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
58683   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
58684
58685   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58686   {
58687     try {
58688       delete arg1;
58689     } CALL_CATCH_EXCEPTION();
58690   }
58691 }
58692
58693
58694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
58695   void * jresult ;
58696   Dali::Devel::PixelBuffer *arg1 = 0 ;
58697   Dali::Devel::PixelBuffer *result = 0 ;
58698
58699   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58700   if (!arg1) {
58701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
58702     return 0;
58703   }
58704   {
58705     try {
58706       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
58707     } CALL_CATCH_EXCEPTION(0);
58708   }
58709   jresult = (void *)result;
58710   return jresult;
58711 }
58712
58713
58714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
58715   void * jresult ;
58716   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
58717   Dali::Devel::PixelBuffer *arg2 = 0 ;
58718   Dali::Devel::PixelBuffer *result = 0 ;
58719
58720   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58721   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
58722   if (!arg2) {
58723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
58724     return 0;
58725   }
58726   {
58727     try {
58728       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
58729     } CALL_CATCH_EXCEPTION(0);
58730   }
58731   jresult = (void *)result;
58732   return jresult;
58733 }
58734
58735
58736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
58737   void * jresult ;
58738   Dali::Devel::PixelBuffer *arg1 = 0 ;
58739   Dali::PixelData result;
58740
58741   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58742   if (!arg1) {
58743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
58744     return 0;
58745   }
58746   {
58747     try {
58748       result = Dali::Devel::PixelBuffer::Convert(*arg1);
58749     } CALL_CATCH_EXCEPTION(0);
58750   }
58751   jresult = new Dali::PixelData((const Dali::PixelData &)result);
58752   return jresult;
58753 }
58754
58755
58756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
58757   void * jresult ;
58758   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
58759   Dali::PixelData result;
58760
58761   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58762   {
58763     try {
58764       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
58765     } CALL_CATCH_EXCEPTION(0);
58766   }
58767   jresult = new Dali::PixelData((const Dali::PixelData &)result);
58768   return jresult;
58769 }
58770
58771
58772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
58773   void * jresult ;
58774   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
58775   unsigned char *result = 0 ;
58776
58777   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58778   {
58779     try {
58780       result = (unsigned char *)(arg1)->GetBuffer();
58781     } CALL_CATCH_EXCEPTION(0);
58782   }
58783    jresult = (void *)result;
58784    return jresult;
58785 }
58786
58787 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
58788   unsigned int jresult ;
58789   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
58790   unsigned int result;
58791
58792   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58793   {
58794     try {
58795       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
58796     } CALL_CATCH_EXCEPTION(0);
58797   }
58798   jresult = result;
58799   return jresult;
58800 }
58801
58802
58803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
58804   unsigned int jresult ;
58805   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
58806   unsigned int result;
58807
58808   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58809   {
58810     try {
58811       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
58812     } CALL_CATCH_EXCEPTION(0);
58813   }
58814   jresult = result;
58815   return jresult;
58816 }
58817
58818
58819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
58820   int jresult ;
58821   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
58822   Dali::Pixel::Format result;
58823
58824   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58825   {
58826     try {
58827       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
58828     } CALL_CATCH_EXCEPTION(0);
58829   }
58830   jresult = (int)result;
58831   return jresult;
58832 }
58833
58834
58835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, bool jarg4) {
58836   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
58837   Dali::Devel::PixelBuffer arg2 ;
58838   float arg3 ;
58839   bool arg4 ;
58840   Dali::Devel::PixelBuffer *argp2 ;
58841
58842   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58843   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
58844   if (!argp2) {
58845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
58846     return ;
58847   }
58848   arg2 = *argp2;
58849   arg3 = (float)jarg3;
58850   arg4 = jarg4 ? true : false;
58851   {
58852     try {
58853       (arg1)->ApplyMask(arg2,arg3,arg4);
58854     } CALL_CATCH_EXCEPTION();
58855   }
58856 }
58857
58858
58859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
58860   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
58861   Dali::Devel::PixelBuffer arg2 ;
58862   float arg3 ;
58863   Dali::Devel::PixelBuffer *argp2 ;
58864
58865   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58866   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
58867   if (!argp2) {
58868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
58869     return ;
58870   }
58871   arg2 = *argp2;
58872   arg3 = (float)jarg3;
58873   {
58874     try {
58875       (arg1)->ApplyMask(arg2,arg3);
58876     } CALL_CATCH_EXCEPTION();
58877   }
58878 }
58879
58880
58881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
58882   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
58883   Dali::Devel::PixelBuffer arg2 ;
58884   Dali::Devel::PixelBuffer *argp2 ;
58885
58886   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58887   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
58888   if (!argp2) {
58889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
58890     return ;
58891   }
58892   arg2 = *argp2;
58893   {
58894     try {
58895       (arg1)->ApplyMask(arg2);
58896     } CALL_CATCH_EXCEPTION();
58897   }
58898 }
58899
58900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
58901   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
58902   float arg2 ;
58903
58904   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58905   arg2 = (float)jarg2;
58906   {
58907     try {
58908       (arg1)->ApplyGaussianBlur(arg2);
58909     } CALL_CATCH_EXCEPTION();
58910   }
58911 }
58912
58913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
58914   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
58915   uint16_t arg2 ;
58916   uint16_t arg3 ;
58917   uint16_t arg4 ;
58918   uint16_t arg5 ;
58919
58920   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58921   arg2 = (uint16_t)jarg2;
58922   arg3 = (uint16_t)jarg3;
58923   arg4 = (uint16_t)jarg4;
58924   arg5 = (uint16_t)jarg5;
58925   {
58926     try {
58927       (arg1)->Crop(arg2,arg3,arg4,arg5);
58928     } CALL_CATCH_EXCEPTION();
58929   }
58930 }
58931
58932
58933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
58934   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
58935   uint16_t arg2 ;
58936   uint16_t arg3 ;
58937
58938   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58939   arg2 = (uint16_t)jarg2;
58940   arg3 = (uint16_t)jarg3;
58941   {
58942     try {
58943       (arg1)->Resize(arg2,arg3);
58944     } CALL_CATCH_EXCEPTION();
58945   }
58946 }
58947
58948 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void* jarg2) {
58949   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
58950   Dali::Degree * arg2 ;
58951
58952   bool result = false;
58953
58954   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58955   arg2 = (Dali::Degree *)jarg2;
58956   {
58957     try {
58958       result = (arg1)->Rotate(*arg2);
58959     } CALL_CATCH_EXCEPTION(false);
58960   }
58961   return result;
58962 }
58963
58964 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBrightness(void * jarg1) {
58965   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
58966   uint32_t result = 0;
58967
58968   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58969   {
58970     try {
58971       result = (arg1)->GetBrightness();
58972     } CALL_CATCH_EXCEPTION(0);
58973   }
58974   return result;
58975 }
58976
58977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
58978   void * jresult ;
58979   std::string *arg1 = 0 ;
58980   Dali::ImageDimensions arg2 ;
58981   Dali::FittingMode::Type arg3 ;
58982   Dali::SamplingMode::Type arg4 ;
58983   bool arg5 ;
58984   Dali::ImageDimensions *argp2 ;
58985   Dali::Devel::PixelBuffer result;
58986
58987   if (!jarg1) {
58988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58989     return 0;
58990   }
58991   std::string arg1_str(jarg1);
58992   arg1 = &arg1_str;
58993   argp2 = (Dali::ImageDimensions *)jarg2;
58994   if (!argp2) {
58995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
58996     return 0;
58997   }
58998   arg2 = *argp2;
58999   arg3 = (Dali::FittingMode::Type)jarg3;
59000   arg4 = (Dali::SamplingMode::Type)jarg4;
59001   arg5 = jarg5 ? true : false;
59002   {
59003     try {
59004       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
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_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
59013   void * jresult ;
59014   std::string *arg1 = 0 ;
59015   Dali::ImageDimensions arg2 ;
59016   Dali::FittingMode::Type arg3 ;
59017   Dali::SamplingMode::Type arg4 ;
59018   Dali::ImageDimensions *argp2 ;
59019   Dali::Devel::PixelBuffer result;
59020
59021   if (!jarg1) {
59022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59023     return 0;
59024   }
59025   std::string arg1_str(jarg1);
59026   arg1 = &arg1_str;
59027   argp2 = (Dali::ImageDimensions *)jarg2;
59028   if (!argp2) {
59029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59030     return 0;
59031   }
59032   arg2 = *argp2;
59033   arg3 = (Dali::FittingMode::Type)jarg3;
59034   arg4 = (Dali::SamplingMode::Type)jarg4;
59035   {
59036     try {
59037       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
59038     } CALL_CATCH_EXCEPTION(0);
59039   }
59040   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59041   return jresult;
59042 }
59043
59044
59045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
59046   void * jresult ;
59047   std::string *arg1 = 0 ;
59048   Dali::ImageDimensions arg2 ;
59049   Dali::FittingMode::Type arg3 ;
59050   Dali::ImageDimensions *argp2 ;
59051   Dali::Devel::PixelBuffer result;
59052
59053   if (!jarg1) {
59054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59055     return 0;
59056   }
59057   std::string arg1_str(jarg1);
59058   arg1 = &arg1_str;
59059   argp2 = (Dali::ImageDimensions *)jarg2;
59060   if (!argp2) {
59061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59062     return 0;
59063   }
59064   arg2 = *argp2;
59065   arg3 = (Dali::FittingMode::Type)jarg3;
59066   {
59067     try {
59068       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
59069     } CALL_CATCH_EXCEPTION(0);
59070   }
59071   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59072   return jresult;
59073 }
59074
59075
59076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
59077   void * jresult ;
59078   std::string *arg1 = 0 ;
59079   Dali::ImageDimensions arg2 ;
59080   Dali::ImageDimensions *argp2 ;
59081   Dali::Devel::PixelBuffer result;
59082
59083   if (!jarg1) {
59084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59085     return 0;
59086   }
59087   std::string arg1_str(jarg1);
59088   arg1 = &arg1_str;
59089   argp2 = (Dali::ImageDimensions *)jarg2;
59090   if (!argp2) {
59091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59092     return 0;
59093   }
59094   arg2 = *argp2;
59095   {
59096     try {
59097       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
59098     } CALL_CATCH_EXCEPTION(0);
59099   }
59100   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59101   return jresult;
59102 }
59103
59104
59105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
59106   void * jresult ;
59107   std::string *arg1 = 0 ;
59108   Dali::Devel::PixelBuffer result;
59109
59110   if (!jarg1) {
59111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59112     return 0;
59113   }
59114   std::string arg1_str(jarg1);
59115   arg1 = &arg1_str;
59116   {
59117     try {
59118       result = Dali::LoadImageFromFile((std::string const &)*arg1);
59119     } CALL_CATCH_EXCEPTION(0);
59120   }
59121   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59122   return jresult;
59123 }
59124
59125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_0(void * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
59126   void * jresult ;
59127   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
59128   Dali::ImageDimensions arg2 ;
59129   Dali::FittingMode::Type arg3 ;
59130   Dali::SamplingMode::Type arg4 ;
59131   bool arg5 ;
59132   Dali::ImageDimensions *argp2 ;
59133   Dali::Devel::PixelBuffer result;
59134
59135   if (!jarg1) {
59136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
59137     return 0;
59138   }
59139   arg1 = (Dali::Vector<uint8_t> *)jarg1;
59140   argp2 = (Dali::ImageDimensions *)jarg2;
59141   if (!argp2) {
59142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59143     return 0;
59144   }
59145   arg2 = *argp2;
59146   arg3 = (Dali::FittingMode::Type)jarg3;
59147   arg4 = (Dali::SamplingMode::Type)jarg4;
59148   arg5 = jarg5 ? true : false;
59149   {
59150     try {
59151       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1, arg2, arg3, arg4, arg5);
59152     } CALL_CATCH_EXCEPTION(0);
59153   }
59154   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59155   return jresult;
59156 }
59157
59158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_1(void * jarg1, void * jarg2, int jarg3, int jarg4) {
59159   void * jresult ;
59160   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
59161   Dali::ImageDimensions arg2 ;
59162   Dali::FittingMode::Type arg3 ;
59163   Dali::SamplingMode::Type arg4 ;
59164   Dali::ImageDimensions *argp2 ;
59165   Dali::Devel::PixelBuffer result;
59166
59167   if (!jarg1) {
59168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
59169     return 0;
59170   }
59171   arg1 = (Dali::Vector<uint8_t> *)jarg1;
59172   argp2 = (Dali::ImageDimensions *)jarg2;
59173   if (!argp2) {
59174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59175     return 0;
59176   }
59177   arg2 = *argp2;
59178   arg3 = (Dali::FittingMode::Type)jarg3;
59179   arg4 = (Dali::SamplingMode::Type)jarg4;
59180   {
59181     try {
59182       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1, arg2, arg3, arg4);
59183     } CALL_CATCH_EXCEPTION(0);
59184   }
59185   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59186   return jresult;
59187 }
59188
59189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_2(void * jarg1, void * jarg2, int jarg3) {
59190   void * jresult ;
59191   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
59192   Dali::ImageDimensions arg2 ;
59193   Dali::FittingMode::Type arg3 ;
59194   Dali::ImageDimensions *argp2 ;
59195   Dali::Devel::PixelBuffer result;
59196
59197   if (!jarg1) {
59198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
59199     return 0;
59200   }
59201   arg1 = (Dali::Vector<uint8_t> *)jarg1;
59202   argp2 = (Dali::ImageDimensions *)jarg2;
59203   if (!argp2) {
59204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59205     return 0;
59206   }
59207   arg2 = *argp2;
59208   arg3 = (Dali::FittingMode::Type)jarg3;
59209   {
59210     try {
59211       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1, arg2, arg3);
59212     } CALL_CATCH_EXCEPTION(0);
59213   }
59214   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59215   return jresult;
59216 }
59217
59218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_3(void * jarg1, void * jarg2) {
59219   void * jresult ;
59220   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
59221   Dali::ImageDimensions arg2 ;
59222   Dali::ImageDimensions *argp2 ;
59223   Dali::Devel::PixelBuffer result;
59224
59225   if (!jarg1) {
59226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
59227     return 0;
59228   }
59229   arg1 = (Dali::Vector<uint8_t> *)jarg1;
59230   argp2 = (Dali::ImageDimensions *)jarg2;
59231   if (!argp2) {
59232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59233     return 0;
59234   }
59235   arg2 = *argp2;
59236   {
59237     try {
59238       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1, arg2);
59239     } CALL_CATCH_EXCEPTION(0);
59240   }
59241   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59242   return jresult;
59243 }
59244
59245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_4(void * jarg1) {
59246   void * jresult ;
59247   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
59248   Dali::Devel::PixelBuffer result;
59249
59250   if (!jarg1) {
59251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
59252     return 0;
59253   }
59254   arg1 = (Dali::Vector<uint8_t> *)jarg1;
59255   {
59256     try {
59257       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1);
59258     } CALL_CATCH_EXCEPTION(0);
59259   }
59260   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59261   return jresult;
59262 }
59263
59264
59265
59266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
59267   void * jresult ;
59268   std::string *arg1 = 0 ;
59269   Dali::ImageDimensions arg2 ;
59270   Dali::FittingMode::Type arg3 ;
59271   Dali::SamplingMode::Type arg4 ;
59272   bool arg5 ;
59273   Dali::ImageDimensions *argp2 ;
59274   Dali::ImageDimensions result;
59275
59276   if (!jarg1) {
59277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59278     return 0;
59279   }
59280   std::string arg1_str(jarg1);
59281   arg1 = &arg1_str;
59282   argp2 = (Dali::ImageDimensions *)jarg2;
59283   if (!argp2) {
59284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59285     return 0;
59286   }
59287   arg2 = *argp2;
59288   arg3 = (Dali::FittingMode::Type)jarg3;
59289   arg4 = (Dali::SamplingMode::Type)jarg4;
59290   arg5 = jarg5 ? true : false;
59291   {
59292     try {
59293       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
59294     } CALL_CATCH_EXCEPTION(0);
59295   }
59296   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
59297   return jresult;
59298 }
59299
59300
59301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
59302   void * jresult ;
59303   std::string *arg1 = 0 ;
59304   Dali::ImageDimensions arg2 ;
59305   Dali::FittingMode::Type arg3 ;
59306   Dali::SamplingMode::Type arg4 ;
59307   Dali::ImageDimensions *argp2 ;
59308   Dali::ImageDimensions result;
59309
59310   if (!jarg1) {
59311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59312     return 0;
59313   }
59314   std::string arg1_str(jarg1);
59315   arg1 = &arg1_str;
59316   argp2 = (Dali::ImageDimensions *)jarg2;
59317   if (!argp2) {
59318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59319     return 0;
59320   }
59321   arg2 = *argp2;
59322   arg3 = (Dali::FittingMode::Type)jarg3;
59323   arg4 = (Dali::SamplingMode::Type)jarg4;
59324   {
59325     try {
59326       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
59327     } CALL_CATCH_EXCEPTION(0);
59328   }
59329   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
59330   return jresult;
59331 }
59332
59333
59334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
59335   void * jresult ;
59336   std::string *arg1 = 0 ;
59337   Dali::ImageDimensions arg2 ;
59338   Dali::FittingMode::Type arg3 ;
59339   Dali::ImageDimensions *argp2 ;
59340   Dali::ImageDimensions result;
59341
59342   if (!jarg1) {
59343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59344     return 0;
59345   }
59346   std::string arg1_str(jarg1);
59347   arg1 = &arg1_str;
59348   argp2 = (Dali::ImageDimensions *)jarg2;
59349   if (!argp2) {
59350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59351     return 0;
59352   }
59353   arg2 = *argp2;
59354   arg3 = (Dali::FittingMode::Type)jarg3;
59355   {
59356     try {
59357       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
59358     } CALL_CATCH_EXCEPTION(0);
59359   }
59360   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
59361   return jresult;
59362 }
59363
59364
59365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
59366   void * jresult ;
59367   std::string *arg1 = 0 ;
59368   Dali::ImageDimensions arg2 ;
59369   Dali::ImageDimensions *argp2 ;
59370   Dali::ImageDimensions result;
59371
59372   if (!jarg1) {
59373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59374     return 0;
59375   }
59376   std::string arg1_str(jarg1);
59377   arg1 = &arg1_str;
59378   argp2 = (Dali::ImageDimensions *)jarg2;
59379   if (!argp2) {
59380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59381     return 0;
59382   }
59383   arg2 = *argp2;
59384   {
59385     try {
59386       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
59387     } CALL_CATCH_EXCEPTION(0);
59388   }
59389   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
59390   return jresult;
59391 }
59392
59393
59394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
59395   void * jresult ;
59396   std::string *arg1 = 0 ;
59397   Dali::ImageDimensions result;
59398
59399   if (!jarg1) {
59400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59401     return 0;
59402   }
59403   std::string arg1_str(jarg1);
59404   arg1 = &arg1_str;
59405   {
59406     try {
59407       result = Dali::GetClosestImageSize((std::string const &)*arg1);
59408     } CALL_CATCH_EXCEPTION(0);
59409   }
59410   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
59411   return jresult;
59412 }
59413
59414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1, bool jarg2) {
59415   void * jresult ;
59416   std::string *arg1 = 0 ;
59417   bool arg2 ;
59418   Dali::ImageDimensions result;
59419
59420   if (!jarg1) {
59421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59422     return 0;
59423   }
59424   std::string arg1_str(jarg1);
59425   arg1 = &arg1_str;
59426   arg2 = jarg2 ? true : false;
59427   {
59428     try {
59429       result = Dali::GetOriginalImageSize((std::string const &)*arg1,arg2);
59430     } CALL_CATCH_EXCEPTION(0);
59431   }
59432   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
59433   return jresult;
59434 }
59435
59436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
59437   void * jresult ;
59438   std::string *arg1 = 0 ;
59439   Dali::ImageDimensions arg2 ;
59440   Dali::FittingMode::Type arg3 ;
59441   Dali::SamplingMode::Type arg4 ;
59442   bool arg5 ;
59443   Dali::ImageDimensions *argp2 ;
59444   Dali::Devel::PixelBuffer result;
59445
59446   if (!jarg1) {
59447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59448     return 0;
59449   }
59450   std::string arg1_str(jarg1);
59451   arg1 = &arg1_str;
59452   argp2 = (Dali::ImageDimensions *)jarg2;
59453   if (!argp2) {
59454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59455     return 0;
59456   }
59457   arg2 = *argp2;
59458   arg3 = (Dali::FittingMode::Type)jarg3;
59459   arg4 = (Dali::SamplingMode::Type)jarg4;
59460   arg5 = jarg5 ? true : false;
59461   {
59462     try {
59463       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
59464     } CALL_CATCH_EXCEPTION(0);
59465   }
59466   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59467   return jresult;
59468 }
59469
59470
59471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
59472   void * jresult ;
59473   std::string *arg1 = 0 ;
59474   Dali::ImageDimensions arg2 ;
59475   Dali::FittingMode::Type arg3 ;
59476   Dali::SamplingMode::Type arg4 ;
59477   Dali::ImageDimensions *argp2 ;
59478   Dali::Devel::PixelBuffer result;
59479
59480   if (!jarg1) {
59481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59482     return 0;
59483   }
59484   std::string arg1_str(jarg1);
59485   arg1 = &arg1_str;
59486   argp2 = (Dali::ImageDimensions *)jarg2;
59487   if (!argp2) {
59488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59489     return 0;
59490   }
59491   arg2 = *argp2;
59492   arg3 = (Dali::FittingMode::Type)jarg3;
59493   arg4 = (Dali::SamplingMode::Type)jarg4;
59494   {
59495     try {
59496       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
59497     } CALL_CATCH_EXCEPTION(0);
59498   }
59499   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59500   return jresult;
59501 }
59502
59503
59504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
59505   void * jresult ;
59506   std::string *arg1 = 0 ;
59507   Dali::ImageDimensions arg2 ;
59508   Dali::FittingMode::Type arg3 ;
59509   Dali::ImageDimensions *argp2 ;
59510   Dali::Devel::PixelBuffer result;
59511
59512   if (!jarg1) {
59513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59514     return 0;
59515   }
59516   std::string arg1_str(jarg1);
59517   arg1 = &arg1_str;
59518   argp2 = (Dali::ImageDimensions *)jarg2;
59519   if (!argp2) {
59520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59521     return 0;
59522   }
59523   arg2 = *argp2;
59524   arg3 = (Dali::FittingMode::Type)jarg3;
59525   {
59526     try {
59527       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
59528     } CALL_CATCH_EXCEPTION(0);
59529   }
59530   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59531   return jresult;
59532 }
59533
59534
59535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
59536   void * jresult ;
59537   std::string *arg1 = 0 ;
59538   Dali::ImageDimensions arg2 ;
59539   Dali::ImageDimensions *argp2 ;
59540   Dali::Devel::PixelBuffer result;
59541
59542   if (!jarg1) {
59543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59544     return 0;
59545   }
59546   std::string arg1_str(jarg1);
59547   arg1 = &arg1_str;
59548   argp2 = (Dali::ImageDimensions *)jarg2;
59549   if (!argp2) {
59550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59551     return 0;
59552   }
59553   arg2 = *argp2;
59554   {
59555     try {
59556       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
59557     } CALL_CATCH_EXCEPTION(0);
59558   }
59559   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59560   return jresult;
59561 }
59562
59563
59564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
59565   void * jresult ;
59566   std::string *arg1 = 0 ;
59567   Dali::Devel::PixelBuffer result;
59568
59569   if (!jarg1) {
59570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59571     return 0;
59572   }
59573   std::string arg1_str(jarg1);
59574   arg1 = &arg1_str;
59575   {
59576     try {
59577       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
59578     } CALL_CATCH_EXCEPTION(0);
59579   }
59580   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59581   return jresult;
59582 }
59583
59584 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
59585   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
59586   char * jresult = SWIG_csharp_string_callback((const char *)result);
59587   return jresult;
59588 }
59589
59590 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
59591   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
59592   return result;
59593 }
59594
59595 struct NativeImageSourcePtrHandle
59596 {
59597   NativeImageSourcePtr Ptr;
59598 };
59599
59600 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
59601 {
59602   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
59603   return (NativeImageInterface*)(arg1);
59604 }
59605
59606 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
59607 {
59608   void* jresult;
59609   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
59610   {
59611     try {
59612       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
59613     }
59614     catch (std::out_of_range & e) {
59615       {
59616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59617       };
59618     }
59619     catch (std::exception & e) {
59620       {
59621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59622       };
59623     }
59624     catch (Dali::DaliException e) {
59625       {
59626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59627       };
59628     }
59629     catch (...) {
59630       {
59631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59632       };
59633     }
59634   }
59635   jresult = (void *)handle;
59636   return jresult;
59637 }
59638
59639 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
59640 {
59641   void* jresult;
59642   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
59643   jresult = (void*)( handle->Ptr.Get() );
59644   return jresult;
59645 }
59646
59647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
59648   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
59649   {
59650     try {
59651       delete arg1;
59652     }
59653     catch (std::out_of_range & e) {
59654       {
59655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
59656       };
59657     }
59658     catch (std::exception & e) {
59659       {
59660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
59661       };
59662     }
59663     catch (Dali::DaliException e) {
59664       {
59665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
59666       };
59667     }
59668     catch (...) {
59669       {
59670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
59671       };
59672     }
59673   }
59674 }
59675
59676 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
59677 {
59678   void* jresult;
59679   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
59680   uint16_t* arg2 = (uint16_t*)(jarg2);
59681   uint16_t* arg3 = (uint16_t*)(jarg3);
59682   uint16_t* arg4 = (uint16_t*)(jarg4);
59683   {
59684     try {
59685       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
59686     }
59687     catch (std::out_of_range & e) {
59688       {
59689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59690       };
59691     }
59692     catch (std::exception & e) {
59693       {
59694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59695       };
59696     }
59697     catch (Dali::DaliException e) {
59698       {
59699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59700       };
59701     }
59702     catch (...) {
59703       {
59704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59705       };
59706     }
59707   }
59708   return jresult;
59709 }
59710
59711 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
59712 {
59713   bool jresult;
59714   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
59715
59716   {
59717     try {
59718       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
59719     }
59720     catch (std::out_of_range & e) {
59721       {
59722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59723       };
59724     }
59725     catch (std::exception & e) {
59726       {
59727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59728       };
59729     }
59730     catch (Dali::DaliException e) {
59731       {
59732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59733       };
59734     }
59735     catch (...) {
59736       {
59737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59738       };
59739     }
59740   }
59741   return jresult;
59742 }
59743
59744 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_GenerateUrl(void* handle)
59745 {
59746   Dali::Toolkit::ImageUrl result;
59747   NativeImageSource* nativeImageSource = (NativeImageSource*)handle;
59748   void *jresult;
59749
59750   if (!nativeImageSource)
59751   {
59752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0);
59753     return 0;
59754   }
59755   {
59756     try
59757     {
59758       result = Dali::Toolkit::Image::GenerateUrl(nativeImageSource);
59759     }
59760     catch (std::out_of_range& e)
59761     {
59762       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
59763       return 0;
59764     }
59765     catch (std::exception& e)
59766     {
59767       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
59768       return 0;
59769     }
59770     catch (Dali::DaliException e)
59771     {
59772       SWIG_CSharpException(SWIG_UnknownError, e.condition);
59773       return 0;
59774     }
59775     catch (...)
59776     {
59777       SWIG_CSharpException(SWIG_UnknownError, "unknown error");
59778       return 0;
59779     }
59780   }
59781
59782   jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl &)result);
59783   return jresult;
59784 }
59785
59786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageUrl(void* jarg1)
59787 {
59788   Dali::Toolkit::ImageUrl* imageUrl = (Dali::Toolkit::ImageUrl*) 0;
59789
59790   imageUrl = (Dali::Toolkit::ImageUrl*)jarg1;
59791   {
59792     try
59793     {
59794       delete imageUrl;
59795     }
59796     catch (std::out_of_range& e)
59797     {
59798       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
59799       return;
59800     }
59801     catch (std::exception& e)
59802     {
59803       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
59804       return;
59805     }
59806     catch (Dali::DaliException e)
59807     {
59808       SWIG_CSharpException(SWIG_UnknownError, e.condition);
59809       return;
59810     }
59811     catch (...)
59812     {
59813       SWIG_CSharpException(SWIG_UnknownError, "unknown error");
59814       return;
59815     }
59816   }
59817 }
59818
59819 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImageUrl_Get(void* jarg1)
59820 {
59821   char *jresult;
59822   Dali::Toolkit::ImageUrl* imageUrl = (Dali::Toolkit::ImageUrl*) 0;
59823   std::string result;
59824
59825   imageUrl = (Dali::Toolkit::ImageUrl*)jarg1;
59826   {
59827     try
59828     {
59829       result = imageUrl->GetUrl();
59830     }
59831     catch (std::out_of_range& e)
59832     {
59833       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
59834       return 0;
59835     }
59836     catch (std::exception& e)
59837     {
59838       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
59839       return 0;
59840     }
59841     catch (Dali::DaliException e)
59842     {
59843       SWIG_CSharpException(SWIG_UnknownError, e.condition);
59844       return 0;
59845     }
59846     catch (...)
59847     {
59848       SWIG_CSharpException(SWIG_UnknownError, "unknown error");
59849       return 0;
59850     }
59851   }
59852
59853   jresult = SWIG_csharp_string_callback((&result)->c_str());
59854   return jresult;
59855 }
59856
59857 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetSuggestedMinimumWidth(void * jarg1) {
59858   Dali::Actor *arg1 = (Dali::Actor *) 0;
59859   Dali::Vector2 maximumSize;
59860   Dali::Vector2 minimumSize;
59861   Dali::Vector3 naturalSize;
59862   bool widthForHeight;
59863   float result;
59864   {
59865     try {
59866       arg1 = (Dali::Actor *)jarg1;
59867       maximumSize = arg1->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
59868       minimumSize = arg1->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
59869       naturalSize = arg1->GetNaturalSize();
59870       widthForHeight = arg1->GetProperty< bool >( Actor::Property::WIDTH_FOR_HEIGHT );
59871
59872       float baseWidth;
59873       if (widthForHeight)
59874       {
59875         float baseHeight = maximumSize.height > 0 ? std::min(maximumSize.height, naturalSize.height) : naturalSize.height;
59876         baseWidth = arg1->GetWidthForHeight(baseHeight);
59877       }
59878       else
59879       {
59880         baseWidth = naturalSize.width;
59881       }
59882
59883       result = minimumSize.width > 0 ? std::max(baseWidth, minimumSize.width) : baseWidth;
59884       result = maximumSize.width > 0 ? std::min(result, maximumSize.width) : result;
59885     } CALL_CATCH_EXCEPTION(0);
59886   }
59887
59888   return result;
59889 }
59890
59891 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetSuggestedMinimumHeight(void * jarg1) {
59892   Dali::Actor *arg1 = (Dali::Actor *) 0;
59893   Dali::Vector2 maximumSize;
59894   Dali::Vector2 minimumSize;
59895   Dali::Vector3 naturalSize;
59896   bool heightForWidth;
59897   float result;
59898   {
59899     try {
59900       arg1 = (Dali::Actor *)jarg1;
59901       maximumSize = arg1->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
59902       minimumSize = arg1->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
59903       naturalSize = arg1->GetNaturalSize();
59904       heightForWidth = arg1->GetProperty< bool >( Actor::Property::HEIGHT_FOR_WIDTH );
59905
59906       float baseHeight;
59907       if (heightForWidth)
59908       {
59909         float baseWidth = maximumSize.width > 0 ? std::min(maximumSize.width, naturalSize.width) : naturalSize.width;
59910         baseHeight = arg1->GetHeightForWidth(baseWidth);
59911       }
59912       else
59913       {
59914         baseHeight = naturalSize.height;
59915       }
59916
59917       result = minimumSize.height > 0 ? std::max(baseHeight, minimumSize.height) : baseHeight;
59918       result = maximumSize.height > 0 ? std::min(result, maximumSize.height) : result;
59919     } CALL_CATCH_EXCEPTION(0);
59920   }
59921
59922   return result;
59923 }
59924
59925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorVector2_BaseType_get() {
59926   int jresult ;
59927   int result;
59928
59929   result = (int)Dali::Vector< Dali::Vector2 >::BaseType;
59930   jresult = (int)result;
59931   return jresult;
59932 }
59933
59934
59935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorVector2__SWIG_0() {
59936   void * jresult ;
59937   Dali::Vector< Dali::Vector2 > *result = 0 ;
59938
59939   {
59940     try {
59941       result = (Dali::Vector< Dali::Vector2 > *)new Dali::Vector< Dali::Vector2 >();
59942     } CALL_CATCH_EXCEPTION(0);
59943   }
59944
59945   jresult = (void *)result;
59946   return jresult;
59947 }
59948
59949
59950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorVector2(void * jarg1) {
59951   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
59952
59953   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
59954   {
59955     try {
59956       delete arg1;
59957     } CALL_CATCH_EXCEPTION();
59958   }
59959 }
59960
59961
59962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorVector2__SWIG_1(void * jarg1) {
59963   void * jresult ;
59964   Dali::Vector< Dali::Vector2 > *arg1 = 0 ;
59965   Dali::Vector< Dali::Vector2 > *result = 0 ;
59966
59967   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
59968   if (!arg1) {
59969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 > const & type is null", 0);
59970     return 0;
59971   }
59972   {
59973     try {
59974       result = (Dali::Vector< Dali::Vector2 > *)new Dali::Vector< Dali::Vector2 >((Dali::Vector< Dali::Vector2 > const &)*arg1);
59975     } CALL_CATCH_EXCEPTION(0);
59976   }
59977
59978   jresult = (void *)result;
59979   return jresult;
59980 }
59981
59982
59983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Assign(void * jarg1, void * jarg2) {
59984   void * jresult ;
59985   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
59986   Dali::Vector< Dali::Vector2 > *arg2 = 0 ;
59987   Dali::Vector< Dali::Vector2 > *result = 0 ;
59988
59989   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
59990   arg2 = (Dali::Vector< Dali::Vector2 > *)jarg2;
59991   if (!arg2) {
59992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 > const & type is null", 0);
59993     return 0;
59994   }
59995   {
59996     try {
59997       result = (Dali::Vector< Dali::Vector2 > *) &(arg1)->operator =((Dali::Vector< Dali::Vector2 > const &)*arg2);
59998     } CALL_CATCH_EXCEPTION(0);
59999   }
60000
60001   jresult = (void *)result;
60002   return jresult;
60003 }
60004
60005
60006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Begin(void * jarg1) {
60007   void * jresult ;
60008   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60009   Dali::Vector< Dali::Vector2 >::Iterator result;
60010
60011   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60012   {
60013     try {
60014       result = (Dali::Vector< Dali::Vector2 >::Iterator)((Dali::Vector< Dali::Vector2 > const *)arg1)->Begin();
60015     } CALL_CATCH_EXCEPTION(0);
60016   }
60017
60018   jresult = (void *)result;
60019   return jresult;
60020 }
60021
60022
60023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_End(void * jarg1) {
60024   void * jresult ;
60025   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60026   Dali::Vector< Dali::Vector2 >::Iterator result;
60027
60028   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60029   {
60030     try {
60031       result = (Dali::Vector< Dali::Vector2 >::Iterator)((Dali::Vector< Dali::Vector2 > const *)arg1)->End();
60032     } CALL_CATCH_EXCEPTION(0);
60033   }
60034
60035   jresult = (void *)result;
60036   return jresult;
60037 }
60038
60039
60040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
60041   void * jresult ;
60042   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60043   Dali::Vector< Dali::Vector2 >::SizeType arg2 ;
60044   Dali::Vector< Dali::Vector2 >::ItemType *result = 0 ;
60045
60046   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60047   arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2;
60048   {
60049     try {
60050       result = (Dali::Vector< Dali::Vector2 >::ItemType *) &(arg1)->operator [](arg2);
60051     } CALL_CATCH_EXCEPTION(0);
60052   }
60053
60054   jresult = (void *)result;
60055   return jresult;
60056 }
60057
60058
60059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_PushBack(void * jarg1, void * jarg2) {
60060   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60061   Dali::Vector< Dali::Vector2 >::ItemType *arg2 = 0 ;
60062
60063   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60064   arg2 = (Dali::Vector< Dali::Vector2 >::ItemType *)jarg2;
60065   if (!arg2) {
60066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 >::ItemType const & type is null", 0);
60067     return ;
60068   }
60069   {
60070     try {
60071       (arg1)->PushBack((Dali::Vector< Dali::Vector2 >::ItemType const &)*arg2);
60072     } CALL_CATCH_EXCEPTION();
60073   }
60074 }
60075
60076
60077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
60078   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60079   Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
60080   Dali::Vector< Dali::Vector2 >::ItemType *arg3 = 0 ;
60081
60082   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60083   arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2;
60084   arg3 = (Dali::Vector< Dali::Vector2 >::ItemType *)jarg3;
60085   if (!arg3) {
60086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 >::ItemType const & type is null", 0);
60087     return ;
60088   }
60089   {
60090     try {
60091       (arg1)->Insert(arg2,(Dali::Vector< Dali::Vector2 >::ItemType const &)*arg3);
60092     } CALL_CATCH_EXCEPTION();
60093   }
60094 }
60095
60096
60097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
60098   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60099   Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
60100   Dali::Vector< Dali::Vector2 >::Iterator arg3 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
60101   Dali::Vector< Dali::Vector2 >::Iterator arg4 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
60102
60103   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60104   arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2;
60105   arg3 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg3;
60106   arg4 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg4;
60107   {
60108     try {
60109       (arg1)->Insert(arg2,arg3,arg4);
60110     } CALL_CATCH_EXCEPTION();
60111   }
60112 }
60113
60114
60115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Reserve(void * jarg1, unsigned long jarg2) {
60116   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60117   Dali::Vector< Dali::Vector2 >::SizeType arg2 ;
60118
60119   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60120   arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2;
60121   {
60122     try {
60123       (arg1)->Reserve(arg2);
60124     } CALL_CATCH_EXCEPTION();
60125   }
60126 }
60127
60128
60129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
60130   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60131   Dali::Vector< Dali::Vector2 >::SizeType arg2 ;
60132
60133   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60134   arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2;
60135   {
60136     try {
60137       (arg1)->Resize(arg2);
60138     } CALL_CATCH_EXCEPTION();
60139   }
60140 }
60141
60142
60143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
60144   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60145   Dali::Vector< Dali::Vector2 >::SizeType arg2 ;
60146   Dali::Vector< Dali::Vector2 >::ItemType *arg3 = 0 ;
60147
60148   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60149   arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2;
60150   arg3 = (Dali::Vector< Dali::Vector2 >::ItemType *)jarg3;
60151   if (!arg3) {
60152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
60153     return ;
60154   }
60155   {
60156     try {
60157       (arg1)->Resize(arg2,(Dali::Vector< Dali::Vector2 >::ItemType const &)*arg3);
60158     } CALL_CATCH_EXCEPTION();
60159   }
60160 }
60161
60162
60163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Erase__SWIG_0(void * jarg1, void * jarg2) {
60164   void * jresult ;
60165   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60166   Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
60167   Dali::Vector< Dali::Vector2 >::Iterator result;
60168
60169   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60170   arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2;
60171   {
60172     try {
60173       result = (Dali::Vector< Dali::Vector2 >::Iterator)(arg1)->Erase(arg2);
60174     } CALL_CATCH_EXCEPTION(0);
60175   }
60176
60177   jresult = (void *)result;
60178   return jresult;
60179 }
60180
60181
60182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
60183   void * jresult ;
60184   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60185   Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
60186   Dali::Vector< Dali::Vector2 >::Iterator arg3 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
60187   Dali::Vector< Dali::Vector2 >::Iterator result;
60188
60189   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60190   arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2;
60191   arg3 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg3;
60192   {
60193     try {
60194       result = (Dali::Vector< Dali::Vector2 >::Iterator)(arg1)->Erase(arg2,arg3);
60195     } CALL_CATCH_EXCEPTION(0);
60196   }
60197
60198   jresult = (void *)result;
60199   return jresult;
60200 }
60201
60202
60203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Remove(void * jarg1, void * jarg2) {
60204   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60205   Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
60206
60207   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60208   arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2;
60209   {
60210     try {
60211       (arg1)->Remove(arg2);
60212     } CALL_CATCH_EXCEPTION();
60213   }
60214 }
60215
60216
60217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Swap(void * jarg1, void * jarg2) {
60218   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60219   Dali::Vector< Dali::Vector2 > *arg2 = 0 ;
60220
60221   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60222   arg2 = (Dali::Vector< Dali::Vector2 > *)jarg2;
60223   if (!arg2) {
60224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 > & type is null", 0);
60225     return ;
60226   }
60227   {
60228     try {
60229       (arg1)->Swap(*arg2);
60230     } CALL_CATCH_EXCEPTION();
60231   }
60232 }
60233
60234
60235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Clear(void * jarg1) {
60236   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60237
60238   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60239   {
60240     try {
60241       (arg1)->Clear();
60242     } CALL_CATCH_EXCEPTION();
60243   }
60244 }
60245
60246
60247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Release(void * jarg1) {
60248   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60249
60250   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60251   {
60252     try {
60253       (arg1)->Release();
60254     } CALL_CATCH_EXCEPTION();
60255   }
60256 }
60257
60258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorVector2_Size(void * jarg1) {
60259   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60260   int size;
60261
60262   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60263   {
60264     try {
60265       size = (arg1)->Size();
60266     } CALL_CATCH_EXCEPTION(0);
60267   }
60268
60269   return size;
60270 }
60271
60272 #ifdef __cplusplus
60273 }
60274 #endif
60275