dali-csharp-binder/src/dali-wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #ifndef SWIGCSHARP
  12 #define SWIGCSHARP
  13 #endif
  14
  15 #define SWIG_DIRECTORS
  16
  17
  18 /* -----------------------------------------------------------------------------
  19  *  This section contains generic SWIG labels for method/variable
  20  *  declarations/attributes, and other compiler dependent labels.
  21  * ----------------------------------------------------------------------------- */
  22
  23 /* template workaround for compilers that cannot correctly implement the C++ standard */
  24 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  25 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  26 #  define SWIGTEMPLATEDISAMBIGUATOR template
  27 # elif defined(__HP_aCC)
  28 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  29 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  30 #  define SWIGTEMPLATEDISAMBIGUATOR template
  31 # else
  32 #  define SWIGTEMPLATEDISAMBIGUATOR
  33 # endif
  34 #endif
  35
  36 /* inline attribute */
  37 #ifndef SWIGINLINE
  38 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  39 #   define SWIGINLINE inline
  40 # else
  41 #   define SWIGINLINE
  42 # endif
  43 #endif
  44
  45 /* attribute recognised by some compilers to avoid 'unused' warnings */
  46 #ifndef SWIGUNUSED
  47 # if defined(__GNUC__)
  48 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  49 #     define SWIGUNUSED __attribute__ ((__unused__))
  50 #   else
  51 #     define SWIGUNUSED
  52 #   endif
  53 # elif defined(__ICC)
  54 #   define SWIGUNUSED __attribute__ ((__unused__))
  55 # else
  56 #   define SWIGUNUSED
  57 # endif
  58 #endif
  59
  60 #ifndef SWIG_MSC_UNSUPPRESS_4505
  61 # if defined(_MSC_VER)
  62 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  63 # endif
  64 #endif
  65
  66 #ifndef SWIGUNUSEDPARM
  67 # ifdef __cplusplus
  68 #   define SWIGUNUSEDPARM(p)
  69 # else
  70 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  71 # endif
  72 #endif
  73
  74 /* internal SWIG method */
  75 #ifndef SWIGINTERN
  76 # define SWIGINTERN static SWIGUNUSED
  77 #endif
  78
  79 /* internal inline SWIG method */
  80 #ifndef SWIGINTERNINLINE
  81 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
  82 #endif
  83
  84 /* exporting methods */
  85 #if defined(__GNUC__)
  86 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
  87 #    ifndef GCC_HASCLASSVISIBILITY
  88 #      define GCC_HASCLASSVISIBILITY
  89 #    endif
  90 #  endif
  91 #endif
  92
  93 #ifndef SWIGEXPORT
  94 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
  95 #   if defined(STATIC_LINKED)
  96 #     define SWIGEXPORT
  97 #   else
  98 #     define SWIGEXPORT __declspec(dllexport)
  99 #   endif
 100 # else
 101 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 102 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 103 #   else
 104 #     define SWIGEXPORT
 105 #   endif
 106 # endif
 107 #endif
 108
 109 /* calling conventions for Windows */
 110 #ifndef SWIGSTDCALL
 111 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 112 #   define SWIGSTDCALL __stdcall
 113 # else
 114 #   define SWIGSTDCALL
 115 # endif
 116 #endif
 117
 118 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 119 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 120 # define _CRT_SECURE_NO_DEPRECATE
 121 #endif
 122
 123 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 124 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 125 # define _SCL_SECURE_NO_DEPRECATE
 126 #endif
 127
 128 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 129 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 130 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 131 #endif
 132
 133 /* Intel's compiler complains if a variable which was never initialised is
 134  * cast to void, which is a common idiom which we use to indicate that we
 135  * are aware a variable isn't used.  So we just silence that warning.
 136  * See: https://github.com/swig/swig/issues/192 for more discussion.
 137  */
 138 #ifdef __INTEL_COMPILER
 139 # pragma warning disable 592
 140 #endif
 141
 142
 143 #include <stdlib.h>
 144 #include <string.h>
 145 #include <string_view>
 146 #include <stdio.h>
 147
 148 #include "common.h"
 149 #include "slim-custom-view-impl.h"
 150
 151 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 152   { SWIG_CSharpApplicationException, NULL },
 153   { SWIG_CSharpArithmeticException, NULL },
 154   { SWIG_CSharpDivideByZeroException, NULL },
 155   { SWIG_CSharpIndexOutOfRangeException, NULL },
 156   { SWIG_CSharpInvalidCastException, NULL },
 157   { SWIG_CSharpInvalidOperationException, NULL },
 158   { SWIG_CSharpIOException, NULL },
 159   { SWIG_CSharpNullReferenceException, NULL },
 160   { SWIG_CSharpOutOfMemoryException, NULL },
 161   { SWIG_CSharpOverflowException, NULL },
 162   { SWIG_CSharpSystemException, NULL }
 163 };
 164
 165 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 166   { SWIG_CSharpArgumentException, NULL },
 167   { SWIG_CSharpArgumentNullException, NULL },
 168   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 169 };
 170
 171 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 172   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 173   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 174     callback = SWIG_csharp_exceptions[code].callback;
 175   }
 176   callback(msg);
 177 }
 178
 179 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 180   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 181   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 182     callback = SWIG_csharp_exceptions_argument[code].callback;
 183   }
 184   callback(msg, param_name);
 185 }
 186
 187
 188 #ifdef __cplusplus
 189 extern "C"
 190 #endif
 191 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 192                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 193                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 194                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 195                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 196                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 197                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 198                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 199                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 200                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 201                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 202                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 203   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 204   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 205   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 206   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 207   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 208   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 209   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 210   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 211   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 212   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 213   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 214 }
 215
 216 #ifdef __cplusplus
 217 extern "C"
 218 #endif
 219 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 220                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 221                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 222                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 223   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 224   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 225   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 226 }
 227
 228
 229 /* Callback for returning strings to C# without leaking memory */
 230 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 231 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 232
 233 // keep argWidgetCs and argWidgetV so they're always available to DALi
 234 int argWidgetC = 1;
 235 char **argWidgetV = NULL;
 236
 237 #ifdef __cplusplus
 238 extern "C"
 239 #endif
 240 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 241   SWIG_csharp_string_callback = callback;
 242 }
 243
 244
 245 /* Contract support */
 246 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 247
 248
 249 /* -----------------------------------------------------------------------------
 250  * director_common.swg
 251  *
 252  * This file contains support for director classes which is common between
 253  * languages.
 254  * ----------------------------------------------------------------------------- */
 255
 256 /*
 257   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 258   'Swig' namespace. This could be useful for multi-modules projects.
 259 */
 260 #ifdef SWIG_DIRECTOR_STATIC
 261 /* Force anonymous (static) namespace */
 262 #define Swig
 263 #endif
 264 /* -----------------------------------------------------------------------------
 265  * director.swg
 266  *
 267  * This file contains support for director classes so that C# proxy
 268  * methods can be called from C++.
 269  * ----------------------------------------------------------------------------- */
 270
 271 #if defined(DEBUG_DIRECTOR_OWNED)
 272 #include <iostream>
 273 #endif
 274 #include <string>
 275 #include <exception>
 276
 277 namespace Swig {
 278   /* Director base class - not currently used in C# directors */
 279   class Director {
 280   };
 281
 282   /* Base class for director exceptions */
 283   class DirectorException : public std::exception {
 284   protected:
 285     std::string swig_msg;
 286
 287   public:
 288     DirectorException(const char *msg) : swig_msg(msg) {
 289     }
 290
 291     DirectorException(const std::string &msg) : swig_msg(msg) {
 292     }
 293
 294     virtual ~DirectorException() throw() {
 295     }
 296
 297     const char *what() const throw() {
 298       return swig_msg.c_str();
 299     }
 300   };
 301
 302   /* Pure virtual method exception */
 303   class DirectorPureVirtualException : public DirectorException {
 304   public:
 305     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 306     }
 307   };
 308 }
 309
 310
 311 void SWIG_CSharpException(int code, const char *msg) {
 312   if (code == SWIG_ValueError) {
 313     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 314     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 315   } else {
 316     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 317     switch(code) {
 318     case SWIG_MemoryError:
 319       exception_code = SWIG_CSharpOutOfMemoryException;
 320       break;
 321     case SWIG_IndexError:
 322       exception_code = SWIG_CSharpIndexOutOfRangeException;
 323       break;
 324     case SWIG_DivisionByZero:
 325       exception_code = SWIG_CSharpDivideByZeroException;
 326       break;
 327     case SWIG_IOError:
 328       exception_code = SWIG_CSharpIOException;
 329       break;
 330     case SWIG_OverflowError:
 331       exception_code = SWIG_CSharpOverflowException;
 332       break;
 333     case SWIG_RuntimeError:
 334     case SWIG_TypeError:
 335     case SWIG_SyntaxError:
 336     case SWIG_SystemError:
 337     case SWIG_UnknownError:
 338     default:
 339       exception_code = SWIG_CSharpApplicationException;
 340       break;
 341     }
 342     SWIG_CSharpSetPendingException(exception_code, msg);
 343   }
 344 }
 345
 346
 347 #include <stdexcept>
 348
 349
 350 #define SWIGSTDCALL
 351
 352 #include <time.h>
 353
 354 #include <dali/dali.h>
 355 #include <dali-toolkit/dali-toolkit.h>
 356
 357 #include <dali/devel-api/actors/actor-devel.h>
 358 #include <dali/devel-api/actors/camera-actor-devel.h>
 359 #include <dali/devel-api/animation/key-frames-devel.h>
 360 #include <dali/devel-api/common/stage-devel.h>
 361 #include <dali/devel-api/events/key-event-devel.h>
 362 #include <dali/devel-api/events/wheel-event-devel.h>
 363 #include <dali/devel-api/events/hover-event-devel.h>
 364 #include <dali/devel-api/events/touch-point.h>
 365 #include <dali/devel-api/events/pan-gesture-devel.h>
 366 #include <dali/devel-api/events/pinch-gesture-devel.h>
 367 #include <dali/devel-api/events/long-press-gesture-devel.h>
 368 #include <dali/devel-api/events/tap-gesture-devel.h>
 369
 370 #include <dali/public-api/math/matrix.h>
 371 #include <dali/public-api/math/matrix3.h>
 372 #include <dali/public-api/math/viewport.h>
 373 #include <dali/public-api/object/property-key.h>
 374 #include <dali/devel-api/object/csharp-type-info.h>
 375 #include <dali/devel-api/object/csharp-type-registry.h>
 376
 377 #include <dali/public-api/adaptor-framework/timer.h>
 378 #include <dali/public-api/adaptor-framework/style-change.h>
 379 #include <dali/devel-api/adaptor-framework/environment-variable.h>
 380
 381 #include <dali-toolkit/devel-api/accessibility-manager/accessibility-manager.h>
 382
 383 #include <dali-toolkit/devel-api/builder/builder.h>
 384
 385 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 386 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 387
 388 #include <dali-toolkit/devel-api/controls/control-devel.h>
 389 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 390 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 391 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 392 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 393 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 394 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 395 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 396 #include <dali-toolkit/devel-api/controls/alignment/alignment.h>
 397 #include <dali-toolkit/devel-api/controls/scroll-bar/scroll-bar.h>
 398 #include <dali-toolkit/devel-api/controls/table-view/table-view.h>
 399
 400 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 401 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 402 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 403
 404 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 405 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 406 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 407
 408 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 409 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 410 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
 411
 412 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 413
 414 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 415 #include <dali/devel-api/adaptor-framework/image-loading.h>
 416
 417 #include <dali/public-api/events/mouse-button.h>
 418
 419 #include <dali/integration-api/debug.h>
 420
 421 #include <dali-toolkit/devel-api/controls/video-view/video-view-devel.h>
 422
 423 #include <dali/devel-api/adaptor-framework/native-image-source-devel.h>
 424 #include <dali/devel-api/adaptor-framework/window-system-devel.h>
 425
 426 #include <dali-toolkit/devel-api/text/rendering-backend.h>
 427
 428 #include <dali/devel-api/update/frame-callback-interface.h>
 429 #include <dali/devel-api/update/update-proxy.h>
 430
 431 #include <dali-toolkit/public-api/image-loader/image.h>
 432 #include <dali-toolkit/public-api/image-loader/image-url.h>
 433
 434
 435 // add here SWIG version check
 436
 437 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 438 // disable Swig-dependent warnings
 439
 440 // 'identifier1' has C-linkage specified,
 441 // but returns UDT 'identifier2' which is incompatible with C
 442 #pragma warning(disable: 4190)
 443
 444 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 445 #pragma warning(disable: 4800)
 446
 447 // debug info too long etc etc
 448 #pragma warning(disable: 4786)
 449 #endif
 450
 451
 452 #include <stdexcept>
 453
 454
 455 #include <string>
 456
 457
 458 #include <vector>
 459 #include <algorithm>
 460 #include <stdexcept>
 461
 462
 463 #include <map>
 464 #include <algorithm>
 465 #include <stdexcept>
 466
 467
 468 #include <utility>
 469
 470
 471 typedef float floatp;
 472
 473 SWIGINTERN floatp *new_floatp(){
 474   return new float();
 475 }
 476 SWIGINTERN void delete_floatp(floatp *self){
 477   if (self) delete self;
 478 }
 479 SWIGINTERN void floatp_assign(floatp *self,float value){
 480   *self = value;
 481 }
 482 SWIGINTERN float floatp_value(floatp *self){
 483   return *self;
 484 }
 485 SWIGINTERN float *floatp_cast(floatp *self){
 486   return self;
 487 }
 488 SWIGINTERN floatp *floatp_frompointer(float *t){
 489   return (floatp *) t;
 490 }
 491
 492 typedef int intp;
 493
 494 SWIGINTERN intp *new_intp(){
 495   return new int();
 496 }
 497 SWIGINTERN void delete_intp(intp *self){
 498   if (self) delete self;
 499 }
 500 SWIGINTERN void intp_assign(intp *self,int value){
 501   *self = value;
 502 }
 503 SWIGINTERN int intp_value(intp *self){
 504   return *self;
 505 }
 506 SWIGINTERN int *intp_cast(intp *self){
 507   return self;
 508 }
 509 SWIGINTERN intp *intp_frompointer(int *t){
 510   return (intp *) t;
 511 }
 512
 513 typedef double doublep;
 514
 515 SWIGINTERN doublep *new_doublep(){
 516   return new double();
 517 }
 518 SWIGINTERN void delete_doublep(doublep *self){
 519   if (self) delete self;
 520 }
 521 SWIGINTERN void doublep_assign(doublep *self,double value){
 522   *self = value;
 523 }
 524 SWIGINTERN double doublep_value(doublep *self){
 525   return *self;
 526 }
 527 SWIGINTERN double *doublep_cast(doublep *self){
 528   return self;
 529 }
 530 SWIGINTERN doublep *doublep_frompointer(double *t){
 531   return (doublep *) t;
 532 }
 533
 534 typedef unsigned int uintp;
 535
 536 SWIGINTERN uintp *new_uintp(){
 537   return new unsigned int();
 538 }
 539 SWIGINTERN void delete_uintp(uintp *self){
 540   if (self) delete self;
 541 }
 542 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 543   *self = value;
 544 }
 545 SWIGINTERN unsigned int uintp_value(uintp *self){
 546   return *self;
 547 }
 548 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 549   return self;
 550 }
 551 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 552   return (uintp *) t;
 553 }
 554
 555 typedef unsigned short ushortp;
 556
 557 SWIGINTERN ushortp *new_ushortp(){
 558   return new unsigned short();
 559 }
 560 SWIGINTERN void delete_ushortp(ushortp *self){
 561   if (self) delete self;
 562 }
 563 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 564   *self = value;
 565 }
 566 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 567   return *self;
 568 }
 569 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 570   return self;
 571 }
 572 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 573   return (ushortp *) t;
 574 }
 575
 576 unsigned int int_to_uint(int x) {
 577    return (unsigned int) x;
 578 }
 579
 580
 581 using namespace Dali;
 582 using namespace Dali::Toolkit;
 583
 584 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 585 {
 586   bool result = false;
 587   try
 588   {
 589     // C++ code. DALi uses Handle <-> Body design pattern.
 590     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 591     // Handles in DALi can be converted into a boolean type
 592     // to check if the handle has a valid body attached to it.
 593     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 594     if( *self )
 595     {
 596       result = true;
 597     }
 598     else
 599     {
 600       result = false;
 601     }
 602   }
 603   CALL_CATCH_EXCEPTION(false);
 604   return result;
 605 }
 606
 607 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 608 {
 609   bool result = false;
 610   try
 611   {
 612     // C++ code. Check if two handles reference the same implemtion
 613     if( *self == rhs)
 614     {
 615       result = true;
 616     }
 617     else
 618     {
 619       result = false;
 620     }
 621   }
 622   CALL_CATCH_EXCEPTION(false);
 623   return result;
 624 }
 625
 626
 627 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 628      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 629    }
 630 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){
 631      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 632    }
 633 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 634         std::vector< Dali::TouchPoint >* pv = 0;
 635         if (capacity >= 0) {
 636           pv = new std::vector< Dali::TouchPoint >();
 637           pv->reserve(capacity);
 638        } else {
 639           throw std::out_of_range("capacity");
 640        }
 641        return pv;
 642       }
 643 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 644         if (index>=0 && index<(int)self->size())
 645           return (*self)[index];
 646         else
 647           throw std::out_of_range("index");
 648       }
 649 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 650         if (index>=0 && index<(int)self->size())
 651           return (*self)[index];
 652         else
 653           throw std::out_of_range("index");
 654       }
 655 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 656         if (index>=0 && index<(int)self->size())
 657           (*self)[index] = val;
 658         else
 659           throw std::out_of_range("index");
 660       }
 661 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 662         self->insert(self->end(), values.begin(), values.end());
 663       }
 664 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 665         if (index < 0)
 666           throw std::out_of_range("index");
 667         if (count < 0)
 668           throw std::out_of_range("count");
 669         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 670           throw std::invalid_argument("invalid range");
 671         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 672       }
 673 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 674         if (index>=0 && index<(int)self->size()+1)
 675           self->insert(self->begin()+index, x);
 676         else
 677           throw std::out_of_range("index");
 678       }
 679 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 680         if (index>=0 && index<(int)self->size()+1)
 681           self->insert(self->begin()+index, values.begin(), values.end());
 682         else
 683           throw std::out_of_range("index");
 684       }
 685 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 686         if (index>=0 && index<(int)self->size())
 687           self->erase(self->begin() + index);
 688         else
 689           throw std::out_of_range("index");
 690       }
 691 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 692         if (index < 0)
 693           throw std::out_of_range("index");
 694         if (count < 0)
 695           throw std::out_of_range("count");
 696         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 697           throw std::invalid_argument("invalid range");
 698         self->erase(self->begin()+index, self->begin()+index+count);
 699       }
 700 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 701         if (count < 0)
 702           throw std::out_of_range("count");
 703         return new std::vector< Dali::TouchPoint >(count, value);
 704       }
 705 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 706         std::reverse(self->begin(), self->end());
 707       }
 708 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 709         if (index < 0)
 710           throw std::out_of_range("index");
 711         if (count < 0)
 712           throw std::out_of_range("count");
 713         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 714           throw std::invalid_argument("invalid range");
 715         std::reverse(self->begin()+index, self->begin()+index+count);
 716       }
 717 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 718         if (index < 0)
 719           throw std::out_of_range("index");
 720         if (index+values.size() > self->size())
 721           throw std::out_of_range("index");
 722         std::copy(values.begin(), values.end(), self->begin()+index);
 723       }
 724 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 725          return self->Empty();
 726       }
 727 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 728         return self->GetConnectionCount();
 729       }
 730 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 731           self->Connect( func );
 732       }
 733 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 734           self->Disconnect( func );
 735       }
 736 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 737           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 738 /*@SWIG@*/ self->Emit( arg );
 739       }
 740 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 741          return self->Empty();
 742       }
 743 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 744         return self->GetConnectionCount();
 745       }
 746 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 747           self->Connect( func );
 748       }
 749 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 750           self->Disconnect( func );
 751       }
 752 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 753           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 754 /*@SWIG@*/ self->Emit( arg );
 755       }
 756 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 757          return self->Empty();
 758       }
 759 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){
 760         return self->GetConnectionCount();
 761       }
 762 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 *)){
 763           self->Connect( func );
 764       }
 765 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 *)){
 766           self->Disconnect( func );
 767       }
 768 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){
 769           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 770 /*@SWIG@*/ self->Emit( arg );
 771       }
 772 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 773          return self->Empty();
 774       }
 775 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 776         return self->GetConnectionCount();
 777       }
 778 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 779           self->Connect( func );
 780       }
 781 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 782           self->Disconnect( func );
 783       }
 784 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 785           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 786 /*@SWIG@*/ self->Emit( arg );
 787       }
 788 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){
 789          return self->Empty();
 790       }
 791 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){
 792         return self->GetConnectionCount();
 793       }
 794 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 &)){
 795         self->Connect( func );
 796       }
 797 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 &)){
 798         self->Disconnect( func );
 799       }
 800 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){
 801         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 802 /*@SWIG@*/ self->Emit( arg1, arg2 );
 803       }
 804 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){
 805          return self->Empty();
 806       }
 807 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){
 808         return self->GetConnectionCount();
 809       }
 810 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 &)){
 811         self->Connect( func );
 812       }
 813 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 &)){
 814         self->Disconnect( func );
 815       }
 816 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){
 817         return self->Emit( arg1, arg2 );
 818       }
 819 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){
 820          return self->Empty();
 821       }
 822 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){
 823         return self->GetConnectionCount();
 824       }
 825 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 &)){
 826         self->Connect( func );
 827       }
 828 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 &)){
 829         self->Disconnect( func );
 830       }
 831 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){
 832         return self->Emit( arg1, arg2 );
 833       }
 834 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){
 835          return self->Empty();
 836       }
 837 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){
 838         return self->GetConnectionCount();
 839       }
 840 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 &)){
 841         self->Connect( func );
 842       }
 843 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 &)){
 844         self->Disconnect( func );
 845       }
 846 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){
 847         return self->Emit( arg1, arg2 );
 848       }
 849 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 850          return self->Empty();
 851       }
 852 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 853         return self->GetConnectionCount();
 854       }
 855 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 856           self->Connect( func );
 857       }
 858 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 859           self->Disconnect( func );
 860       }
 861 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 862           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 863 /*@SWIG@*/ self->Emit( arg );
 864       }
 865 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 866          return self->Empty();
 867       }
 868 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){
 869         return self->GetConnectionCount();
 870       }
 871 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 &)){
 872           self->Connect( func );
 873       }
 874 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 &)){
 875           self->Disconnect( func );
 876       }
 877 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){
 878           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 879 /*@SWIG@*/ self->Emit( arg );
 880       }
 881 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchEvent const &) > const *self){
 882          return self->Empty();
 883       }
 884 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){
 885         return self->GetConnectionCount();
 886       }
 887 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 &)){
 888           self->Connect( func );
 889       }
 890 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 &)){
 891           self->Disconnect( func );
 892       }
 893 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){
 894           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 895 /*@SWIG@*/ self->Emit( arg );
 896       }
 897 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 898          return self->Empty();
 899       }
 900 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){
 901         return self->GetConnectionCount();
 902       }
 903 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 &)){
 904           self->Connect( func );
 905       }
 906 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 &)){
 907           self->Disconnect( func );
 908       }
 909 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){
 910           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 911 /*@SWIG@*/ self->Emit( arg );
 912       }
 913 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){
 914          return self->Empty();
 915       }
 916 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){
 917         return self->GetConnectionCount();
 918       }
 919 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 &)){
 920         self->Connect( func );
 921       }
 922 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 &)){
 923         self->Disconnect( func );
 924       }
 925 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){
 926         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 927 /*@SWIG@*/ self->Emit( arg1, arg2 );
 928       }
 929 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){
 930          return self->Empty();
 931       }
 932 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){
 933         return self->GetConnectionCount();
 934       }
 935 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 &)){
 936         self->Connect( func );
 937       }
 938 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 &)){
 939         self->Disconnect( func );
 940       }
 941 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){
 942         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 943 /*@SWIG@*/ self->Emit( arg1, arg2 );
 944       }
 945 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){
 946          return self->Empty();
 947       }
 948 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){
 949         return self->GetConnectionCount();
 950       }
 951 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 &)){
 952         self->Connect( func );
 953       }
 954 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 &)){
 955         self->Disconnect( func );
 956       }
 957 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){
 958         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 959 /*@SWIG@*/ self->Emit( arg1, arg2 );
 960       }
 961 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){
 962          return self->Empty();
 963       }
 964 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){
 965         return self->GetConnectionCount();
 966       }
 967 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)){
 968           return self->Connect( func );
 969       }
 970 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)){
 971           self->Disconnect( func );
 972       }
 973 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){
 974           self->Emit( arg1, arg3 );
 975       }
 976 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){
 977          return self->Empty();
 978       }
 979 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){
 980         return self->GetConnectionCount();
 981       }
 982 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)){
 983           return self->Connect( func );
 984       }
 985 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)){
 986           self->Disconnect( func );
 987       }
 988 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){
 989           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 990 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
 991       }
 992
 993 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
 994          return self->Empty();
 995       }
 996 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
 997         return self->GetConnectionCount();
 998       }
 999 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1000           self->Connect( func );
1001       }
1002 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1003           self->Disconnect( func );
1004       }
1005 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1006           return self->Emit();
1007       }
1008
1009 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1010         std::vector< unsigned int >* pv = 0;
1011         if (capacity >= 0) {
1012           pv = new std::vector< unsigned int >();
1013           pv->reserve(capacity);
1014        } else {
1015           throw std::out_of_range("capacity");
1016        }
1017        return pv;
1018       }
1019 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1020         if (index>=0 && index<(int)self->size())
1021           return (*self)[index];
1022         else
1023           throw std::out_of_range("index");
1024       }
1025 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1026         if (index>=0 && index<(int)self->size())
1027           return (*self)[index];
1028         else
1029           throw std::out_of_range("index");
1030       }
1031 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1032         if (index>=0 && index<(int)self->size())
1033           (*self)[index] = val;
1034         else
1035           throw std::out_of_range("index");
1036       }
1037 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1038         self->insert(self->end(), values.begin(), values.end());
1039       }
1040 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1041         if (index < 0)
1042           throw std::out_of_range("index");
1043         if (count < 0)
1044           throw std::out_of_range("count");
1045         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1046           throw std::invalid_argument("invalid range");
1047         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1048       }
1049 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1050         if (index>=0 && index<(int)self->size()+1)
1051           self->insert(self->begin()+index, x);
1052         else
1053           throw std::out_of_range("index");
1054       }
1055 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1056         if (index>=0 && index<(int)self->size()+1)
1057           self->insert(self->begin()+index, values.begin(), values.end());
1058         else
1059           throw std::out_of_range("index");
1060       }
1061 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1062         if (index>=0 && index<(int)self->size())
1063           self->erase(self->begin() + index);
1064         else
1065           throw std::out_of_range("index");
1066       }
1067 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1068         if (index < 0)
1069           throw std::out_of_range("index");
1070         if (count < 0)
1071           throw std::out_of_range("count");
1072         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1073           throw std::invalid_argument("invalid range");
1074         self->erase(self->begin()+index, self->begin()+index+count);
1075       }
1076 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1077         if (count < 0)
1078           throw std::out_of_range("count");
1079         return new std::vector< unsigned int >(count, value);
1080       }
1081 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1082         std::reverse(self->begin(), self->end());
1083       }
1084 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1085         if (index < 0)
1086           throw std::out_of_range("index");
1087         if (count < 0)
1088           throw std::out_of_range("count");
1089         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1090           throw std::invalid_argument("invalid range");
1091         std::reverse(self->begin()+index, self->begin()+index+count);
1092       }
1093 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1094         if (index < 0)
1095           throw std::out_of_range("index");
1096         if (index+values.size() > self->size())
1097           throw std::out_of_range("index");
1098         std::copy(values.begin(), values.end(), self->begin()+index);
1099       }
1100 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1101         return std::find(self->begin(), self->end(), value) != self->end();
1102       }
1103 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1104         int index = -1;
1105         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1106         if (it != self->end())
1107           index = (int)(it - self->begin());
1108         return index;
1109       }
1110 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1111         int index = -1;
1112         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1113         if (rit != self->rend())
1114           index = (int)(self->rend() - 1 - rit);
1115         return index;
1116       }
1117 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1118         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1119         if (it != self->end()) {
1120           self->erase(it);
1121           return true;
1122         }
1123         return false;
1124       }
1125 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){
1126         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1127         if (capacity >= 0) {
1128           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1129           pv->reserve(capacity);
1130        } else {
1131           throw std::out_of_range("capacity");
1132        }
1133        return pv;
1134       }
1135 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){
1136         if (index>=0 && index<(int)self->size())
1137           return (*self)[index];
1138         else
1139           throw std::out_of_range("index");
1140       }
1141 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){
1142         if (index>=0 && index<(int)self->size())
1143           return (*self)[index];
1144         else
1145           throw std::out_of_range("index");
1146       }
1147 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){
1148         if (index>=0 && index<(int)self->size())
1149           (*self)[index] = val;
1150         else
1151           throw std::out_of_range("index");
1152       }
1153 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){
1154         self->insert(self->end(), values.begin(), values.end());
1155       }
1156 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){
1157         if (index < 0)
1158           throw std::out_of_range("index");
1159         if (count < 0)
1160           throw std::out_of_range("count");
1161         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1162           throw std::invalid_argument("invalid range");
1163         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1164       }
1165 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){
1166         if (index>=0 && index<(int)self->size()+1)
1167           self->insert(self->begin()+index, x);
1168         else
1169           throw std::out_of_range("index");
1170       }
1171 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){
1172         if (index>=0 && index<(int)self->size()+1)
1173           self->insert(self->begin()+index, values.begin(), values.end());
1174         else
1175           throw std::out_of_range("index");
1176       }
1177 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){
1178         if (index>=0 && index<(int)self->size())
1179           self->erase(self->begin() + index);
1180         else
1181           throw std::out_of_range("index");
1182       }
1183 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){
1184         if (index < 0)
1185           throw std::out_of_range("index");
1186         if (count < 0)
1187           throw std::out_of_range("count");
1188         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1189           throw std::invalid_argument("invalid range");
1190         self->erase(self->begin()+index, self->begin()+index+count);
1191       }
1192 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){
1193         if (count < 0)
1194           throw std::out_of_range("count");
1195         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1196       }
1197 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){
1198         std::reverse(self->begin(), self->end());
1199       }
1200 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){
1201         if (index < 0)
1202           throw std::out_of_range("index");
1203         if (count < 0)
1204           throw std::out_of_range("count");
1205         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1206           throw std::invalid_argument("invalid range");
1207         std::reverse(self->begin()+index, self->begin()+index+count);
1208       }
1209 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){
1210         if (index < 0)
1211           throw std::out_of_range("index");
1212         if (index+values.size() > self->size())
1213           throw std::out_of_range("index");
1214         std::copy(values.begin(), values.end(), self->begin()+index);
1215       }
1216 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1217         std::vector< Dali::Actor >* pv = 0;
1218         if (capacity >= 0) {
1219           pv = new std::vector< Dali::Actor >();
1220           pv->reserve(capacity);
1221        } else {
1222           throw std::out_of_range("capacity");
1223        }
1224        return pv;
1225       }
1226 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1227         if (index>=0 && index<(int)self->size())
1228           return (*self)[index];
1229         else
1230           throw std::out_of_range("index");
1231       }
1232 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1233         if (index>=0 && index<(int)self->size())
1234           return (*self)[index];
1235         else
1236           throw std::out_of_range("index");
1237       }
1238 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1239         if (index>=0 && index<(int)self->size())
1240           (*self)[index] = val;
1241         else
1242           throw std::out_of_range("index");
1243       }
1244 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1245         self->insert(self->end(), values.begin(), values.end());
1246       }
1247 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1248         if (index < 0)
1249           throw std::out_of_range("index");
1250         if (count < 0)
1251           throw std::out_of_range("count");
1252         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1253           throw std::invalid_argument("invalid range");
1254         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1255       }
1256 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1257         if (index>=0 && index<(int)self->size()+1)
1258           self->insert(self->begin()+index, x);
1259         else
1260           throw std::out_of_range("index");
1261       }
1262 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1263         if (index>=0 && index<(int)self->size()+1)
1264           self->insert(self->begin()+index, values.begin(), values.end());
1265         else
1266           throw std::out_of_range("index");
1267       }
1268 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1269         if (index>=0 && index<(int)self->size())
1270           self->erase(self->begin() + index);
1271         else
1272           throw std::out_of_range("index");
1273       }
1274 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1275         if (index < 0)
1276           throw std::out_of_range("index");
1277         if (count < 0)
1278           throw std::out_of_range("count");
1279         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1280           throw std::invalid_argument("invalid range");
1281         self->erase(self->begin()+index, self->begin()+index+count);
1282       }
1283 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1284         if (count < 0)
1285           throw std::out_of_range("count");
1286         return new std::vector< Dali::Actor >(count, value);
1287       }
1288 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1289         std::reverse(self->begin(), self->end());
1290       }
1291 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1292         if (index < 0)
1293           throw std::out_of_range("index");
1294         if (count < 0)
1295           throw std::out_of_range("count");
1296         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1297           throw std::invalid_argument("invalid range");
1298         std::reverse(self->begin()+index, self->begin()+index+count);
1299       }
1300 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1301         if (index < 0)
1302           throw std::out_of_range("index");
1303         if (index+values.size() > self->size())
1304           throw std::out_of_range("index");
1305         std::copy(values.begin(), values.end(), self->begin()+index);
1306       }
1307 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1308          return self->Empty();
1309       }
1310 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1311         return self->GetConnectionCount();
1312       }
1313 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 &)){
1314           self->Connect( func );
1315       }
1316 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 &)){
1317           self->Disconnect( func );
1318       }
1319 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){
1320           return self->Emit( arg );
1321       }
1322 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){
1323          return self->Empty();
1324       }
1325 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){
1326         return self->GetConnectionCount();
1327       }
1328 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)){
1329         self->Connect( func );
1330       }
1331 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)){
1332         self->Disconnect( func );
1333       }
1334 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){
1335         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1336 /*@SWIG@*/ self->Emit( arg1, arg2 );
1337       }
1338 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1339          return self->Empty();
1340       }
1341 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){
1342         return self->GetConnectionCount();
1343       }
1344 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)){
1345         self->Connect( func );
1346       }
1347 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)){
1348         self->Disconnect( func );
1349       }
1350 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){
1351         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1352 /*@SWIG@*/ self->Emit( arg1, arg2 );
1353       }
1354 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1355          return self->Empty();
1356       }
1357 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1358         return self->GetConnectionCount();
1359       }
1360 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)){
1361         self->Connect( func );
1362       }
1363 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)){
1364         self->Disconnect( func );
1365       }
1366 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){
1367         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1368 /*@SWIG@*/ self->Emit( arg1, arg2 );
1369       }
1370 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){
1371          return self->Empty();
1372       }
1373 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){
1374         return self->GetConnectionCount();
1375       }
1376 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)){
1377         self->Connect( func );
1378       }
1379 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)){
1380         self->Disconnect( func );
1381       }
1382 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){
1383         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1384 /*@SWIG@*/ self->Emit( arg1, arg2 );
1385       }
1386 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1387          return self->Empty();
1388       }
1389 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1390         return self->GetConnectionCount();
1391       }
1392 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)){
1393           self->Connect( func );
1394       }
1395 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)){
1396           self->Disconnect( func );
1397       }
1398 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1399           return self->Emit( arg );
1400       }
1401 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1402          return self->Empty();
1403       }
1404 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1405         return self->GetConnectionCount();
1406       }
1407 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)){
1408           self->Connect( func );
1409       }
1410 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)){
1411           self->Disconnect( func );
1412       }
1413 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1414           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1415 /*@SWIG@*/ self->Emit( arg );
1416       }
1417 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){
1418          return self->Empty();
1419       }
1420 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){
1421         return self->GetConnectionCount();
1422       }
1423 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)){
1424           return self->Connect( func );
1425       }
1426 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)){
1427           self->Disconnect( func );
1428       }
1429 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){
1430           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1431 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1432       }
1433 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1434          return self->Empty();
1435       }
1436 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1437         return self->GetConnectionCount();
1438       }
1439 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)){
1440           self->Connect( func );
1441       }
1442 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)){
1443           self->Disconnect( func );
1444       }
1445 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1446           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1447 /*@SWIG@*/ self->Emit( arg );
1448       }
1449 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){
1450          return self->Empty();
1451       }
1452 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){
1453         return self->GetConnectionCount();
1454       }
1455 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)){
1456           return self->Connect( func );
1457       }
1458 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)){
1459           self->Disconnect( func );
1460       }
1461 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){
1462           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1463 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1464       }
1465 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){
1466          return self->Empty();
1467       }
1468 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){
1469         return self->GetConnectionCount();
1470       }
1471 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 &)){
1472           self->Connect( func );
1473       }
1474 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 &)){
1475           self->Disconnect( func );
1476       }
1477 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){
1478           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1479 /*@SWIG@*/ self->Emit( arg );
1480       }
1481 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1482          return self->Empty();
1483       }
1484 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){
1485         return self->GetConnectionCount();
1486       }
1487 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 &)){
1488           self->Connect( func );
1489       }
1490 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 &)){
1491           self->Disconnect( func );
1492       }
1493 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){
1494           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1495 /*@SWIG@*/ self->Emit( arg );
1496       }
1497
1498
1499 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){
1500          return self->Empty();
1501       }
1502 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){
1503         return self->GetConnectionCount();
1504       }
1505 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 &)){
1506         self->Connect( func );
1507       }
1508 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 &)){
1509         self->Disconnect( func );
1510       }
1511 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){
1512         return self->Emit( arg1, arg2 );
1513       }
1514 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1515          return self->Empty();
1516       }
1517 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1518         return self->GetConnectionCount();
1519       }
1520 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)){
1521           self->Connect( func );
1522       }
1523 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)){
1524           self->Disconnect( func );
1525       }
1526 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1527           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1528 /*@SWIG@*/ self->Emit( arg );
1529       }
1530 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1531          return self->Empty();
1532       }
1533 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1534         return self->GetConnectionCount();
1535       }
1536 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 &)){
1537           self->Connect( func );
1538       }
1539 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 &)){
1540           self->Disconnect( func );
1541       }
1542 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){
1543           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1544 /*@SWIG@*/ self->Emit( arg );
1545       }
1546 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1547          return self->Empty();
1548       }
1549 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){
1550         return self->GetConnectionCount();
1551       }
1552 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)){
1553         self->Connect( func );
1554       }
1555 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)){
1556         self->Disconnect( func );
1557       }
1558 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){
1559         return self->Emit( arg1, arg2 );
1560       }
1561 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1562          return self->Empty();
1563       }
1564 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){
1565         return self->GetConnectionCount();
1566       }
1567 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)){
1568         self->Connect( func );
1569       }
1570 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)){
1571         self->Disconnect( func );
1572       }
1573 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){
1574         return self->Emit( arg1, arg2 );
1575       }
1576
1577 /* ---------------------------------------------------
1578  * C++ director class methods
1579  * --------------------------------------------------- */
1580
1581 #include "dali-wrap.h"
1582
1583 /*
1584  *  Widget director
1585  */
1586 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1587   swig_init_callbacks();
1588 }
1589
1590 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1591 }
1592
1593 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1594   char * jcontentInfo = 0 ;
1595   void * jwindow  ;
1596
1597   if (!swig_callbackOnCreate) {
1598     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1599     return;
1600   } else {
1601     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1602     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1603     swig_callbackOnCreate(jcontentInfo, jwindow);
1604   }
1605 }
1606
1607 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1608   char * jcontentInfo = 0 ;
1609   int jtype  ;
1610
1611   if (!swig_callbackOnTerminate) {
1612     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1613     return;
1614   } else {
1615     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1616     jtype = (int)type;
1617     swig_callbackOnTerminate(jcontentInfo, jtype);
1618   }
1619 }
1620
1621 void SwigDirector_WidgetImpl::OnPause() {
1622   if (!swig_callbackOnPause) {
1623     Dali::Internal::Adaptor::Widget::OnPause();
1624     return;
1625   } else {
1626     swig_callbackOnPause();
1627   }
1628 }
1629
1630 void SwigDirector_WidgetImpl::OnResume() {
1631   if (!swig_callbackOnResume) {
1632     Dali::Internal::Adaptor::Widget::OnResume();
1633     return;
1634   } else {
1635     swig_callbackOnResume();
1636   }
1637 }
1638
1639 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1640   void * jwindow  ;
1641
1642   if (!swig_callbackOnResize) {
1643     Dali::Internal::Adaptor::Widget::OnResize(window);
1644     return;
1645   } else {
1646     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1647     swig_callbackOnResize(jwindow);
1648   }
1649 }
1650
1651 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1652   char * jcontentInfo = 0 ;
1653   int jforce  ;
1654
1655   if (!swig_callbackOnUpdate) {
1656     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1657     return;
1658   } else {
1659     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1660     jforce = force;
1661     swig_callbackOnUpdate(jcontentInfo, jforce);
1662   }
1663 }
1664
1665 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1666   void * jslotObserver = 0 ;
1667   void * jcallback = 0 ;
1668
1669   if (!swig_callbackSignalConnected) {
1670     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1671     return;
1672   } else {
1673     jslotObserver = (void *) slotObserver;
1674     jcallback = (void *) callback;
1675     swig_callbackSignalConnected(jslotObserver, jcallback);
1676   }
1677 }
1678
1679 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1680   void * jslotObserver = 0 ;
1681   void * jcallback = 0 ;
1682
1683   if (!swig_callbackSignalDisconnected) {
1684     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1685     return;
1686   } else {
1687     jslotObserver = (void *) slotObserver;
1688     jcallback = (void *) callback;
1689     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1690   }
1691 }
1692
1693 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) {
1694
1695   swig_callbackOnCreate = callbackOnCreate;
1696   swig_callbackOnTerminate = callbackOnTerminate;
1697   swig_callbackOnPause = callbackOnPause;
1698   swig_callbackOnResume = callbackOnResume;
1699   swig_callbackOnResize = callbackOnResize;
1700   swig_callbackOnUpdate = callbackOnUpdate;
1701   swig_callbackSignalConnected = callbackSignalConnected;
1702   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1703 }
1704
1705 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1706   swig_callbackOnCreate = 0;
1707   swig_callbackOnTerminate = 0;
1708   swig_callbackOnPause = 0;
1709   swig_callbackOnResume = 0;
1710   swig_callbackOnResize = 0;
1711   swig_callbackOnUpdate = 0;
1712   swig_callbackSignalConnected = 0;
1713   swig_callbackSignalDisconnected = 0;
1714 }
1715
1716
1717 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1718   swig_init_callbacks();
1719 }
1720
1721 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1722
1723 }
1724
1725
1726 void SwigDirector_ViewImpl::OnSceneConnection(int depth) {
1727   int jdepth  ;
1728
1729   if (!swig_callbackOnSceneConnection) {
1730     Dali::Toolkit::Internal::Control::OnSceneConnection(depth);
1731     return;
1732   } else {
1733     jdepth = depth;
1734     swig_callbackOnSceneConnection(jdepth);
1735   }
1736 }
1737
1738 void SwigDirector_ViewImpl::OnSceneDisconnection() {
1739   if (!swig_callbackOnSceneDisconnection) {
1740     Dali::Toolkit::Internal::Control::OnSceneDisconnection();
1741     return;
1742   } else {
1743     swig_callbackOnSceneDisconnection();
1744   }
1745 }
1746
1747 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1748   void * jchild = 0 ;
1749
1750   if (!swig_callbackOnChildAdd) {
1751     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1752     return;
1753   } else {
1754     jchild = (Dali::Actor *) &child;
1755     swig_callbackOnChildAdd(jchild);
1756   }
1757 }
1758
1759 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1760   void * jchild = 0 ;
1761
1762   if (!swig_callbackOnChildRemove) {
1763     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1764     return;
1765   } else {
1766     jchild = (Dali::Actor *) &child;
1767     swig_callbackOnChildRemove(jchild);
1768   }
1769 }
1770
1771 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, const Dali::Property::Value& propertyValue) {
1772   int jindex  ;
1773   void * jpropertyValue  ;
1774
1775   if (!swig_callbackOnPropertySet) {
1776     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1777     return;
1778   } else {
1779     jindex = index;
1780     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1781     swig_callbackOnPropertySet(jindex, jpropertyValue);
1782   }
1783 }
1784
1785 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1786   void * jtargetSize = 0 ;
1787
1788   if (!swig_callbackOnSizeSet) {
1789     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1790     return;
1791   } else {
1792     jtargetSize = (Dali::Vector3 *) &targetSize;
1793     swig_callbackOnSizeSet(jtargetSize);
1794   }
1795 }
1796
1797 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1798   void * janimation = 0 ;
1799   void * jtargetSize = 0 ;
1800
1801   if (!swig_callbackOnSizeAnimation) {
1802     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1803     return;
1804   } else {
1805     janimation = (Dali::Animation *) &animation;
1806     jtargetSize = (Dali::Vector3 *) &targetSize;
1807     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1808   }
1809 }
1810
1811 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1812   bool c_result = SwigValueInit< bool >() ;
1813   unsigned int jresult = 0 ;
1814   void * jarg0 = 0 ;
1815
1816   if (!swig_callbackOnKeyEvent) {
1817     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1818   } else {
1819     jarg0 = (Dali::KeyEvent *) &event;
1820     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1821     c_result = jresult ? true : false;
1822   }
1823   return c_result;
1824 }
1825
1826 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1827   void * jsize = 0 ;
1828   void * jcontainer = 0 ;
1829
1830   if (!swig_callbackOnRelayout) {
1831     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1832     return;
1833   } else {
1834     jsize = (Dali::Vector2 *) &size;
1835     jcontainer = (Dali::RelayoutContainer *) &container;
1836     swig_callbackOnRelayout(jsize, jcontainer);
1837   }
1838 }
1839
1840 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1841   int jpolicy  ;
1842   int jdimension  ;
1843
1844   if (!swig_callbackOnSetResizePolicy) {
1845     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1846     return;
1847   } else {
1848     jpolicy = (int)policy;
1849     jdimension = (int)dimension;
1850     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1851   }
1852 }
1853
1854 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1855   Dali::Vector3 c_result ;
1856   void * jresult = 0 ;
1857
1858   if (!swig_callbackGetNaturalSize) {
1859     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1860   } else {
1861     jresult = (void *) swig_callbackGetNaturalSize();
1862     if (!jresult) {
1863       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1864       return c_result;
1865     }
1866     c_result = *(Dali::Vector3 *)jresult;
1867   }
1868   return c_result;
1869 }
1870
1871 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1872   float c_result = SwigValueInit< float >() ;
1873   float jresult = 0 ;
1874   void * jchild = 0 ;
1875   int jdimension  ;
1876
1877   if (!swig_callbackCalculateChildSize) {
1878     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1879   } else {
1880     jchild = (Dali::Actor *) &child;
1881     jdimension = (int)dimension;
1882     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1883     c_result = (float)jresult;
1884   }
1885   return c_result;
1886 }
1887
1888 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1889   float c_result = SwigValueInit< float >() ;
1890   float jresult = 0 ;
1891   float jwidth  ;
1892
1893   if (!swig_callbackGetHeightForWidth) {
1894     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1895   } else {
1896     jwidth = width;
1897     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1898     c_result = (float)jresult;
1899   }
1900   return c_result;
1901 }
1902
1903 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1904   float c_result = SwigValueInit< float >() ;
1905   float jresult = 0 ;
1906   float jheight  ;
1907
1908   if (!swig_callbackGetWidthForHeight) {
1909     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1910   } else {
1911     jheight = height;
1912     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1913     c_result = (float)jresult;
1914   }
1915   return c_result;
1916 }
1917
1918 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1919   bool c_result = SwigValueInit< bool >() ;
1920   unsigned int jresult = 0 ;
1921   int jdimension  ;
1922
1923   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1924     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1925   } else {
1926     jdimension = (int)dimension;
1927     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1928     c_result = jresult ? true : false;
1929   }
1930   return c_result;
1931 }
1932
1933 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1934   int jdimension  ;
1935
1936   if (!swig_callbackOnCalculateRelayoutSize) {
1937     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1938     return;
1939   } else {
1940     jdimension = (int)dimension;
1941     swig_callbackOnCalculateRelayoutSize(jdimension);
1942   }
1943 }
1944
1945 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1946   float jsize  ;
1947   int jdimension  ;
1948
1949   if (!swig_callbackOnLayoutNegotiated) {
1950     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
1951     return;
1952   } else {
1953     jsize = size;
1954     jdimension = (int)dimension;
1955     swig_callbackOnLayoutNegotiated(jsize, jdimension);
1956   }
1957 }
1958
1959 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
1960   return Dali::CustomActorImpl::GetExtension();
1961 }
1962
1963 void SwigDirector_ViewImpl::OnInitialize() {
1964   if (!swig_callbackOnInitialize) {
1965     Dali::Toolkit::Internal::Control::OnInitialize();
1966     return;
1967   } else {
1968     swig_callbackOnInitialize();
1969   }
1970 }
1971
1972 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
1973   void * jstyleManager  ;
1974   int jchange  ;
1975
1976   if (!swig_callbackOnStyleChange) {
1977     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
1978     return;
1979   } else {
1980     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
1981     jchange = (int)change;
1982     swig_callbackOnStyleChange(jstyleManager, jchange);
1983   }
1984 }
1985
1986 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
1987   bool c_result = SwigValueInit< bool >() ;
1988   unsigned int jresult = 0 ;
1989
1990   if (!swig_callbackOnAccessibilityActivated) {
1991     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
1992   } else {
1993     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
1994     c_result = jresult ? true : false;
1995   }
1996   return c_result;
1997 }
1998
1999 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2000   bool c_result = SwigValueInit< bool >() ;
2001   unsigned int jresult = 0 ;
2002   void * jgesture  ;
2003
2004   if (!swig_callbackOnAccessibilityPan) {
2005     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2006   } else {
2007     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2008     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2009     c_result = jresult ? true : false;
2010   }
2011   return c_result;
2012 }
2013
2014 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2015   bool c_result = SwigValueInit< bool >() ;
2016   unsigned int jresult = 0 ;
2017   unsigned int jisIncrease  ;
2018
2019   if (!swig_callbackOnAccessibilityValueChange) {
2020     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2021   } else {
2022     jisIncrease = isIncrease;
2023     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2024     c_result = jresult ? true : false;
2025   }
2026   return c_result;
2027 }
2028
2029 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2030   bool c_result = SwigValueInit< bool >() ;
2031   unsigned int jresult = 0 ;
2032
2033   if (!swig_callbackOnAccessibilityZoom) {
2034     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2035   } else {
2036     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2037     c_result = jresult ? true : false;
2038   }
2039   return c_result;
2040 }
2041
2042 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2043   if (!swig_callbackOnKeyInputFocusGained) {
2044     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2045     return;
2046   } else {
2047     swig_callbackOnKeyInputFocusGained();
2048   }
2049 }
2050
2051 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2052   if (!swig_callbackOnKeyInputFocusLost) {
2053     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2054     return;
2055   } else {
2056     swig_callbackOnKeyInputFocusLost();
2057   }
2058 }
2059
2060
2061 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled)
2062 {
2063   Dali::Actor c_result;
2064   void* jresult = 0;
2065
2066   if(!swig_callbackGetNextKeyboardFocusableActor)
2067   {
2068     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2069   }
2070   else
2071   {
2072     jresult = (void*)swig_callbackGetNextKeyboardFocusableActor((void*)(&currentFocusedActor), (int)direction, loopEnabled);
2073
2074     if(!jresult)
2075     {
2076       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2077       return c_result;
2078     }
2079     c_result = *(Dali::Actor*)jresult;
2080   }
2081   return c_result;
2082 }
2083
2084 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor)
2085 {
2086   if(!swig_callbackOnKeyboardFocusChangeCommitted)
2087   {
2088     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2089     return;
2090   }
2091   else
2092   {
2093     swig_callbackOnKeyboardFocusChangeCommitted((void*)(&commitedFocusableActor));
2094   }
2095 }
2096
2097 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2098   bool c_result = SwigValueInit< bool >() ;
2099   unsigned int jresult = 0 ;
2100
2101   if (!swig_callbackOnKeyboardEnter) {
2102     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2103   } else {
2104     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2105     c_result = jresult ? true : false;
2106   }
2107   return c_result;
2108 }
2109
2110 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2111   void * jpinch = 0 ;
2112
2113   if (!swig_callbackOnPinch) {
2114     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2115     return;
2116   } else {
2117     jpinch = (Dali::PinchGesture *) &pinch;
2118     swig_callbackOnPinch(jpinch);
2119   }
2120 }
2121
2122 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2123   void * jpan = 0 ;
2124
2125   if (!swig_callbackOnPan) {
2126     Dali::Toolkit::Internal::Control::OnPan(pan);
2127     return;
2128   } else {
2129     jpan = (Dali::PanGesture *) &pan;
2130     swig_callbackOnPan(jpan);
2131   }
2132 }
2133
2134 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2135   void * jtap = 0 ;
2136
2137   if (!swig_callbackOnTap) {
2138     Dali::Toolkit::Internal::Control::OnTap(tap);
2139     return;
2140   } else {
2141     jtap = (Dali::TapGesture *) &tap;
2142     swig_callbackOnTap(jtap);
2143   }
2144 }
2145
2146 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2147   void * jlongPress = 0 ;
2148
2149   if (!swig_callbackOnLongPress) {
2150     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2151     return;
2152   } else {
2153     jlongPress = (Dali::LongPressGesture *) &longPress;
2154     swig_callbackOnLongPress(jlongPress);
2155   }
2156 }
2157
2158 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2159   void * jslotObserver = 0 ;
2160   void * jcallback = 0 ;
2161
2162   if (!swig_callbackSignalConnected) {
2163     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2164     return;
2165   } else {
2166     jslotObserver = (void *) slotObserver;
2167     jcallback = (void *) callback;
2168     swig_callbackSignalConnected(jslotObserver, jcallback);
2169   }
2170 }
2171
2172 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2173   void * jslotObserver = 0 ;
2174   void * jcallback = 0 ;
2175
2176   if (!swig_callbackSignalDisconnected) {
2177     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2178     return;
2179   } else {
2180     jslotObserver = (void *) slotObserver;
2181     jcallback = (void *) callback;
2182     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2183   }
2184 }
2185
2186 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2187   return Dali::Toolkit::Internal::Control::GetControlExtension();
2188 }
2189
2190 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) {
2191   swig_callbackOnSceneConnection = callbackOnSceneConnection;
2192   swig_callbackOnSceneDisconnection = callbackOnSceneDisconnection;
2193   swig_callbackOnChildAdd = callbackOnChildAdd;
2194   swig_callbackOnChildRemove = callbackOnChildRemove;
2195   swig_callbackOnPropertySet = callbackOnPropertySet;
2196   swig_callbackOnSizeSet = callbackOnSizeSet;
2197   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2198   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2199   swig_callbackOnRelayout = callbackOnRelayout;
2200   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2201   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2202   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2203   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2204   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2205   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2206   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2207   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2208   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2209   swig_callbackOnInitialize = callbackOnInitialize;
2210   swig_callbackOnStyleChange = callbackOnStyleChange;
2211   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2212   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2213   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2214   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2215   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2216   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2217   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2218   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2219   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2220   swig_callbackOnPinch = callbackOnPinch;
2221   swig_callbackOnPan = callbackOnPan;
2222   swig_callbackOnTap = callbackOnTap;
2223   swig_callbackOnLongPress = callbackOnLongPress;
2224   swig_callbackSignalConnected = callbackSignalConnected;
2225   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2226 }
2227
2228 void SwigDirector_ViewImpl::swig_init_callbacks() {
2229   swig_callbackOnSceneConnection = 0;
2230   swig_callbackOnSceneDisconnection = 0;
2231   swig_callbackOnChildAdd = 0;
2232   swig_callbackOnChildRemove = 0;
2233   swig_callbackOnPropertySet = 0;
2234   swig_callbackOnSizeSet = 0;
2235   swig_callbackOnSizeAnimation = 0;
2236   swig_callbackOnKeyEvent = 0;
2237   swig_callbackOnRelayout = 0;
2238   swig_callbackOnSetResizePolicy = 0;
2239   swig_callbackGetNaturalSize = 0;
2240   swig_callbackCalculateChildSize = 0;
2241   swig_callbackGetHeightForWidth = 0;
2242   swig_callbackGetWidthForHeight = 0;
2243   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2244   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2245   swig_callbackOnCalculateRelayoutSize = 0;
2246   swig_callbackOnLayoutNegotiated = 0;
2247   swig_callbackOnInitialize = 0;
2248   swig_callbackOnStyleChange = 0;
2249   swig_callbackOnAccessibilityActivated = 0;
2250   swig_callbackOnAccessibilityPan = 0;
2251   swig_callbackOnAccessibilityValueChange = 0;
2252   swig_callbackOnAccessibilityZoom = 0;
2253   swig_callbackOnKeyInputFocusGained = 0;
2254   swig_callbackOnKeyInputFocusLost = 0;
2255   swig_callbackGetNextKeyboardFocusableActor = 0;
2256   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2257   swig_callbackOnKeyboardEnter = 0;
2258   swig_callbackOnPinch = 0;
2259   swig_callbackOnPan = 0;
2260   swig_callbackOnTap = 0;
2261   swig_callbackOnLongPress = 0;
2262   swig_callbackSignalConnected = 0;
2263   swig_callbackSignalDisconnected = 0;
2264 }
2265
2266 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2267   swig_init_callbacks();
2268 }
2269
2270 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2271
2272 }
2273
2274
2275 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2276   unsigned int c_result = SwigValueInit< unsigned int >() ;
2277   unsigned int jresult = 0 ;
2278
2279   if (!swig_callbackGetNumberOfItems) {
2280     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2281   } else {
2282     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2283     c_result = (unsigned int)jresult;
2284   }
2285   return c_result;
2286 }
2287
2288 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2289   Dali::Actor c_result ;
2290   void * jresult = 0 ;
2291   unsigned int jitemId  ;
2292
2293   if (!swig_callbackNewItem) {
2294     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2295   } else {
2296     jitemId = itemId;
2297     jresult = (void *) swig_callbackNewItem(jitemId);
2298     if (!jresult) {
2299       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2300       return c_result;
2301     }
2302     c_result = *(Dali::Actor *)jresult;
2303   }
2304   return c_result;
2305 }
2306
2307 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor)
2308 {
2309   if(!swig_callbackItemReleased)
2310   {
2311     Dali::Toolkit::ItemFactory::ItemReleased(itemId, actor);
2312     return;
2313   }
2314   else
2315   {
2316     swig_callbackItemReleased(itemId, (void*)(&actor));
2317   }
2318 }
2319
2320 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2321   return Dali::Toolkit::ItemFactory::GetExtension();
2322 }
2323
2324 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2325   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2326   swig_callbackNewItem = callbackNewItem;
2327   swig_callbackItemReleased = callbackItemReleased;
2328 }
2329
2330 void SwigDirector_ItemFactory::swig_init_callbacks() {
2331   swig_callbackGetNumberOfItems = 0;
2332   swig_callbackNewItem = 0;
2333   swig_callbackItemReleased = 0;
2334 }
2335
2336 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2337   swig_init_callbacks();
2338 }
2339
2340 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2341
2342 }
2343
2344
2345 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction, const std::string& deviceName)
2346 {
2347   Dali::Actor c_result;
2348   void* jresult = 0;
2349
2350   if(!swig_callbackGetNextFocusableActor)
2351   {
2352     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2353   }
2354   else
2355   {
2356     jresult = (void*)swig_callbackGetNextFocusableActor((void*)(&current), (void*)(&proposed), direction, deviceName.c_str());
2357     if(!jresult)
2358     {
2359       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__);
2360       return c_result;
2361     }
2362     c_result = *(Dali::Actor*)jresult;
2363   }
2364   return c_result;
2365 }
2366
2367 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2368   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2369 }
2370
2371 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2372   swig_callbackGetNextFocusableActor = 0;
2373 }
2374
2375 SwigDirector_FrameCallbackInterface::SwigDirector_FrameCallbackInterface() : Dali::FrameCallbackInterface(), Swig::Director() {
2376   swig_callbackOnUpdate = 0;
2377 }
2378
2379 SwigDirector_FrameCallbackInterface::~SwigDirector_FrameCallbackInterface() {
2380
2381 }
2382
2383 void SwigDirector_FrameCallbackInterface::swig_connect_director(SWIG_Callback0_t callbackUpdate) {
2384   swig_callbackOnUpdate = callbackUpdate;
2385 }
2386
2387
2388 void SwigDirector_FrameCallbackInterface::Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) {
2389   void * jcurrent  ;
2390
2391   if (!swig_callbackOnUpdate) {
2392     throw Swig::DirectorPureVirtualException("Dali::FrameCallbackInterface::Update");
2393   } else {
2394     Dali::UpdateProxy* proxy = &updateProxy;
2395     jcurrent = (void *)proxy;
2396     swig_callbackOnUpdate(jcurrent, elapsedSeconds);
2397     if (!jcurrent) {
2398       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::UpdateProxy! ", __FILE__, __LINE__);
2399       return;
2400     }
2401   }
2402   return;
2403 }
2404
2405
2406 #ifdef __cplusplus
2407 extern "C" {
2408 #endif
2409
2410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2411   void * jresult ;
2412   floatp *result = 0 ;
2413
2414   {
2415     try {
2416       result = (floatp *)new_floatp();
2417     } CALL_CATCH_EXCEPTION(0);
2418   }
2419   jresult = (void *)result;
2420   return jresult;
2421 }
2422
2423
2424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2425   floatp *arg1 = (floatp *) 0 ;
2426
2427   arg1 = (floatp *)jarg1;
2428   {
2429     try {
2430       delete_floatp(arg1);
2431     } CALL_CATCH_EXCEPTION();
2432   }
2433
2434 }
2435
2436
2437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2438   floatp *arg1 = (floatp *) 0 ;
2439   float arg2 ;
2440
2441   arg1 = (floatp *)jarg1;
2442   arg2 = (float)jarg2;
2443   {
2444     try {
2445       floatp_assign(arg1,arg2);
2446     } CALL_CATCH_EXCEPTION();
2447   }
2448
2449 }
2450
2451
2452 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2453   float jresult ;
2454   floatp *arg1 = (floatp *) 0 ;
2455   float result;
2456
2457   arg1 = (floatp *)jarg1;
2458   {
2459     try {
2460       result = (float)floatp_value(arg1);
2461     } CALL_CATCH_EXCEPTION(0);
2462   }
2463   jresult = result;
2464   return jresult;
2465 }
2466
2467
2468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2469   void * jresult ;
2470   floatp *arg1 = (floatp *) 0 ;
2471   float *result = 0 ;
2472
2473   arg1 = (floatp *)jarg1;
2474   {
2475     try {
2476       result = (float *)floatp_cast(arg1);
2477     } CALL_CATCH_EXCEPTION(0);
2478   }
2479
2480   jresult = (void *)result;
2481   return jresult;
2482 }
2483
2484
2485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2486   void * jresult ;
2487   float *arg1 = (float *) 0 ;
2488   floatp *result = 0 ;
2489
2490   arg1 = (float *)jarg1;
2491   {
2492     try {
2493       result = (floatp *)floatp_frompointer(arg1);
2494     } CALL_CATCH_EXCEPTION(0);
2495   }
2496
2497   jresult = (void *)result;
2498   return jresult;
2499 }
2500
2501
2502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2503   void * jresult ;
2504   intp *result = 0 ;
2505
2506   {
2507     try {
2508       result = (intp *)new_intp();
2509     } CALL_CATCH_EXCEPTION(0);
2510   }
2511
2512   jresult = (void *)result;
2513   return jresult;
2514 }
2515
2516
2517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2518   intp *arg1 = (intp *) 0 ;
2519
2520   arg1 = (intp *)jarg1;
2521   {
2522     try {
2523       delete_intp(arg1);
2524     } CALL_CATCH_EXCEPTION();
2525   }
2526
2527 }
2528
2529
2530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2531   intp *arg1 = (intp *) 0 ;
2532   int arg2 ;
2533
2534   arg1 = (intp *)jarg1;
2535   arg2 = (int)jarg2;
2536   {
2537     try {
2538       intp_assign(arg1,arg2);
2539     } CALL_CATCH_EXCEPTION();
2540   }
2541
2542 }
2543
2544
2545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2546   int jresult ;
2547   intp *arg1 = (intp *) 0 ;
2548   int result;
2549
2550   arg1 = (intp *)jarg1;
2551   {
2552     try {
2553       result = (int)intp_value(arg1);
2554     } CALL_CATCH_EXCEPTION(0);
2555   }
2556
2557   jresult = result;
2558   return jresult;
2559 }
2560
2561
2562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2563   void * jresult ;
2564   intp *arg1 = (intp *) 0 ;
2565   int *result = 0 ;
2566
2567   arg1 = (intp *)jarg1;
2568   {
2569     try {
2570       result = (int *)intp_cast(arg1);
2571     } CALL_CATCH_EXCEPTION(0);
2572   }
2573
2574   jresult = (void *)result;
2575   return jresult;
2576 }
2577
2578
2579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2580   void * jresult ;
2581   int *arg1 = (int *) 0 ;
2582   intp *result = 0 ;
2583
2584   arg1 = (int *)jarg1;
2585   {
2586     try {
2587       result = (intp *)intp_frompointer(arg1);
2588     } CALL_CATCH_EXCEPTION(0);
2589   }
2590
2591   jresult = (void *)result;
2592   return jresult;
2593 }
2594
2595
2596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2597   void * jresult ;
2598   doublep *result = 0 ;
2599
2600   {
2601     try {
2602       result = (doublep *)new_doublep();
2603     } CALL_CATCH_EXCEPTION(0);
2604   }
2605
2606   jresult = (void *)result;
2607   return jresult;
2608 }
2609
2610
2611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2612   doublep *arg1 = (doublep *) 0 ;
2613
2614   arg1 = (doublep *)jarg1;
2615   {
2616     try {
2617       delete_doublep(arg1);
2618     } CALL_CATCH_EXCEPTION();
2619   }
2620
2621 }
2622
2623
2624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2625   doublep *arg1 = (doublep *) 0 ;
2626   double arg2 ;
2627
2628   arg1 = (doublep *)jarg1;
2629   arg2 = (double)jarg2;
2630   {
2631     try {
2632       doublep_assign(arg1,arg2);
2633     } CALL_CATCH_EXCEPTION();
2634   }
2635
2636 }
2637
2638
2639 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2640   double jresult ;
2641   doublep *arg1 = (doublep *) 0 ;
2642   double result;
2643
2644   arg1 = (doublep *)jarg1;
2645   {
2646     try {
2647       result = (double)doublep_value(arg1);
2648     } CALL_CATCH_EXCEPTION(0);
2649   }
2650
2651   jresult = result;
2652   return jresult;
2653 }
2654
2655
2656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2657   void * jresult ;
2658   doublep *arg1 = (doublep *) 0 ;
2659   double *result = 0 ;
2660
2661   arg1 = (doublep *)jarg1;
2662   {
2663     try {
2664       result = (double *)doublep_cast(arg1);
2665     } CALL_CATCH_EXCEPTION(0);
2666   }
2667
2668   jresult = (void *)result;
2669   return jresult;
2670 }
2671
2672
2673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2674   void * jresult ;
2675   double *arg1 = (double *) 0 ;
2676   doublep *result = 0 ;
2677
2678   arg1 = (double *)jarg1;
2679   {
2680     try {
2681       result = (doublep *)doublep_frompointer(arg1);
2682     } CALL_CATCH_EXCEPTION(0);
2683   }
2684
2685   jresult = (void *)result;
2686   return jresult;
2687 }
2688
2689
2690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2691   void * jresult ;
2692   uintp *result = 0 ;
2693
2694   {
2695     try {
2696       result = (uintp *)new_uintp();
2697     } CALL_CATCH_EXCEPTION(0);
2698   }
2699
2700   jresult = (void *)result;
2701   return jresult;
2702 }
2703
2704
2705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2706   uintp *arg1 = (uintp *) 0 ;
2707
2708   arg1 = (uintp *)jarg1;
2709   {
2710     try {
2711       delete_uintp(arg1);
2712     } CALL_CATCH_EXCEPTION();
2713   }
2714
2715 }
2716
2717
2718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2719   uintp *arg1 = (uintp *) 0 ;
2720   unsigned int arg2 ;
2721
2722   arg1 = (uintp *)jarg1;
2723   arg2 = (unsigned int)jarg2;
2724   {
2725     try {
2726       uintp_assign(arg1,arg2);
2727     } CALL_CATCH_EXCEPTION();
2728   }
2729
2730 }
2731
2732
2733 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
2734   unsigned int jresult ;
2735   uintp *arg1 = (uintp *) 0 ;
2736   unsigned int result;
2737
2738   arg1 = (uintp *)jarg1;
2739   {
2740     try {
2741       result = (unsigned int)uintp_value(arg1);
2742     } CALL_CATCH_EXCEPTION(0);
2743   }
2744
2745   jresult = result;
2746   return jresult;
2747 }
2748
2749
2750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
2751   void * jresult ;
2752   uintp *arg1 = (uintp *) 0 ;
2753   unsigned int *result = 0 ;
2754
2755   arg1 = (uintp *)jarg1;
2756   {
2757     try {
2758       result = (unsigned int *)uintp_cast(arg1);
2759     } CALL_CATCH_EXCEPTION(0);
2760   }
2761
2762   jresult = (void *)result;
2763   return jresult;
2764 }
2765
2766
2767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
2768   void * jresult ;
2769   unsigned int *arg1 = (unsigned int *) 0 ;
2770   uintp *result = 0 ;
2771
2772   arg1 = (unsigned int *)jarg1;
2773   {
2774     try {
2775       result = (uintp *)uintp_frompointer(arg1);
2776     } CALL_CATCH_EXCEPTION(0);
2777   }
2778
2779   jresult = (void *)result;
2780   return jresult;
2781 }
2782
2783
2784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
2785   void * jresult ;
2786   ushortp *result = 0 ;
2787
2788   {
2789     try {
2790       result = (ushortp *)new_ushortp();
2791     } CALL_CATCH_EXCEPTION(0);
2792   }
2793
2794   jresult = (void *)result;
2795   return jresult;
2796 }
2797
2798
2799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
2800   ushortp *arg1 = (ushortp *) 0 ;
2801
2802   arg1 = (ushortp *)jarg1;
2803   {
2804     try {
2805       delete_ushortp(arg1);
2806     } CALL_CATCH_EXCEPTION();
2807   }
2808
2809 }
2810
2811
2812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
2813   ushortp *arg1 = (ushortp *) 0 ;
2814   unsigned short arg2 ;
2815
2816   arg1 = (ushortp *)jarg1;
2817   arg2 = (unsigned short)jarg2;
2818   {
2819     try {
2820       ushortp_assign(arg1,arg2);
2821     } CALL_CATCH_EXCEPTION();
2822   }
2823
2824 }
2825
2826
2827 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
2828   unsigned short jresult ;
2829   ushortp *arg1 = (ushortp *) 0 ;
2830   unsigned short result;
2831
2832   arg1 = (ushortp *)jarg1;
2833   {
2834     try {
2835       result = (unsigned short)ushortp_value(arg1);
2836     } CALL_CATCH_EXCEPTION(0);
2837   }
2838
2839   jresult = result;
2840   return jresult;
2841 }
2842
2843
2844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
2845   void * jresult ;
2846   ushortp *arg1 = (ushortp *) 0 ;
2847   unsigned short *result = 0 ;
2848
2849   arg1 = (ushortp *)jarg1;
2850   {
2851     try {
2852       result = (unsigned short *)ushortp_cast(arg1);
2853     } CALL_CATCH_EXCEPTION(0);
2854   }
2855
2856   jresult = (void *)result;
2857   return jresult;
2858 }
2859
2860
2861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
2862   void * jresult ;
2863   unsigned short *arg1 = (unsigned short *) 0 ;
2864   ushortp *result = 0 ;
2865
2866   arg1 = (unsigned short *)jarg1;
2867   {
2868     try {
2869       result = (ushortp *)ushortp_frompointer(arg1);
2870     } CALL_CATCH_EXCEPTION(0);
2871   }
2872
2873   jresult = (void *)result;
2874   return jresult;
2875 }
2876
2877
2878 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
2879   unsigned int jresult ;
2880   int arg1 ;
2881   unsigned int result;
2882
2883   arg1 = (int)jarg1;
2884   {
2885     try {
2886       result = (unsigned int)int_to_uint(arg1);
2887     } CALL_CATCH_EXCEPTION(0);
2888   }
2889
2890   jresult = result;
2891   return jresult;
2892 }
2893
2894
2895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
2896   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
2897
2898   arg1 = (Dali::RefObject *)jarg1;
2899   {
2900     try {
2901       (arg1)->Reference();
2902     } CALL_CATCH_EXCEPTION();
2903   }
2904
2905 }
2906
2907
2908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
2909   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
2910
2911   arg1 = (Dali::RefObject *)jarg1;
2912   {
2913     try {
2914       (arg1)->Unreference();
2915     } CALL_CATCH_EXCEPTION();
2916   }
2917
2918 }
2919
2920
2921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
2922   int jresult ;
2923   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
2924   int result;
2925
2926   arg1 = (Dali::RefObject *)jarg1;
2927   {
2928     try {
2929       result = (int)(arg1)->ReferenceCount();
2930     } CALL_CATCH_EXCEPTION(0);
2931   }
2932
2933   jresult = result;
2934   return jresult;
2935 }
2936
2937
2938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
2939   void * jresult ;
2940   Dali::Any *result = 0 ;
2941
2942   {
2943     try {
2944       result = (Dali::Any *)new Dali::Any();
2945     } CALL_CATCH_EXCEPTION(0);
2946   }
2947
2948   jresult = (void *)result;
2949   return jresult;
2950 }
2951
2952
2953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
2954   Dali::Any *arg1 = (Dali::Any *) 0 ;
2955
2956   arg1 = (Dali::Any *)jarg1;
2957   {
2958     try {
2959       delete arg1;
2960     } CALL_CATCH_EXCEPTION();
2961   }
2962
2963 }
2964
2965
2966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
2967   char *arg1 = (char *) 0 ;
2968
2969   arg1 = (char *)jarg1;
2970   {
2971     try {
2972       Dali::Any::AssertAlways((char const *)arg1);
2973     } CALL_CATCH_EXCEPTION();
2974   }
2975
2976 }
2977
2978
2979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
2980   void * jresult ;
2981   Dali::Any *arg1 = 0 ;
2982   Dali::Any *result = 0 ;
2983
2984   arg1 = (Dali::Any *)jarg1;
2985   if (!arg1) {
2986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
2987     return 0;
2988   }
2989   {
2990     try {
2991       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
2992     } CALL_CATCH_EXCEPTION(0);
2993   }
2994
2995   jresult = (void *)result;
2996   return jresult;
2997 }
2998
2999
3000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3001   void * jresult ;
3002   Dali::Any *arg1 = (Dali::Any *) 0 ;
3003   Dali::Any *arg2 = 0 ;
3004   Dali::Any *result = 0 ;
3005
3006   arg1 = (Dali::Any *)jarg1;
3007   arg2 = (Dali::Any *)jarg2;
3008   if (!arg2) {
3009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3010     return 0;
3011   }
3012   {
3013     try {
3014       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3015     } CALL_CATCH_EXCEPTION(0);
3016   }
3017
3018   jresult = (void *)result;
3019   return jresult;
3020 }
3021
3022
3023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3024   void * jresult ;
3025   Dali::Any *arg1 = (Dali::Any *) 0 ;
3026   std::type_info *result = 0 ;
3027
3028   arg1 = (Dali::Any *)jarg1;
3029   {
3030     try {
3031       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3032     } CALL_CATCH_EXCEPTION(0);
3033   }
3034
3035   jresult = (void *)result;
3036   return jresult;
3037 }
3038
3039
3040 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3041   bool jresult ;
3042   Dali::Any *arg1 = (Dali::Any *) 0 ;
3043   bool result;
3044
3045   arg1 = (Dali::Any *)jarg1;
3046   {
3047     try {
3048       result = (bool)((Dali::Any const *)arg1)->Empty();
3049     } CALL_CATCH_EXCEPTION(0);
3050   }
3051
3052   jresult = result;
3053   return jresult;
3054 }
3055
3056
3057
3058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3059   char *arg1 = (char *) 0 ;
3060   char *arg2 = (char *) 0 ;
3061
3062   arg1 = (char *)jarg1;
3063   arg2 = (char *)jarg2;
3064   {
3065     try {
3066       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3067     } CALL_CATCH_EXCEPTION();
3068   }
3069
3070 }
3071
3072
3073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3074   void * jresult ;
3075   char *arg1 = (char *) 0 ;
3076   char *arg2 = (char *) 0 ;
3077   Dali::DaliException *result = 0 ;
3078
3079   arg1 = (char *)jarg1;
3080   arg2 = (char *)jarg2;
3081   {
3082     try {
3083       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3084     } CALL_CATCH_EXCEPTION(0);
3085   }
3086
3087   jresult = (void *)result;
3088   return jresult;
3089 }
3090
3091
3092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3093   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3094   std::string arg2 = std::string(jarg2);
3095
3096   arg1 = (Dali::DaliException *)jarg1;
3097   {
3098     if (!arg2.empty()) {
3099       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
3100     } else {
3101       arg1->location = 0;
3102     }
3103   }
3104 }
3105
3106 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3107   char * jresult ;
3108   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3109   char *result = 0 ;
3110
3111   arg1 = (Dali::DaliException *)jarg1;
3112   result = (char *) ((arg1)->location);
3113   jresult = SWIG_csharp_string_callback((const char *)result);
3114   return jresult;
3115 }
3116
3117
3118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3119   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3120   std::string arg2 = std::string(jarg2);
3121
3122   arg1 = (Dali::DaliException *)jarg1;
3123   {
3124     if (!arg2.empty()) {
3125       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
3126     } else {
3127       arg1->condition = 0;
3128     }
3129   }
3130 }
3131
3132
3133 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3134   char * jresult ;
3135   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3136   char *result = 0 ;
3137
3138   arg1 = (Dali::DaliException *)jarg1;
3139   result = (char *) ((arg1)->condition);
3140   jresult = SWIG_csharp_string_callback((const char *)result);
3141   return jresult;
3142 }
3143
3144
3145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3146   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3147
3148   arg1 = (Dali::DaliException *)jarg1;
3149   {
3150     try {
3151       delete arg1;
3152     } CALL_CATCH_EXCEPTION();
3153   }
3154
3155 }
3156
3157
3158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3159   void * jresult ;
3160   Dali::Vector2 *result = 0 ;
3161
3162   {
3163     try {
3164       result = (Dali::Vector2 *)new Dali::Vector2();
3165     } CALL_CATCH_EXCEPTION(0);
3166   }
3167
3168   jresult = (void *)result;
3169   return jresult;
3170 }
3171
3172
3173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3174   void * jresult ;
3175   float arg1 ;
3176   float arg2 ;
3177   Dali::Vector2 *result = 0 ;
3178
3179   arg1 = (float)jarg1;
3180   arg2 = (float)jarg2;
3181   {
3182     try {
3183       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3184     } CALL_CATCH_EXCEPTION(0);
3185   }
3186
3187   jresult = (void *)result;
3188   return jresult;
3189 }
3190
3191
3192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3193   void * jresult ;
3194   float *arg1 = (float *) 0 ;
3195   Dali::Vector2 *result = 0 ;
3196
3197   arg1 = jarg1;
3198   {
3199     try {
3200       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3201     } CALL_CATCH_EXCEPTION(0);
3202   }
3203
3204   jresult = (void *)result;
3205
3206
3207   return jresult;
3208 }
3209
3210
3211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3212   void * jresult ;
3213   Dali::Vector3 *arg1 = 0 ;
3214   Dali::Vector2 *result = 0 ;
3215
3216   arg1 = (Dali::Vector3 *)jarg1;
3217   if (!arg1) {
3218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3219     return 0;
3220   }
3221   {
3222     try {
3223       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3224     } CALL_CATCH_EXCEPTION(0);
3225   }
3226
3227   jresult = (void *)result;
3228   return jresult;
3229 }
3230
3231
3232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
3233   void * jresult ;
3234   Dali::Vector4 *arg1 = 0 ;
3235   Dali::Vector2 *result = 0 ;
3236
3237   arg1 = (Dali::Vector4 *)jarg1;
3238   if (!arg1) {
3239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3240     return 0;
3241   }
3242   {
3243     try {
3244       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3245     } CALL_CATCH_EXCEPTION(0);
3246   }
3247
3248   jresult = (void *)result;
3249   return jresult;
3250 }
3251
3252
3253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
3254   void * jresult ;
3255   Dali::Vector2 *result = 0 ;
3256
3257   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
3258   jresult = (void *)result;
3259   return jresult;
3260 }
3261
3262
3263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
3264   void * jresult ;
3265   Dali::Vector2 *result = 0 ;
3266
3267   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
3268   jresult = (void *)result;
3269   return jresult;
3270 }
3271
3272
3273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
3274   void * jresult ;
3275   Dali::Vector2 *result = 0 ;
3276
3277   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
3278   jresult = (void *)result;
3279   return jresult;
3280 }
3281
3282
3283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
3284   void * jresult ;
3285   Dali::Vector2 *result = 0 ;
3286
3287   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
3288   jresult = (void *)result;
3289   return jresult;
3290 }
3291
3292
3293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
3294   void * jresult ;
3295   Dali::Vector2 *result = 0 ;
3296
3297   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
3298   jresult = (void *)result;
3299   return jresult;
3300 }
3301
3302
3303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
3304   void * jresult ;
3305   Dali::Vector2 *result = 0 ;
3306
3307   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
3308   jresult = (void *)result;
3309   return jresult;
3310 }
3311
3312
3313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
3314   void * jresult ;
3315   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3316   float *arg2 = (float *) 0 ;
3317   Dali::Vector2 *result = 0 ;
3318
3319   arg1 = (Dali::Vector2 *)jarg1;
3320   arg2 = jarg2;
3321   {
3322     try {
3323       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
3324     } CALL_CATCH_EXCEPTION(0);
3325   }
3326
3327   jresult = (void *)result;
3328
3329
3330   return jresult;
3331 }
3332
3333
3334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
3335   void * jresult ;
3336   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3337   Dali::Vector3 *arg2 = 0 ;
3338   Dali::Vector2 *result = 0 ;
3339
3340   arg1 = (Dali::Vector2 *)jarg1;
3341   arg2 = (Dali::Vector3 *)jarg2;
3342   if (!arg2) {
3343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3344     return 0;
3345   }
3346   {
3347     try {
3348       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
3349     } CALL_CATCH_EXCEPTION(0);
3350   }
3351
3352   jresult = (void *)result;
3353   return jresult;
3354 }
3355
3356
3357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
3358   void * jresult ;
3359   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3360   Dali::Vector4 *arg2 = 0 ;
3361   Dali::Vector2 *result = 0 ;
3362
3363   arg1 = (Dali::Vector2 *)jarg1;
3364   arg2 = (Dali::Vector4 *)jarg2;
3365   if (!arg2) {
3366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3367     return 0;
3368   }
3369   {
3370     try {
3371       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
3372     } CALL_CATCH_EXCEPTION(0);
3373   }
3374
3375   jresult = (void *)result;
3376   return jresult;
3377 }
3378
3379
3380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
3381   void * jresult ;
3382   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3383   Dali::Vector2 *arg2 = 0 ;
3384   Dali::Vector2 result;
3385
3386   arg1 = (Dali::Vector2 *)jarg1;
3387   arg2 = (Dali::Vector2 *)jarg2;
3388   if (!arg2) {
3389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3390     return 0;
3391   }
3392   {
3393     try {
3394       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
3395     } CALL_CATCH_EXCEPTION(0);
3396   }
3397
3398   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3399   return jresult;
3400 }
3401
3402
3403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
3404   void * jresult ;
3405   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3406   Dali::Vector2 *arg2 = 0 ;
3407   Dali::Vector2 *result = 0 ;
3408
3409   arg1 = (Dali::Vector2 *)jarg1;
3410   arg2 = (Dali::Vector2 *)jarg2;
3411   if (!arg2) {
3412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3413     return 0;
3414   }
3415   {
3416     try {
3417       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
3418     } CALL_CATCH_EXCEPTION(0);
3419   }
3420
3421   jresult = (void *)result;
3422   return jresult;
3423 }
3424
3425
3426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
3427   void * jresult ;
3428   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3429   Dali::Vector2 *arg2 = 0 ;
3430   Dali::Vector2 result;
3431
3432   arg1 = (Dali::Vector2 *)jarg1;
3433   arg2 = (Dali::Vector2 *)jarg2;
3434   if (!arg2) {
3435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3436     return 0;
3437   }
3438   {
3439     try {
3440       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
3441     } CALL_CATCH_EXCEPTION(0);
3442   }
3443
3444   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3445   return jresult;
3446 }
3447
3448
3449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
3450   void * jresult ;
3451   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3452   Dali::Vector2 *arg2 = 0 ;
3453   Dali::Vector2 *result = 0 ;
3454
3455   arg1 = (Dali::Vector2 *)jarg1;
3456   arg2 = (Dali::Vector2 *)jarg2;
3457   if (!arg2) {
3458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3459     return 0;
3460   }
3461   {
3462     try {
3463       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
3464     } CALL_CATCH_EXCEPTION(0);
3465   }
3466
3467   jresult = (void *)result;
3468   return jresult;
3469 }
3470
3471
3472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
3473   void * jresult ;
3474   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3475   Dali::Vector2 *arg2 = 0 ;
3476   Dali::Vector2 result;
3477
3478   arg1 = (Dali::Vector2 *)jarg1;
3479   arg2 = (Dali::Vector2 *)jarg2;
3480   if (!arg2) {
3481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3482     return 0;
3483   }
3484   {
3485     try {
3486       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
3487     } CALL_CATCH_EXCEPTION(0);
3488   }
3489
3490   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3491   return jresult;
3492 }
3493
3494
3495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
3496   void * jresult ;
3497   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3498   float arg2 ;
3499   Dali::Vector2 result;
3500
3501   arg1 = (Dali::Vector2 *)jarg1;
3502   arg2 = (float)jarg2;
3503   {
3504     try {
3505       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
3506     } CALL_CATCH_EXCEPTION(0);
3507   }
3508
3509   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3510   return jresult;
3511 }
3512
3513
3514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
3515   void * jresult ;
3516   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3517   Dali::Vector2 *arg2 = 0 ;
3518   Dali::Vector2 *result = 0 ;
3519
3520   arg1 = (Dali::Vector2 *)jarg1;
3521   arg2 = (Dali::Vector2 *)jarg2;
3522   if (!arg2) {
3523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3524     return 0;
3525   }
3526   {
3527     try {
3528       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
3529     } CALL_CATCH_EXCEPTION(0);
3530   }
3531
3532   jresult = (void *)result;
3533   return jresult;
3534 }
3535
3536
3537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
3538   void * jresult ;
3539   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3540   float arg2 ;
3541   Dali::Vector2 *result = 0 ;
3542
3543   arg1 = (Dali::Vector2 *)jarg1;
3544   arg2 = (float)jarg2;
3545   {
3546     try {
3547       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
3548     } CALL_CATCH_EXCEPTION(0);
3549   }
3550
3551   jresult = (void *)result;
3552   return jresult;
3553 }
3554
3555
3556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
3557   void * jresult ;
3558   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3559   Dali::Vector2 *arg2 = 0 ;
3560   Dali::Vector2 result;
3561
3562   arg1 = (Dali::Vector2 *)jarg1;
3563   arg2 = (Dali::Vector2 *)jarg2;
3564   if (!arg2) {
3565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3566     return 0;
3567   }
3568   {
3569     try {
3570       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
3571     } CALL_CATCH_EXCEPTION(0);
3572   }
3573
3574   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3575   return jresult;
3576 }
3577
3578
3579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
3580   void * jresult ;
3581   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3582   float arg2 ;
3583   Dali::Vector2 result;
3584
3585   arg1 = (Dali::Vector2 *)jarg1;
3586   arg2 = (float)jarg2;
3587   {
3588     try {
3589       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
3590     } CALL_CATCH_EXCEPTION(0);
3591   }
3592
3593   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3594   return jresult;
3595 }
3596
3597
3598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
3599   void * jresult ;
3600   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3601   Dali::Vector2 *arg2 = 0 ;
3602   Dali::Vector2 *result = 0 ;
3603
3604   arg1 = (Dali::Vector2 *)jarg1;
3605   arg2 = (Dali::Vector2 *)jarg2;
3606   if (!arg2) {
3607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3608     return 0;
3609   }
3610   {
3611     try {
3612       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
3613     } CALL_CATCH_EXCEPTION(0);
3614   }
3615
3616   jresult = (void *)result;
3617   return jresult;
3618 }
3619
3620
3621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
3622   void * jresult ;
3623   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3624   float arg2 ;
3625   Dali::Vector2 *result = 0 ;
3626
3627   arg1 = (Dali::Vector2 *)jarg1;
3628   arg2 = (float)jarg2;
3629   {
3630     try {
3631       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
3632     } CALL_CATCH_EXCEPTION(0);
3633   }
3634
3635   jresult = (void *)result;
3636   return jresult;
3637 }
3638
3639
3640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
3641   void * jresult ;
3642   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3643   Dali::Vector2 result;
3644
3645   arg1 = (Dali::Vector2 *)jarg1;
3646   {
3647     try {
3648       result = ((Dali::Vector2 const *)arg1)->operator -();
3649     } CALL_CATCH_EXCEPTION(0);
3650   }
3651
3652   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3653   return jresult;
3654 }
3655
3656
3657 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
3658   bool jresult ;
3659   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3660   Dali::Vector2 *arg2 = 0 ;
3661   bool result;
3662
3663   arg1 = (Dali::Vector2 *)jarg1;
3664   arg2 = (Dali::Vector2 *)jarg2;
3665   if (!arg2) {
3666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3667     return 0;
3668   }
3669   {
3670     try {
3671       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
3672     } CALL_CATCH_EXCEPTION(0);
3673   }
3674
3675   jresult = result;
3676   return jresult;
3677 }
3678
3679
3680 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
3681   bool jresult ;
3682   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3683   Dali::Vector2 *arg2 = 0 ;
3684   bool result;
3685
3686   arg1 = (Dali::Vector2 *)jarg1;
3687   arg2 = (Dali::Vector2 *)jarg2;
3688   if (!arg2) {
3689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3690     return 0;
3691   }
3692   {
3693     try {
3694       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
3695     } CALL_CATCH_EXCEPTION(0);
3696   }
3697
3698   jresult = result;
3699   return jresult;
3700 }
3701
3702
3703 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
3704   float jresult ;
3705   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3706   unsigned int arg2 ;
3707   float *result = 0 ;
3708
3709   arg1 = (Dali::Vector2 *)jarg1;
3710   arg2 = (unsigned int)jarg2;
3711   {
3712     try {
3713       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
3714     } CALL_CATCH_EXCEPTION(0);
3715   }
3716
3717   jresult = *result;
3718   return jresult;
3719 }
3720
3721
3722 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
3723   float jresult ;
3724   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3725   float result;
3726
3727   arg1 = (Dali::Vector2 *)jarg1;
3728   {
3729     try {
3730       result = (float)((Dali::Vector2 const *)arg1)->Length();
3731     } CALL_CATCH_EXCEPTION(0);
3732   }
3733
3734   jresult = result;
3735   return jresult;
3736 }
3737
3738
3739 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
3740   float jresult ;
3741   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3742   float result;
3743
3744   arg1 = (Dali::Vector2 *)jarg1;
3745   {
3746     try {
3747       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
3748     } CALL_CATCH_EXCEPTION(0);
3749   }
3750
3751   jresult = result;
3752   return jresult;
3753 }
3754
3755
3756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
3757   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3758
3759   arg1 = (Dali::Vector2 *)jarg1;
3760   {
3761     try {
3762       (arg1)->Normalize();
3763     } CALL_CATCH_EXCEPTION();
3764   }
3765
3766 }
3767
3768
3769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
3770   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3771   Dali::Vector2 *arg2 = 0 ;
3772   Dali::Vector2 *arg3 = 0 ;
3773
3774   arg1 = (Dali::Vector2 *)jarg1;
3775   arg2 = (Dali::Vector2 *)jarg2;
3776   if (!arg2) {
3777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3778     return ;
3779   }
3780   arg3 = (Dali::Vector2 *)jarg3;
3781   if (!arg3) {
3782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3783     return ;
3784   }
3785   {
3786     try {
3787       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
3788     } CALL_CATCH_EXCEPTION();
3789   }
3790
3791 }
3792
3793
3794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
3795   void * jresult ;
3796   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3797   float *result = 0 ;
3798
3799   arg1 = (Dali::Vector2 *)jarg1;
3800   {
3801     try {
3802       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
3803     } CALL_CATCH_EXCEPTION(0);
3804   }
3805
3806   jresult = (void *)result;
3807   return jresult;
3808 }
3809
3810
3811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
3812   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3813   float arg2 ;
3814
3815   arg1 = (Dali::Vector2 *)jarg1;
3816   arg2 = (float)jarg2;
3817   if (arg1) (arg1)->x = arg2;
3818 }
3819
3820
3821 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
3822   float jresult ;
3823   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3824   float result;
3825
3826   arg1 = (Dali::Vector2 *)jarg1;
3827   result = (float) ((arg1)->x);
3828   jresult = result;
3829   return jresult;
3830 }
3831
3832
3833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
3834   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3835   float arg2 ;
3836
3837   arg1 = (Dali::Vector2 *)jarg1;
3838   arg2 = (float)jarg2;
3839   if (arg1) (arg1)->width = arg2;
3840 }
3841
3842
3843 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
3844   float jresult ;
3845   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3846   float result;
3847
3848   arg1 = (Dali::Vector2 *)jarg1;
3849   result = (float) ((arg1)->width);
3850   jresult = result;
3851   return jresult;
3852 }
3853
3854
3855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
3856   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3857   float arg2 ;
3858
3859   arg1 = (Dali::Vector2 *)jarg1;
3860   arg2 = (float)jarg2;
3861   if (arg1) (arg1)->y = arg2;
3862 }
3863
3864
3865 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
3866   float jresult ;
3867   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3868   float result;
3869
3870   arg1 = (Dali::Vector2 *)jarg1;
3871   result = (float) ((arg1)->y);
3872   jresult = result;
3873   return jresult;
3874 }
3875
3876
3877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
3878   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3879   float arg2 ;
3880
3881   arg1 = (Dali::Vector2 *)jarg1;
3882   arg2 = (float)jarg2;
3883   if (arg1) (arg1)->height = arg2;
3884 }
3885
3886
3887 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
3888   float jresult ;
3889   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3890   float result;
3891
3892   arg1 = (Dali::Vector2 *)jarg1;
3893   result = (float) ((arg1)->height);
3894   jresult = result;
3895   return jresult;
3896 }
3897
3898
3899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
3900   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3901
3902   arg1 = (Dali::Vector2 *)jarg1;
3903   {
3904     try {
3905       delete arg1;
3906     } CALL_CATCH_EXCEPTION();
3907   }
3908
3909 }
3910
3911
3912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
3913   void * jresult ;
3914   Dali::Vector2 *arg1 = 0 ;
3915   Dali::Vector2 *arg2 = 0 ;
3916   Dali::Vector2 result;
3917
3918   arg1 = (Dali::Vector2 *)jarg1;
3919   if (!arg1) {
3920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3921     return 0;
3922   }
3923   arg2 = (Dali::Vector2 *)jarg2;
3924   if (!arg2) {
3925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3926     return 0;
3927   }
3928   {
3929     try {
3930       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
3931     } CALL_CATCH_EXCEPTION(0);
3932   }
3933
3934   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3935   return jresult;
3936 }
3937
3938
3939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
3940   void * jresult ;
3941   Dali::Vector2 *arg1 = 0 ;
3942   Dali::Vector2 *arg2 = 0 ;
3943   Dali::Vector2 result;
3944
3945   arg1 = (Dali::Vector2 *)jarg1;
3946   if (!arg1) {
3947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3948     return 0;
3949   }
3950   arg2 = (Dali::Vector2 *)jarg2;
3951   if (!arg2) {
3952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3953     return 0;
3954   }
3955   {
3956     try {
3957       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
3958     } CALL_CATCH_EXCEPTION(0);
3959   }
3960
3961   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3962   return jresult;
3963 }
3964
3965
3966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
3967   void * jresult ;
3968   Dali::Vector2 *arg1 = 0 ;
3969   float *arg2 = 0 ;
3970   float *arg3 = 0 ;
3971   float temp2 ;
3972   float temp3 ;
3973   Dali::Vector2 result;
3974
3975   arg1 = (Dali::Vector2 *)jarg1;
3976   if (!arg1) {
3977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3978     return 0;
3979   }
3980   temp2 = (float)jarg2;
3981   arg2 = &temp2;
3982   temp3 = (float)jarg3;
3983   arg3 = &temp3;
3984   {
3985     try {
3986       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
3987     } CALL_CATCH_EXCEPTION(0);
3988   }
3989
3990   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3991   return jresult;
3992 }
3993
3994
3995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
3996   void * jresult ;
3997   Dali::Vector3 *result = 0 ;
3998
3999   {
4000     try {
4001       result = (Dali::Vector3 *)new Dali::Vector3();
4002     } CALL_CATCH_EXCEPTION(0);
4003   }
4004
4005   jresult = (void *)result;
4006   return jresult;
4007 }
4008
4009
4010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
4011   void * jresult ;
4012   float arg1 ;
4013   float arg2 ;
4014   float arg3 ;
4015   Dali::Vector3 *result = 0 ;
4016
4017   arg1 = (float)jarg1;
4018   arg2 = (float)jarg2;
4019   arg3 = (float)jarg3;
4020   {
4021     try {
4022       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
4023     } CALL_CATCH_EXCEPTION(0);
4024   }
4025
4026   jresult = (void *)result;
4027   return jresult;
4028 }
4029
4030
4031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
4032   void * jresult ;
4033   float *arg1 = (float *) 0 ;
4034   Dali::Vector3 *result = 0 ;
4035
4036   arg1 = jarg1;
4037   {
4038     try {
4039       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
4040     } CALL_CATCH_EXCEPTION(0);
4041   }
4042
4043   jresult = (void *)result;
4044
4045
4046   return jresult;
4047 }
4048
4049
4050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
4051   void * jresult ;
4052   Dali::Vector2 *arg1 = 0 ;
4053   Dali::Vector3 *result = 0 ;
4054
4055   arg1 = (Dali::Vector2 *)jarg1;
4056   if (!arg1) {
4057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4058     return 0;
4059   }
4060   {
4061     try {
4062       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
4063     } CALL_CATCH_EXCEPTION(0);
4064   }
4065
4066   jresult = (void *)result;
4067   return jresult;
4068 }
4069
4070
4071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
4072   void * jresult ;
4073   Dali::Vector4 *arg1 = 0 ;
4074   Dali::Vector3 *result = 0 ;
4075
4076   arg1 = (Dali::Vector4 *)jarg1;
4077   if (!arg1) {
4078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4079     return 0;
4080   }
4081   {
4082     try {
4083       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
4084     } CALL_CATCH_EXCEPTION(0);
4085   }
4086
4087   jresult = (void *)result;
4088   return jresult;
4089 }
4090
4091
4092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
4093   void * jresult ;
4094   Dali::Vector3 *result = 0 ;
4095
4096   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
4097   jresult = (void *)result;
4098   return jresult;
4099 }
4100
4101
4102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
4103   void * jresult ;
4104   Dali::Vector3 *result = 0 ;
4105
4106   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
4107   jresult = (void *)result;
4108   return jresult;
4109 }
4110
4111
4112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
4113   void * jresult ;
4114   Dali::Vector3 *result = 0 ;
4115
4116   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
4117   jresult = (void *)result;
4118   return jresult;
4119 }
4120
4121
4122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
4123   void * jresult ;
4124   Dali::Vector3 *result = 0 ;
4125
4126   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
4127   jresult = (void *)result;
4128   return jresult;
4129 }
4130
4131
4132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
4133   void * jresult ;
4134   Dali::Vector3 *result = 0 ;
4135
4136   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
4137   jresult = (void *)result;
4138   return jresult;
4139 }
4140
4141
4142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
4143   void * jresult ;
4144   Dali::Vector3 *result = 0 ;
4145
4146   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
4147   jresult = (void *)result;
4148   return jresult;
4149 }
4150
4151
4152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
4153   void * jresult ;
4154   Dali::Vector3 *result = 0 ;
4155
4156   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
4157   jresult = (void *)result;
4158   return jresult;
4159 }
4160
4161
4162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
4163   void * jresult ;
4164   Dali::Vector3 *result = 0 ;
4165
4166   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
4167   jresult = (void *)result;
4168   return jresult;
4169 }
4170
4171
4172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
4173   void * jresult ;
4174   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4175   float *arg2 = (float *) 0 ;
4176   Dali::Vector3 *result = 0 ;
4177
4178   arg1 = (Dali::Vector3 *)jarg1;
4179   arg2 = jarg2;
4180   {
4181     try {
4182       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
4183     } CALL_CATCH_EXCEPTION(0);
4184   }
4185
4186   jresult = (void *)result;
4187
4188
4189   return jresult;
4190 }
4191
4192
4193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
4194   void * jresult ;
4195   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4196   Dali::Vector2 *arg2 = 0 ;
4197   Dali::Vector3 *result = 0 ;
4198
4199   arg1 = (Dali::Vector3 *)jarg1;
4200   arg2 = (Dali::Vector2 *)jarg2;
4201   if (!arg2) {
4202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4203     return 0;
4204   }
4205   {
4206     try {
4207       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
4208     } CALL_CATCH_EXCEPTION(0);
4209   }
4210
4211   jresult = (void *)result;
4212   return jresult;
4213 }
4214
4215
4216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
4217   void * jresult ;
4218   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4219   Dali::Vector4 *arg2 = 0 ;
4220   Dali::Vector3 *result = 0 ;
4221
4222   arg1 = (Dali::Vector3 *)jarg1;
4223   arg2 = (Dali::Vector4 *)jarg2;
4224   if (!arg2) {
4225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4226     return 0;
4227   }
4228   {
4229     try {
4230       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4231     } CALL_CATCH_EXCEPTION(0);
4232   }
4233
4234   jresult = (void *)result;
4235   return jresult;
4236 }
4237
4238
4239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
4240   void * jresult ;
4241   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4242   Dali::Vector3 *arg2 = 0 ;
4243   Dali::Vector3 result;
4244
4245   arg1 = (Dali::Vector3 *)jarg1;
4246   arg2 = (Dali::Vector3 *)jarg2;
4247   if (!arg2) {
4248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4249     return 0;
4250   }
4251   {
4252     try {
4253       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
4254     } CALL_CATCH_EXCEPTION(0);
4255   }
4256
4257   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4258   return jresult;
4259 }
4260
4261
4262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
4263   void * jresult ;
4264   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4265   Dali::Vector3 *arg2 = 0 ;
4266   Dali::Vector3 *result = 0 ;
4267
4268   arg1 = (Dali::Vector3 *)jarg1;
4269   arg2 = (Dali::Vector3 *)jarg2;
4270   if (!arg2) {
4271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4272     return 0;
4273   }
4274   {
4275     try {
4276       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
4277     } CALL_CATCH_EXCEPTION(0);
4278   }
4279
4280   jresult = (void *)result;
4281   return jresult;
4282 }
4283
4284
4285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4286   void * jresult ;
4287   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4288   Dali::Vector3 *arg2 = 0 ;
4289   Dali::Vector3 result;
4290
4291   arg1 = (Dali::Vector3 *)jarg1;
4292   arg2 = (Dali::Vector3 *)jarg2;
4293   if (!arg2) {
4294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4295     return 0;
4296   }
4297   {
4298     try {
4299       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
4300     } CALL_CATCH_EXCEPTION(0);
4301   }
4302
4303   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4304   return jresult;
4305 }
4306
4307
4308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
4309   void * jresult ;
4310   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4311   Dali::Vector3 *arg2 = 0 ;
4312   Dali::Vector3 *result = 0 ;
4313
4314   arg1 = (Dali::Vector3 *)jarg1;
4315   arg2 = (Dali::Vector3 *)jarg2;
4316   if (!arg2) {
4317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4318     return 0;
4319   }
4320   {
4321     try {
4322       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
4323     } CALL_CATCH_EXCEPTION(0);
4324   }
4325
4326   jresult = (void *)result;
4327   return jresult;
4328 }
4329
4330
4331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4332   void * jresult ;
4333   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4334   Dali::Vector3 *arg2 = 0 ;
4335   Dali::Vector3 result;
4336
4337   arg1 = (Dali::Vector3 *)jarg1;
4338   arg2 = (Dali::Vector3 *)jarg2;
4339   if (!arg2) {
4340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4341     return 0;
4342   }
4343   {
4344     try {
4345       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
4346     } CALL_CATCH_EXCEPTION(0);
4347   }
4348
4349   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4350   return jresult;
4351 }
4352
4353
4354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
4355   void * jresult ;
4356   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4357   float arg2 ;
4358   Dali::Vector3 result;
4359
4360   arg1 = (Dali::Vector3 *)jarg1;
4361   arg2 = (float)jarg2;
4362   {
4363     try {
4364       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
4365     } CALL_CATCH_EXCEPTION(0);
4366   }
4367
4368   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4369   return jresult;
4370 }
4371
4372
4373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4374   void * jresult ;
4375   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4376   Dali::Vector3 *arg2 = 0 ;
4377   Dali::Vector3 *result = 0 ;
4378
4379   arg1 = (Dali::Vector3 *)jarg1;
4380   arg2 = (Dali::Vector3 *)jarg2;
4381   if (!arg2) {
4382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4383     return 0;
4384   }
4385   {
4386     try {
4387       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
4388     } CALL_CATCH_EXCEPTION(0);
4389   }
4390
4391   jresult = (void *)result;
4392   return jresult;
4393 }
4394
4395
4396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4397   void * jresult ;
4398   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4399   float arg2 ;
4400   Dali::Vector3 *result = 0 ;
4401
4402   arg1 = (Dali::Vector3 *)jarg1;
4403   arg2 = (float)jarg2;
4404   {
4405     try {
4406       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
4407     } CALL_CATCH_EXCEPTION(0);
4408   }
4409
4410   jresult = (void *)result;
4411   return jresult;
4412 }
4413
4414
4415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
4416   void * jresult ;
4417   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4418   Dali::Quaternion *arg2 = 0 ;
4419   Dali::Vector3 *result = 0 ;
4420
4421   arg1 = (Dali::Vector3 *)jarg1;
4422   arg2 = (Dali::Quaternion *)jarg2;
4423   if (!arg2) {
4424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
4425     return 0;
4426   }
4427   {
4428     try {
4429       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
4430     } CALL_CATCH_EXCEPTION(0);
4431   }
4432
4433   jresult = (void *)result;
4434   return jresult;
4435 }
4436
4437
4438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
4439   void * jresult ;
4440   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4441   Dali::Vector3 *arg2 = 0 ;
4442   Dali::Vector3 result;
4443
4444   arg1 = (Dali::Vector3 *)jarg1;
4445   arg2 = (Dali::Vector3 *)jarg2;
4446   if (!arg2) {
4447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4448     return 0;
4449   }
4450   {
4451     try {
4452       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
4453     } CALL_CATCH_EXCEPTION(0);
4454   }
4455
4456   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4457   return jresult;
4458 }
4459
4460
4461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
4462   void * jresult ;
4463   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4464   float arg2 ;
4465   Dali::Vector3 result;
4466
4467   arg1 = (Dali::Vector3 *)jarg1;
4468   arg2 = (float)jarg2;
4469   {
4470     try {
4471       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
4472     } CALL_CATCH_EXCEPTION(0);
4473   }
4474
4475   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4476   return jresult;
4477 }
4478
4479
4480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4481   void * jresult ;
4482   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4483   Dali::Vector3 *arg2 = 0 ;
4484   Dali::Vector3 *result = 0 ;
4485
4486   arg1 = (Dali::Vector3 *)jarg1;
4487   arg2 = (Dali::Vector3 *)jarg2;
4488   if (!arg2) {
4489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4490     return 0;
4491   }
4492   {
4493     try {
4494       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
4495     } CALL_CATCH_EXCEPTION(0);
4496   }
4497
4498   jresult = (void *)result;
4499   return jresult;
4500 }
4501
4502
4503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4504   void * jresult ;
4505   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4506   float arg2 ;
4507   Dali::Vector3 *result = 0 ;
4508
4509   arg1 = (Dali::Vector3 *)jarg1;
4510   arg2 = (float)jarg2;
4511   {
4512     try {
4513       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
4514     } CALL_CATCH_EXCEPTION(0);
4515   }
4516
4517   jresult = (void *)result;
4518   return jresult;
4519 }
4520
4521
4522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
4523   void * jresult ;
4524   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4525   Dali::Vector3 result;
4526
4527   arg1 = (Dali::Vector3 *)jarg1;
4528   {
4529     try {
4530       result = ((Dali::Vector3 const *)arg1)->operator -();
4531     } CALL_CATCH_EXCEPTION(0);
4532   }
4533
4534   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4535   return jresult;
4536 }
4537
4538
4539 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
4540   bool jresult ;
4541   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4542   Dali::Vector3 *arg2 = 0 ;
4543   bool result;
4544
4545   arg1 = (Dali::Vector3 *)jarg1;
4546   arg2 = (Dali::Vector3 *)jarg2;
4547   if (!arg2) {
4548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4549     return 0;
4550   }
4551   {
4552     try {
4553       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
4554     } CALL_CATCH_EXCEPTION(0);
4555   }
4556
4557   jresult = result;
4558   return jresult;
4559 }
4560
4561
4562 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
4563   bool jresult ;
4564   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4565   Dali::Vector3 *arg2 = 0 ;
4566   bool result;
4567
4568   arg1 = (Dali::Vector3 *)jarg1;
4569   arg2 = (Dali::Vector3 *)jarg2;
4570   if (!arg2) {
4571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4572     return 0;
4573   }
4574   {
4575     try {
4576       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
4577     } CALL_CATCH_EXCEPTION(0);
4578   }
4579
4580   jresult = result;
4581   return jresult;
4582 }
4583
4584
4585 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4586   float jresult ;
4587   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4588   unsigned int arg2 ;
4589   float *result = 0 ;
4590
4591   arg1 = (Dali::Vector3 *)jarg1;
4592   arg2 = (unsigned int)jarg2;
4593   {
4594     try {
4595       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
4596     } CALL_CATCH_EXCEPTION(0);
4597   }
4598
4599   jresult = *result;
4600   return jresult;
4601 }
4602
4603
4604 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
4605   float jresult ;
4606   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4607   Dali::Vector3 *arg2 = 0 ;
4608   float result;
4609
4610   arg1 = (Dali::Vector3 *)jarg1;
4611   arg2 = (Dali::Vector3 *)jarg2;
4612   if (!arg2) {
4613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4614     return 0;
4615   }
4616   {
4617     try {
4618       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
4619     } CALL_CATCH_EXCEPTION(0);
4620   }
4621
4622   jresult = result;
4623   return jresult;
4624 }
4625
4626
4627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
4628   void * jresult ;
4629   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4630   Dali::Vector3 *arg2 = 0 ;
4631   Dali::Vector3 result;
4632
4633   arg1 = (Dali::Vector3 *)jarg1;
4634   arg2 = (Dali::Vector3 *)jarg2;
4635   if (!arg2) {
4636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4637     return 0;
4638   }
4639   {
4640     try {
4641       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
4642     } CALL_CATCH_EXCEPTION(0);
4643   }
4644
4645   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4646   return jresult;
4647 }
4648
4649
4650 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
4651   float jresult ;
4652   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4653   float result;
4654
4655   arg1 = (Dali::Vector3 *)jarg1;
4656   {
4657     try {
4658       result = (float)((Dali::Vector3 const *)arg1)->Length();
4659     } CALL_CATCH_EXCEPTION(0);
4660   }
4661
4662   jresult = result;
4663   return jresult;
4664 }
4665
4666
4667 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
4668   float jresult ;
4669   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4670   float result;
4671
4672   arg1 = (Dali::Vector3 *)jarg1;
4673   {
4674     try {
4675       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
4676     } CALL_CATCH_EXCEPTION(0);
4677   }
4678
4679   jresult = result;
4680   return jresult;
4681 }
4682
4683
4684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
4685   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4686
4687   arg1 = (Dali::Vector3 *)jarg1;
4688   {
4689     try {
4690       (arg1)->Normalize();
4691     } CALL_CATCH_EXCEPTION();
4692   }
4693
4694 }
4695
4696
4697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4698   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4699   Dali::Vector3 *arg2 = 0 ;
4700   Dali::Vector3 *arg3 = 0 ;
4701
4702   arg1 = (Dali::Vector3 *)jarg1;
4703   arg2 = (Dali::Vector3 *)jarg2;
4704   if (!arg2) {
4705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4706     return ;
4707   }
4708   arg3 = (Dali::Vector3 *)jarg3;
4709   if (!arg3) {
4710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4711     return ;
4712   }
4713   {
4714     try {
4715       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
4716     } CALL_CATCH_EXCEPTION();
4717   }
4718
4719 }
4720
4721
4722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
4723   void * jresult ;
4724   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4725   float *result = 0 ;
4726
4727   arg1 = (Dali::Vector3 *)jarg1;
4728   {
4729     try {
4730       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
4731     } CALL_CATCH_EXCEPTION(0);
4732   }
4733
4734   jresult = (void *)result;
4735   return jresult;
4736 }
4737
4738
4739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
4740   void * jresult ;
4741   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4742   Dali::Vector2 *result = 0 ;
4743
4744   arg1 = (Dali::Vector3 *)jarg1;
4745   {
4746     try {
4747       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
4748     } CALL_CATCH_EXCEPTION(0);
4749   }
4750
4751   jresult = (void *)result;
4752   return jresult;
4753 }
4754
4755
4756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
4757   void * jresult ;
4758   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4759   Dali::Vector2 *result = 0 ;
4760
4761   arg1 = (Dali::Vector3 *)jarg1;
4762   {
4763     try {
4764       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
4765     } CALL_CATCH_EXCEPTION(0);
4766   }
4767
4768   jresult = (void *)result;
4769   return jresult;
4770 }
4771
4772
4773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
4774   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4775   float arg2 ;
4776
4777   arg1 = (Dali::Vector3 *)jarg1;
4778   arg2 = (float)jarg2;
4779   if (arg1) (arg1)->x = arg2;
4780 }
4781
4782
4783 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
4784   float jresult ;
4785   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4786   float result;
4787
4788   arg1 = (Dali::Vector3 *)jarg1;
4789   result = (float) ((arg1)->x);
4790   jresult = result;
4791   return jresult;
4792 }
4793
4794
4795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
4796   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4797   float arg2 ;
4798
4799   arg1 = (Dali::Vector3 *)jarg1;
4800   arg2 = (float)jarg2;
4801   if (arg1) (arg1)->width = arg2;
4802 }
4803
4804
4805 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
4806   float jresult ;
4807   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4808   float result;
4809
4810   arg1 = (Dali::Vector3 *)jarg1;
4811   result = (float) ((arg1)->width);
4812   jresult = result;
4813   return jresult;
4814 }
4815
4816
4817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
4818   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4819   float arg2 ;
4820
4821   arg1 = (Dali::Vector3 *)jarg1;
4822   arg2 = (float)jarg2;
4823   if (arg1) (arg1)->r = arg2;
4824 }
4825
4826
4827 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
4828   float jresult ;
4829   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4830   float result;
4831
4832   arg1 = (Dali::Vector3 *)jarg1;
4833   result = (float) ((arg1)->r);
4834   jresult = result;
4835   return jresult;
4836 }
4837
4838
4839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
4840   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4841   float arg2 ;
4842
4843   arg1 = (Dali::Vector3 *)jarg1;
4844   arg2 = (float)jarg2;
4845   if (arg1) (arg1)->y = arg2;
4846 }
4847
4848
4849 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
4850   float jresult ;
4851   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4852   float result;
4853
4854   arg1 = (Dali::Vector3 *)jarg1;
4855   result = (float) ((arg1)->y);
4856   jresult = result;
4857   return jresult;
4858 }
4859
4860
4861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
4862   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4863   float arg2 ;
4864
4865   arg1 = (Dali::Vector3 *)jarg1;
4866   arg2 = (float)jarg2;
4867   if (arg1) (arg1)->height = arg2;
4868 }
4869
4870
4871 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
4872   float jresult ;
4873   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4874   float result;
4875
4876   arg1 = (Dali::Vector3 *)jarg1;
4877   result = (float) ((arg1)->height);
4878   jresult = result;
4879   return jresult;
4880 }
4881
4882
4883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
4884   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4885   float arg2 ;
4886
4887   arg1 = (Dali::Vector3 *)jarg1;
4888   arg2 = (float)jarg2;
4889   if (arg1) (arg1)->g = arg2;
4890 }
4891
4892
4893 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
4894   float jresult ;
4895   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4896   float result;
4897
4898   arg1 = (Dali::Vector3 *)jarg1;
4899   result = (float) ((arg1)->g);
4900   jresult = result;
4901   return jresult;
4902 }
4903
4904
4905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
4906   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4907   float arg2 ;
4908
4909   arg1 = (Dali::Vector3 *)jarg1;
4910   arg2 = (float)jarg2;
4911   if (arg1) (arg1)->z = arg2;
4912 }
4913
4914
4915 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
4916   float jresult ;
4917   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4918   float result;
4919
4920   arg1 = (Dali::Vector3 *)jarg1;
4921   result = (float) ((arg1)->z);
4922   jresult = result;
4923   return jresult;
4924 }
4925
4926
4927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
4928   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4929   float arg2 ;
4930
4931   arg1 = (Dali::Vector3 *)jarg1;
4932   arg2 = (float)jarg2;
4933   if (arg1) (arg1)->depth = arg2;
4934 }
4935
4936
4937 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
4938   float jresult ;
4939   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4940   float result;
4941
4942   arg1 = (Dali::Vector3 *)jarg1;
4943   result = (float) ((arg1)->depth);
4944   jresult = result;
4945   return jresult;
4946 }
4947
4948
4949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
4950   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4951   float arg2 ;
4952
4953   arg1 = (Dali::Vector3 *)jarg1;
4954   arg2 = (float)jarg2;
4955   if (arg1) (arg1)->b = arg2;
4956 }
4957
4958
4959 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
4960   float jresult ;
4961   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4962   float result;
4963
4964   arg1 = (Dali::Vector3 *)jarg1;
4965   result = (float) ((arg1)->b);
4966   jresult = result;
4967   return jresult;
4968 }
4969
4970
4971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
4972   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4973
4974   arg1 = (Dali::Vector3 *)jarg1;
4975   {
4976     try {
4977       delete arg1;
4978     } CALL_CATCH_EXCEPTION();
4979   }
4980
4981 }
4982
4983
4984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
4985   void * jresult ;
4986   Dali::Vector3 *arg1 = 0 ;
4987   Dali::Vector3 *arg2 = 0 ;
4988   Dali::Vector3 result;
4989
4990   arg1 = (Dali::Vector3 *)jarg1;
4991   if (!arg1) {
4992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4993     return 0;
4994   }
4995   arg2 = (Dali::Vector3 *)jarg2;
4996   if (!arg2) {
4997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4998     return 0;
4999   }
5000   {
5001     try {
5002       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
5003     } CALL_CATCH_EXCEPTION(0);
5004   }
5005
5006   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5007   return jresult;
5008 }
5009
5010
5011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
5012   void * jresult ;
5013   Dali::Vector3 *arg1 = 0 ;
5014   Dali::Vector3 *arg2 = 0 ;
5015   Dali::Vector3 result;
5016
5017   arg1 = (Dali::Vector3 *)jarg1;
5018   if (!arg1) {
5019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5020     return 0;
5021   }
5022   arg2 = (Dali::Vector3 *)jarg2;
5023   if (!arg2) {
5024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5025     return 0;
5026   }
5027   {
5028     try {
5029       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
5030     } CALL_CATCH_EXCEPTION(0);
5031   }
5032
5033   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5034   return jresult;
5035 }
5036
5037
5038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
5039   void * jresult ;
5040   Dali::Vector3 *arg1 = 0 ;
5041   float *arg2 = 0 ;
5042   float *arg3 = 0 ;
5043   float temp2 ;
5044   float temp3 ;
5045   Dali::Vector3 result;
5046
5047   arg1 = (Dali::Vector3 *)jarg1;
5048   if (!arg1) {
5049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5050     return 0;
5051   }
5052   temp2 = (float)jarg2;
5053   arg2 = &temp2;
5054   temp3 = (float)jarg3;
5055   arg3 = &temp3;
5056   {
5057     try {
5058       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5059     } CALL_CATCH_EXCEPTION(0);
5060   }
5061
5062   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5063   return jresult;
5064 }
5065
5066
5067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
5068   void * jresult ;
5069   Dali::Vector4 *result = 0 ;
5070
5071   {
5072     try {
5073       result = (Dali::Vector4 *)new Dali::Vector4();
5074     } CALL_CATCH_EXCEPTION(0);
5075   }
5076
5077   jresult = (void *)result;
5078   return jresult;
5079 }
5080
5081
5082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
5083   void * jresult ;
5084   float arg1 ;
5085   float arg2 ;
5086   float arg3 ;
5087   float arg4 ;
5088   Dali::Vector4 *result = 0 ;
5089
5090   arg1 = (float)jarg1;
5091   arg2 = (float)jarg2;
5092   arg3 = (float)jarg3;
5093   arg4 = (float)jarg4;
5094   {
5095     try {
5096       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
5097     } CALL_CATCH_EXCEPTION(0);
5098   }
5099
5100   jresult = (void *)result;
5101   return jresult;
5102 }
5103
5104
5105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
5106   void * jresult ;
5107   float *arg1 = (float *) 0 ;
5108   Dali::Vector4 *result = 0 ;
5109
5110   arg1 = jarg1;
5111   {
5112     try {
5113       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
5114     } CALL_CATCH_EXCEPTION(0);
5115   }
5116
5117   jresult = (void *)result;
5118
5119
5120   return jresult;
5121 }
5122
5123
5124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
5125   void * jresult ;
5126   Dali::Vector2 *arg1 = 0 ;
5127   Dali::Vector4 *result = 0 ;
5128
5129   arg1 = (Dali::Vector2 *)jarg1;
5130   if (!arg1) {
5131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5132     return 0;
5133   }
5134   {
5135     try {
5136       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
5137     } CALL_CATCH_EXCEPTION(0);
5138   }
5139
5140   jresult = (void *)result;
5141   return jresult;
5142 }
5143
5144
5145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
5146   void * jresult ;
5147   Dali::Vector3 *arg1 = 0 ;
5148   Dali::Vector4 *result = 0 ;
5149
5150   arg1 = (Dali::Vector3 *)jarg1;
5151   if (!arg1) {
5152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5153     return 0;
5154   }
5155   {
5156     try {
5157       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
5158     } CALL_CATCH_EXCEPTION(0);
5159   }
5160
5161   jresult = (void *)result;
5162   return jresult;
5163 }
5164
5165
5166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
5167   void * jresult ;
5168   Dali::Vector4 *result = 0 ;
5169
5170   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
5171   jresult = (void *)result;
5172   return jresult;
5173 }
5174
5175
5176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
5177   void * jresult ;
5178   Dali::Vector4 *result = 0 ;
5179
5180   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
5181   jresult = (void *)result;
5182   return jresult;
5183 }
5184
5185
5186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
5187   void * jresult ;
5188   Dali::Vector4 *result = 0 ;
5189
5190   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
5191   jresult = (void *)result;
5192   return jresult;
5193 }
5194
5195
5196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
5197   void * jresult ;
5198   Dali::Vector4 *result = 0 ;
5199
5200   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
5201   jresult = (void *)result;
5202   return jresult;
5203 }
5204
5205
5206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
5207   void * jresult ;
5208   Dali::Vector4 *result = 0 ;
5209
5210   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
5211   jresult = (void *)result;
5212   return jresult;
5213 }
5214
5215
5216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
5217   void * jresult ;
5218   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5219   float *arg2 = (float *) 0 ;
5220   Dali::Vector4 *result = 0 ;
5221
5222   arg1 = (Dali::Vector4 *)jarg1;
5223   arg2 = jarg2;
5224   {
5225     try {
5226       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
5227     } CALL_CATCH_EXCEPTION(0);
5228   }
5229
5230   jresult = (void *)result;
5231
5232
5233   return jresult;
5234 }
5235
5236
5237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
5238   void * jresult ;
5239   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5240   Dali::Vector2 *arg2 = 0 ;
5241   Dali::Vector4 *result = 0 ;
5242
5243   arg1 = (Dali::Vector4 *)jarg1;
5244   arg2 = (Dali::Vector2 *)jarg2;
5245   if (!arg2) {
5246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5247     return 0;
5248   }
5249   {
5250     try {
5251       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5252     } CALL_CATCH_EXCEPTION(0);
5253   }
5254
5255   jresult = (void *)result;
5256   return jresult;
5257 }
5258
5259
5260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
5261   void * jresult ;
5262   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5263   Dali::Vector3 *arg2 = 0 ;
5264   Dali::Vector4 *result = 0 ;
5265
5266   arg1 = (Dali::Vector4 *)jarg1;
5267   arg2 = (Dali::Vector3 *)jarg2;
5268   if (!arg2) {
5269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5270     return 0;
5271   }
5272   {
5273     try {
5274       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
5275     } CALL_CATCH_EXCEPTION(0);
5276   }
5277
5278   jresult = (void *)result;
5279   return jresult;
5280 }
5281
5282
5283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
5284   void * jresult ;
5285   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5286   Dali::Vector4 *arg2 = 0 ;
5287   Dali::Vector4 result;
5288
5289   arg1 = (Dali::Vector4 *)jarg1;
5290   arg2 = (Dali::Vector4 *)jarg2;
5291   if (!arg2) {
5292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5293     return 0;
5294   }
5295   {
5296     try {
5297       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
5298     } CALL_CATCH_EXCEPTION(0);
5299   }
5300
5301   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5302   return jresult;
5303 }
5304
5305
5306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
5307   void * jresult ;
5308   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5309   Dali::Vector4 *arg2 = 0 ;
5310   Dali::Vector4 *result = 0 ;
5311
5312   arg1 = (Dali::Vector4 *)jarg1;
5313   arg2 = (Dali::Vector4 *)jarg2;
5314   if (!arg2) {
5315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5316     return 0;
5317   }
5318   {
5319     try {
5320       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
5321     } CALL_CATCH_EXCEPTION(0);
5322   }
5323
5324   jresult = (void *)result;
5325   return jresult;
5326 }
5327
5328
5329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5330   void * jresult ;
5331   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5332   Dali::Vector4 *arg2 = 0 ;
5333   Dali::Vector4 result;
5334
5335   arg1 = (Dali::Vector4 *)jarg1;
5336   arg2 = (Dali::Vector4 *)jarg2;
5337   if (!arg2) {
5338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5339     return 0;
5340   }
5341   {
5342     try {
5343       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
5344     } CALL_CATCH_EXCEPTION(0);
5345   }
5346
5347   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5348   return jresult;
5349 }
5350
5351
5352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
5353   void * jresult ;
5354   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5355   Dali::Vector4 *arg2 = 0 ;
5356   Dali::Vector4 *result = 0 ;
5357
5358   arg1 = (Dali::Vector4 *)jarg1;
5359   arg2 = (Dali::Vector4 *)jarg2;
5360   if (!arg2) {
5361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5362     return 0;
5363   }
5364   {
5365     try {
5366       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
5367     } CALL_CATCH_EXCEPTION(0);
5368   }
5369
5370   jresult = (void *)result;
5371   return jresult;
5372 }
5373
5374
5375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5376   void * jresult ;
5377   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5378   Dali::Vector4 *arg2 = 0 ;
5379   Dali::Vector4 result;
5380
5381   arg1 = (Dali::Vector4 *)jarg1;
5382   arg2 = (Dali::Vector4 *)jarg2;
5383   if (!arg2) {
5384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5385     return 0;
5386   }
5387   {
5388     try {
5389       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
5390     } CALL_CATCH_EXCEPTION(0);
5391   }
5392
5393   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5394   return jresult;
5395 }
5396
5397
5398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
5399   void * jresult ;
5400   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5401   float arg2 ;
5402   Dali::Vector4 result;
5403
5404   arg1 = (Dali::Vector4 *)jarg1;
5405   arg2 = (float)jarg2;
5406   {
5407     try {
5408       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
5409     } CALL_CATCH_EXCEPTION(0);
5410   }
5411
5412   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5413   return jresult;
5414 }
5415
5416
5417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5418   void * jresult ;
5419   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5420   Dali::Vector4 *arg2 = 0 ;
5421   Dali::Vector4 *result = 0 ;
5422
5423   arg1 = (Dali::Vector4 *)jarg1;
5424   arg2 = (Dali::Vector4 *)jarg2;
5425   if (!arg2) {
5426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5427     return 0;
5428   }
5429   {
5430     try {
5431       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
5432     } CALL_CATCH_EXCEPTION(0);
5433   }
5434
5435   jresult = (void *)result;
5436   return jresult;
5437 }
5438
5439
5440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5441   void * jresult ;
5442   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5443   float arg2 ;
5444   Dali::Vector4 *result = 0 ;
5445
5446   arg1 = (Dali::Vector4 *)jarg1;
5447   arg2 = (float)jarg2;
5448   {
5449     try {
5450       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
5451     } CALL_CATCH_EXCEPTION(0);
5452   }
5453
5454   jresult = (void *)result;
5455   return jresult;
5456 }
5457
5458
5459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
5460   void * jresult ;
5461   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5462   Dali::Vector4 *arg2 = 0 ;
5463   Dali::Vector4 result;
5464
5465   arg1 = (Dali::Vector4 *)jarg1;
5466   arg2 = (Dali::Vector4 *)jarg2;
5467   if (!arg2) {
5468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5469     return 0;
5470   }
5471   {
5472     try {
5473       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
5474     } CALL_CATCH_EXCEPTION(0);
5475   }
5476
5477   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5478   return jresult;
5479 }
5480
5481
5482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
5483   void * jresult ;
5484   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5485   float arg2 ;
5486   Dali::Vector4 result;
5487
5488   arg1 = (Dali::Vector4 *)jarg1;
5489   arg2 = (float)jarg2;
5490   {
5491     try {
5492       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
5493     } CALL_CATCH_EXCEPTION(0);
5494   }
5495
5496   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5497   return jresult;
5498 }
5499
5500
5501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5502   void * jresult ;
5503   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5504   Dali::Vector4 *arg2 = 0 ;
5505   Dali::Vector4 *result = 0 ;
5506
5507   arg1 = (Dali::Vector4 *)jarg1;
5508   arg2 = (Dali::Vector4 *)jarg2;
5509   if (!arg2) {
5510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5511     return 0;
5512   }
5513   {
5514     try {
5515       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
5516     } CALL_CATCH_EXCEPTION(0);
5517   }
5518
5519   jresult = (void *)result;
5520   return jresult;
5521 }
5522
5523
5524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5525   void * jresult ;
5526   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5527   float arg2 ;
5528   Dali::Vector4 *result = 0 ;
5529
5530   arg1 = (Dali::Vector4 *)jarg1;
5531   arg2 = (float)jarg2;
5532   {
5533     try {
5534       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
5535     } CALL_CATCH_EXCEPTION(0);
5536   }
5537
5538   jresult = (void *)result;
5539   return jresult;
5540 }
5541
5542
5543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
5544   void * jresult ;
5545   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5546   Dali::Vector4 result;
5547
5548   arg1 = (Dali::Vector4 *)jarg1;
5549   {
5550     try {
5551       result = ((Dali::Vector4 const *)arg1)->operator -();
5552     } CALL_CATCH_EXCEPTION(0);
5553   }
5554
5555   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5556   return jresult;
5557 }
5558
5559
5560 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
5561   bool jresult ;
5562   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5563   Dali::Vector4 *arg2 = 0 ;
5564   bool result;
5565
5566   arg1 = (Dali::Vector4 *)jarg1;
5567   arg2 = (Dali::Vector4 *)jarg2;
5568   if (!arg2) {
5569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5570     return 0;
5571   }
5572   {
5573     try {
5574       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
5575     } CALL_CATCH_EXCEPTION(0);
5576   }
5577
5578   jresult = result;
5579   return jresult;
5580 }
5581
5582
5583 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
5584   bool jresult ;
5585   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5586   Dali::Vector4 *arg2 = 0 ;
5587   bool result;
5588
5589   arg1 = (Dali::Vector4 *)jarg1;
5590   arg2 = (Dali::Vector4 *)jarg2;
5591   if (!arg2) {
5592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5593     return 0;
5594   }
5595   {
5596     try {
5597       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
5598     } CALL_CATCH_EXCEPTION(0);
5599   }
5600
5601   jresult = result;
5602   return jresult;
5603 }
5604
5605
5606 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5607   float jresult ;
5608   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5609   unsigned int arg2 ;
5610   float *result = 0 ;
5611
5612   arg1 = (Dali::Vector4 *)jarg1;
5613   arg2 = (unsigned int)jarg2;
5614   {
5615     try {
5616       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
5617     } CALL_CATCH_EXCEPTION(0);
5618   }
5619
5620   jresult = *result;
5621   return jresult;
5622 }
5623
5624
5625 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
5626   float jresult ;
5627   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5628   Dali::Vector3 *arg2 = 0 ;
5629   float result;
5630
5631   arg1 = (Dali::Vector4 *)jarg1;
5632   arg2 = (Dali::Vector3 *)jarg2;
5633   if (!arg2) {
5634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5635     return 0;
5636   }
5637   {
5638     try {
5639       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5640     } CALL_CATCH_EXCEPTION(0);
5641   }
5642
5643   jresult = result;
5644   return jresult;
5645 }
5646
5647
5648 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
5649   float jresult ;
5650   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5651   Dali::Vector4 *arg2 = 0 ;
5652   float result;
5653
5654   arg1 = (Dali::Vector4 *)jarg1;
5655   arg2 = (Dali::Vector4 *)jarg2;
5656   if (!arg2) {
5657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5658     return 0;
5659   }
5660   {
5661     try {
5662       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
5663     } CALL_CATCH_EXCEPTION(0);
5664   }
5665
5666   jresult = result;
5667   return jresult;
5668 }
5669
5670
5671 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
5672   float jresult ;
5673   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5674   Dali::Vector4 *arg2 = 0 ;
5675   float result;
5676
5677   arg1 = (Dali::Vector4 *)jarg1;
5678   arg2 = (Dali::Vector4 *)jarg2;
5679   if (!arg2) {
5680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5681     return 0;
5682   }
5683   {
5684     try {
5685       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
5686     } CALL_CATCH_EXCEPTION(0);
5687   }
5688
5689   jresult = result;
5690   return jresult;
5691 }
5692
5693
5694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
5695   void * jresult ;
5696   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5697   Dali::Vector4 *arg2 = 0 ;
5698   Dali::Vector4 result;
5699
5700   arg1 = (Dali::Vector4 *)jarg1;
5701   arg2 = (Dali::Vector4 *)jarg2;
5702   if (!arg2) {
5703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5704     return 0;
5705   }
5706   {
5707     try {
5708       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
5709     } CALL_CATCH_EXCEPTION(0);
5710   }
5711
5712   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5713   return jresult;
5714 }
5715
5716
5717 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
5718   float jresult ;
5719   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5720   float result;
5721
5722   arg1 = (Dali::Vector4 *)jarg1;
5723   {
5724     try {
5725       result = (float)((Dali::Vector4 const *)arg1)->Length();
5726     } CALL_CATCH_EXCEPTION(0);
5727   }
5728
5729   jresult = result;
5730   return jresult;
5731 }
5732
5733
5734 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
5735   float jresult ;
5736   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5737   float result;
5738
5739   arg1 = (Dali::Vector4 *)jarg1;
5740   {
5741     try {
5742       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
5743     } CALL_CATCH_EXCEPTION(0);
5744   }
5745
5746   jresult = result;
5747   return jresult;
5748 }
5749
5750
5751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
5752   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5753
5754   arg1 = (Dali::Vector4 *)jarg1;
5755   {
5756     try {
5757       (arg1)->Normalize();
5758     } CALL_CATCH_EXCEPTION();
5759   }
5760
5761 }
5762
5763
5764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5765   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5766   Dali::Vector4 *arg2 = 0 ;
5767   Dali::Vector4 *arg3 = 0 ;
5768
5769   arg1 = (Dali::Vector4 *)jarg1;
5770   arg2 = (Dali::Vector4 *)jarg2;
5771   if (!arg2) {
5772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5773     return ;
5774   }
5775   arg3 = (Dali::Vector4 *)jarg3;
5776   if (!arg3) {
5777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5778     return ;
5779   }
5780   {
5781     try {
5782       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
5783     } CALL_CATCH_EXCEPTION();
5784   }
5785
5786 }
5787
5788
5789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
5790   void * jresult ;
5791   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5792   float *result = 0 ;
5793
5794   arg1 = (Dali::Vector4 *)jarg1;
5795   {
5796     try {
5797       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
5798     } CALL_CATCH_EXCEPTION(0);
5799   }
5800
5801   jresult = (void *)result;
5802   return jresult;
5803 }
5804
5805
5806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
5807   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5808   float arg2 ;
5809
5810   arg1 = (Dali::Vector4 *)jarg1;
5811   arg2 = (float)jarg2;
5812   if (arg1) (arg1)->x = arg2;
5813 }
5814
5815
5816 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
5817   float jresult ;
5818   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5819   float result;
5820
5821   arg1 = (Dali::Vector4 *)jarg1;
5822   result = (float) ((arg1)->x);
5823   jresult = result;
5824   return jresult;
5825 }
5826
5827
5828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
5829   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5830   float arg2 ;
5831
5832   arg1 = (Dali::Vector4 *)jarg1;
5833   arg2 = (float)jarg2;
5834   if (arg1) (arg1)->r = arg2;
5835 }
5836
5837
5838 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
5839   float jresult ;
5840   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5841   float result;
5842
5843   arg1 = (Dali::Vector4 *)jarg1;
5844   result = (float) ((arg1)->r);
5845   jresult = result;
5846   return jresult;
5847 }
5848
5849
5850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
5851   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5852   float arg2 ;
5853
5854   arg1 = (Dali::Vector4 *)jarg1;
5855   arg2 = (float)jarg2;
5856   if (arg1) (arg1)->s = arg2;
5857 }
5858
5859
5860 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
5861   float jresult ;
5862   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5863   float result;
5864
5865   arg1 = (Dali::Vector4 *)jarg1;
5866   result = (float) ((arg1)->s);
5867   jresult = result;
5868   return jresult;
5869 }
5870
5871
5872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
5873   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5874   float arg2 ;
5875
5876   arg1 = (Dali::Vector4 *)jarg1;
5877   arg2 = (float)jarg2;
5878   if (arg1) (arg1)->y = arg2;
5879 }
5880
5881
5882 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
5883   float jresult ;
5884   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5885   float result;
5886
5887   arg1 = (Dali::Vector4 *)jarg1;
5888   result = (float) ((arg1)->y);
5889   jresult = result;
5890   return jresult;
5891 }
5892
5893
5894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
5895   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5896   float arg2 ;
5897
5898   arg1 = (Dali::Vector4 *)jarg1;
5899   arg2 = (float)jarg2;
5900   if (arg1) (arg1)->g = arg2;
5901 }
5902
5903
5904 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
5905   float jresult ;
5906   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5907   float result;
5908
5909   arg1 = (Dali::Vector4 *)jarg1;
5910   result = (float) ((arg1)->g);
5911   jresult = result;
5912   return jresult;
5913 }
5914
5915
5916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
5917   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5918   float arg2 ;
5919
5920   arg1 = (Dali::Vector4 *)jarg1;
5921   arg2 = (float)jarg2;
5922   if (arg1) (arg1)->t = arg2;
5923 }
5924
5925
5926 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
5927   float jresult ;
5928   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5929   float result;
5930
5931   arg1 = (Dali::Vector4 *)jarg1;
5932   result = (float) ((arg1)->t);
5933   jresult = result;
5934   return jresult;
5935 }
5936
5937
5938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
5939   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5940   float arg2 ;
5941
5942   arg1 = (Dali::Vector4 *)jarg1;
5943   arg2 = (float)jarg2;
5944   if (arg1) (arg1)->z = arg2;
5945 }
5946
5947
5948 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
5949   float jresult ;
5950   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5951   float result;
5952
5953   arg1 = (Dali::Vector4 *)jarg1;
5954   result = (float) ((arg1)->z);
5955   jresult = result;
5956   return jresult;
5957 }
5958
5959
5960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
5961   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5962   float arg2 ;
5963
5964   arg1 = (Dali::Vector4 *)jarg1;
5965   arg2 = (float)jarg2;
5966   if (arg1) (arg1)->b = arg2;
5967 }
5968
5969
5970 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
5971   float jresult ;
5972   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5973   float result;
5974
5975   arg1 = (Dali::Vector4 *)jarg1;
5976   result = (float) ((arg1)->b);
5977   jresult = result;
5978   return jresult;
5979 }
5980
5981
5982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
5983   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5984   float arg2 ;
5985
5986   arg1 = (Dali::Vector4 *)jarg1;
5987   arg2 = (float)jarg2;
5988   if (arg1) (arg1)->p = arg2;
5989 }
5990
5991
5992 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
5993   float jresult ;
5994   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5995   float result;
5996
5997   arg1 = (Dali::Vector4 *)jarg1;
5998   result = (float) ((arg1)->p);
5999   jresult = result;
6000   return jresult;
6001 }
6002
6003
6004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
6005   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6006   float arg2 ;
6007
6008   arg1 = (Dali::Vector4 *)jarg1;
6009   arg2 = (float)jarg2;
6010   if (arg1) (arg1)->w = arg2;
6011 }
6012
6013
6014 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
6015   float jresult ;
6016   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6017   float result;
6018
6019   arg1 = (Dali::Vector4 *)jarg1;
6020   result = (float) ((arg1)->w);
6021   jresult = result;
6022   return jresult;
6023 }
6024
6025
6026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
6027   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6028   float arg2 ;
6029
6030   arg1 = (Dali::Vector4 *)jarg1;
6031   arg2 = (float)jarg2;
6032   if (arg1) (arg1)->a = arg2;
6033 }
6034
6035
6036 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
6037   float jresult ;
6038   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6039   float result;
6040
6041   arg1 = (Dali::Vector4 *)jarg1;
6042   result = (float) ((arg1)->a);
6043   jresult = result;
6044   return jresult;
6045 }
6046
6047
6048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
6049   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6050   float arg2 ;
6051
6052   arg1 = (Dali::Vector4 *)jarg1;
6053   arg2 = (float)jarg2;
6054   if (arg1) (arg1)->q = arg2;
6055 }
6056
6057
6058 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
6059   float jresult ;
6060   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6061   float result;
6062
6063   arg1 = (Dali::Vector4 *)jarg1;
6064   result = (float) ((arg1)->q);
6065   jresult = result;
6066   return jresult;
6067 }
6068
6069
6070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
6071   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6072
6073   arg1 = (Dali::Vector4 *)jarg1;
6074   {
6075     try {
6076       delete arg1;
6077     } CALL_CATCH_EXCEPTION();
6078   }
6079
6080 }
6081
6082
6083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
6084   void * jresult ;
6085   Dali::Vector4 *arg1 = 0 ;
6086   Dali::Vector4 *arg2 = 0 ;
6087   Dali::Vector4 result;
6088
6089   arg1 = (Dali::Vector4 *)jarg1;
6090   if (!arg1) {
6091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6092     return 0;
6093   }
6094   arg2 = (Dali::Vector4 *)jarg2;
6095   if (!arg2) {
6096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6097     return 0;
6098   }
6099   {
6100     try {
6101       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
6102     } CALL_CATCH_EXCEPTION(0);
6103   }
6104
6105   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6106   return jresult;
6107 }
6108
6109
6110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
6111   void * jresult ;
6112   Dali::Vector4 *arg1 = 0 ;
6113   Dali::Vector4 *arg2 = 0 ;
6114   Dali::Vector4 result;
6115
6116   arg1 = (Dali::Vector4 *)jarg1;
6117   if (!arg1) {
6118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6119     return 0;
6120   }
6121   arg2 = (Dali::Vector4 *)jarg2;
6122   if (!arg2) {
6123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6124     return 0;
6125   }
6126   {
6127     try {
6128       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
6129     } CALL_CATCH_EXCEPTION(0);
6130   }
6131
6132   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6133   return jresult;
6134 }
6135
6136
6137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
6138   void * jresult ;
6139   Dali::Vector4 *arg1 = 0 ;
6140   float *arg2 = 0 ;
6141   float *arg3 = 0 ;
6142   float temp2 ;
6143   float temp3 ;
6144   Dali::Vector4 result;
6145
6146   arg1 = (Dali::Vector4 *)jarg1;
6147   if (!arg1) {
6148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6149     return 0;
6150   }
6151   temp2 = (float)jarg2;
6152   arg2 = &temp2;
6153   temp3 = (float)jarg3;
6154   arg3 = &temp3;
6155   {
6156     try {
6157       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6158     } CALL_CATCH_EXCEPTION(0);
6159   }
6160
6161   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6162   return jresult;
6163 }
6164
6165
6166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
6167   void * jresult ;
6168   Dali::Uint16Pair *result = 0 ;
6169
6170   {
6171     try {
6172       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
6173     } CALL_CATCH_EXCEPTION(0);
6174   }
6175
6176   jresult = (void *)result;
6177   return jresult;
6178 }
6179
6180
6181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
6182   void * jresult ;
6183   uint32_t arg1 ;
6184   uint32_t arg2 ;
6185   Dali::Uint16Pair *result = 0 ;
6186
6187   arg1 = (uint32_t)jarg1;
6188   arg2 = (uint32_t)jarg2;
6189   {
6190     try {
6191       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
6192     } CALL_CATCH_EXCEPTION(0);
6193   }
6194
6195   jresult = (void *)result;
6196   return jresult;
6197 }
6198
6199
6200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
6201   void * jresult ;
6202   Dali::Uint16Pair *arg1 = 0 ;
6203   Dali::Uint16Pair *result = 0 ;
6204
6205   arg1 = (Dali::Uint16Pair *)jarg1;
6206   if (!arg1) {
6207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6208     return 0;
6209   }
6210   {
6211     try {
6212       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
6213     } CALL_CATCH_EXCEPTION(0);
6214   }
6215
6216   jresult = (void *)result;
6217   return jresult;
6218 }
6219
6220
6221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
6222   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6223   uint16_t arg2 ;
6224
6225   arg1 = (Dali::Uint16Pair *)jarg1;
6226   arg2 = (uint16_t)jarg2;
6227   {
6228     try {
6229       (arg1)->SetWidth(arg2);
6230     } CALL_CATCH_EXCEPTION();
6231   }
6232
6233 }
6234
6235
6236 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
6237   unsigned short jresult ;
6238   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6239   uint16_t result;
6240
6241   arg1 = (Dali::Uint16Pair *)jarg1;
6242   {
6243     try {
6244       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
6245     } CALL_CATCH_EXCEPTION(0);
6246   }
6247
6248   jresult = result;
6249   return jresult;
6250 }
6251
6252
6253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
6254   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6255   uint16_t arg2 ;
6256
6257   arg1 = (Dali::Uint16Pair *)jarg1;
6258   arg2 = (uint16_t)jarg2;
6259   {
6260     try {
6261       (arg1)->SetHeight(arg2);
6262     } CALL_CATCH_EXCEPTION();
6263   }
6264
6265 }
6266
6267
6268 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
6269   unsigned short jresult ;
6270   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6271   uint16_t result;
6272
6273   arg1 = (Dali::Uint16Pair *)jarg1;
6274   {
6275     try {
6276       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
6277     } CALL_CATCH_EXCEPTION(0);
6278   }
6279
6280   jresult = result;
6281   return jresult;
6282 }
6283
6284
6285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
6286   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6287   uint16_t arg2 ;
6288
6289   arg1 = (Dali::Uint16Pair *)jarg1;
6290   arg2 = (uint16_t)jarg2;
6291   {
6292     try {
6293       (arg1)->SetX(arg2);
6294     } CALL_CATCH_EXCEPTION();
6295   }
6296
6297 }
6298
6299
6300 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
6301   unsigned short jresult ;
6302   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6303   uint16_t result;
6304
6305   arg1 = (Dali::Uint16Pair *)jarg1;
6306   {
6307     try {
6308       result = ((Dali::Uint16Pair const *)arg1)->GetX();
6309     } CALL_CATCH_EXCEPTION(0);
6310   }
6311
6312   jresult = result;
6313   return jresult;
6314 }
6315
6316
6317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
6318   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6319   uint16_t arg2 ;
6320
6321   arg1 = (Dali::Uint16Pair *)jarg1;
6322   arg2 = (uint16_t)jarg2;
6323   {
6324     try {
6325       (arg1)->SetY(arg2);
6326     } CALL_CATCH_EXCEPTION();
6327   }
6328
6329 }
6330
6331
6332 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
6333   unsigned short jresult ;
6334   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6335   uint16_t result;
6336
6337   arg1 = (Dali::Uint16Pair *)jarg1;
6338   {
6339     try {
6340       result = ((Dali::Uint16Pair const *)arg1)->GetY();
6341     } CALL_CATCH_EXCEPTION(0);
6342   }
6343
6344   jresult = result;
6345   return jresult;
6346 }
6347
6348
6349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
6350   void * jresult ;
6351   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6352   Dali::Uint16Pair *arg2 = 0 ;
6353   Dali::Uint16Pair *result = 0 ;
6354
6355   arg1 = (Dali::Uint16Pair *)jarg1;
6356   arg2 = (Dali::Uint16Pair *)jarg2;
6357   if (!arg2) {
6358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6359     return 0;
6360   }
6361   {
6362     try {
6363       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
6364     } CALL_CATCH_EXCEPTION(0);
6365   }
6366
6367   jresult = (void *)result;
6368   return jresult;
6369 }
6370
6371
6372 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
6373   bool jresult ;
6374   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6375   Dali::Uint16Pair *arg2 = 0 ;
6376   bool result;
6377
6378   arg1 = (Dali::Uint16Pair *)jarg1;
6379   arg2 = (Dali::Uint16Pair *)jarg2;
6380   if (!arg2) {
6381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6382     return 0;
6383   }
6384   {
6385     try {
6386       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
6387     } CALL_CATCH_EXCEPTION(0);
6388   }
6389
6390   jresult = result;
6391   return jresult;
6392 }
6393
6394
6395 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
6396   bool jresult ;
6397   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6398   Dali::Uint16Pair *arg2 = 0 ;
6399   bool result;
6400
6401   arg1 = (Dali::Uint16Pair *)jarg1;
6402   arg2 = (Dali::Uint16Pair *)jarg2;
6403   if (!arg2) {
6404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6405     return 0;
6406   }
6407   {
6408     try {
6409       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
6410     } CALL_CATCH_EXCEPTION(0);
6411   }
6412
6413   jresult = result;
6414   return jresult;
6415 }
6416
6417
6418 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
6419   bool jresult ;
6420   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6421   Dali::Uint16Pair *arg2 = 0 ;
6422   bool result;
6423
6424   arg1 = (Dali::Uint16Pair *)jarg1;
6425   arg2 = (Dali::Uint16Pair *)jarg2;
6426   if (!arg2) {
6427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6428     return 0;
6429   }
6430   {
6431     try {
6432       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
6433     } CALL_CATCH_EXCEPTION(0);
6434   }
6435
6436   jresult = result;
6437   return jresult;
6438 }
6439
6440
6441 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
6442   bool jresult ;
6443   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6444   Dali::Uint16Pair *arg2 = 0 ;
6445   bool result;
6446
6447   arg1 = (Dali::Uint16Pair *)jarg1;
6448   arg2 = (Dali::Uint16Pair *)jarg2;
6449   if (!arg2) {
6450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6451     return 0;
6452   }
6453   {
6454     try {
6455       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
6456     } CALL_CATCH_EXCEPTION(0);
6457   }
6458
6459   jresult = result;
6460   return jresult;
6461 }
6462
6463
6464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
6465   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6466
6467   arg1 = (Dali::Uint16Pair *)jarg1;
6468   {
6469     try {
6470       delete arg1;
6471     } CALL_CATCH_EXCEPTION();
6472   }
6473
6474 }
6475
6476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Int32Pair__SWIG_0() {
6477   void * jresult ;
6478   Dali::Int32Pair *result = 0 ;
6479
6480   {
6481     try {
6482       result = (Dali::Int32Pair *)new Dali::Int32Pair();
6483     } CALL_CATCH_EXCEPTION(0);
6484   }
6485
6486   jresult = (void *)result;
6487   return jresult;
6488 }
6489
6490
6491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Int32Pair__SWIG_1(int32_t x, int32_t y) {
6492   void * jresult ;
6493   Dali::Int32Pair *result = 0 ;
6494
6495   {
6496     try {
6497       result = (Dali::Int32Pair *)new Dali::Int32Pair(x,y);
6498     } CALL_CATCH_EXCEPTION(0);
6499   }
6500
6501   jresult = (void *)result;
6502   return jresult;
6503 }
6504
6505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Int32Pair_SetX(void * int32Pair, int32_t x) {
6506   Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ;
6507
6508   {
6509     try {
6510       (pInt32Pair)->SetX(x);
6511     } CALL_CATCH_EXCEPTION();
6512   }
6513 }
6514
6515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Int32Pair_GetX(void * int32Pair) {
6516   int result ;
6517   Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair);
6518
6519   {
6520     try {
6521       result = ((Dali::Int32Pair const *)pInt32Pair)->GetX();
6522     } CALL_CATCH_EXCEPTION(0);
6523   }
6524
6525   return result;
6526 }
6527
6528
6529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Int32Pair_SetY(void * int32Pair, int32_t y) {
6530   Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ;
6531
6532   {
6533     try {
6534       (pInt32Pair)->SetY(y);
6535     } CALL_CATCH_EXCEPTION();
6536   }
6537
6538 }
6539
6540
6541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Int32Pair_GetY(void * int32Pair) {
6542   Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ;
6543   int result;
6544
6545   {
6546     try {
6547       result = ((Dali::Int32Pair const *)pInt32Pair)->GetY();
6548     } CALL_CATCH_EXCEPTION(0);
6549   }
6550
6551   return result;
6552 }
6553
6554
6555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Int32Pair(void * int32Pair) {
6556   Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ;
6557
6558   {
6559     try {
6560       delete pInt32Pair;
6561     } CALL_CATCH_EXCEPTION();
6562   }
6563
6564 }
6565
6566
6567
6568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
6569   void * jresult ;
6570   Dali::Degree *result = 0 ;
6571
6572   {
6573     try {
6574       result = (Dali::Degree *)new Dali::Degree();
6575     } CALL_CATCH_EXCEPTION(0);
6576   }
6577
6578   jresult = (void *)result;
6579   return jresult;
6580 }
6581
6582
6583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
6584   void * jresult ;
6585   float arg1 ;
6586   Dali::Degree *result = 0 ;
6587
6588   arg1 = (float)jarg1;
6589   {
6590     try {
6591       result = (Dali::Degree *)new Dali::Degree(arg1);
6592     } CALL_CATCH_EXCEPTION(0);
6593   }
6594
6595   jresult = (void *)result;
6596   return jresult;
6597 }
6598
6599
6600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
6601   void * jresult ;
6602   Dali::Radian arg1 ;
6603   Dali::Radian *argp1 ;
6604   Dali::Degree *result = 0 ;
6605
6606   argp1 = (Dali::Radian *)jarg1;
6607   if (!argp1) {
6608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
6609     return 0;
6610   }
6611   arg1 = *argp1;
6612   {
6613     try {
6614       result = (Dali::Degree *)new Dali::Degree(arg1);
6615     } CALL_CATCH_EXCEPTION(0);
6616   }
6617
6618   jresult = (void *)result;
6619   return jresult;
6620 }
6621
6622
6623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
6624   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
6625   float arg2 ;
6626
6627   arg1 = (Dali::Degree *)jarg1;
6628   arg2 = (float)jarg2;
6629   if (arg1) (arg1)->degree = arg2;
6630 }
6631
6632
6633 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
6634   float jresult ;
6635   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
6636   float result;
6637
6638   arg1 = (Dali::Degree *)jarg1;
6639   result = (float) ((arg1)->degree);
6640   jresult = result;
6641   return jresult;
6642 }
6643
6644
6645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
6646   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
6647
6648   arg1 = (Dali::Degree *)jarg1;
6649   {
6650     try {
6651       delete arg1;
6652     } CALL_CATCH_EXCEPTION();
6653   }
6654
6655 }
6656
6657
6658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
6659   void * jresult ;
6660   Dali::Radian *result = 0 ;
6661
6662   result = (Dali::Radian *)&Dali::ANGLE_360;
6663   jresult = (void *)result;
6664   return jresult;
6665 }
6666
6667
6668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
6669   void * jresult ;
6670   Dali::Radian *result = 0 ;
6671
6672   result = (Dali::Radian *)&Dali::ANGLE_315;
6673   jresult = (void *)result;
6674   return jresult;
6675 }
6676
6677
6678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
6679   void * jresult ;
6680   Dali::Radian *result = 0 ;
6681
6682   result = (Dali::Radian *)&Dali::ANGLE_270;
6683   jresult = (void *)result;
6684   return jresult;
6685 }
6686
6687
6688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
6689   void * jresult ;
6690   Dali::Radian *result = 0 ;
6691
6692   result = (Dali::Radian *)&Dali::ANGLE_225;
6693   jresult = (void *)result;
6694   return jresult;
6695 }
6696
6697
6698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
6699   void * jresult ;
6700   Dali::Radian *result = 0 ;
6701
6702   result = (Dali::Radian *)&Dali::ANGLE_180;
6703   jresult = (void *)result;
6704   return jresult;
6705 }
6706
6707
6708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
6709   void * jresult ;
6710   Dali::Radian *result = 0 ;
6711
6712   result = (Dali::Radian *)&Dali::ANGLE_135;
6713   jresult = (void *)result;
6714   return jresult;
6715 }
6716
6717
6718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
6719   void * jresult ;
6720   Dali::Radian *result = 0 ;
6721
6722   result = (Dali::Radian *)&Dali::ANGLE_120;
6723   jresult = (void *)result;
6724   return jresult;
6725 }
6726
6727
6728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
6729   void * jresult ;
6730   Dali::Radian *result = 0 ;
6731
6732   result = (Dali::Radian *)&Dali::ANGLE_90;
6733   jresult = (void *)result;
6734   return jresult;
6735 }
6736
6737
6738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
6739   void * jresult ;
6740   Dali::Radian *result = 0 ;
6741
6742   result = (Dali::Radian *)&Dali::ANGLE_60;
6743   jresult = (void *)result;
6744   return jresult;
6745 }
6746
6747
6748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
6749   void * jresult ;
6750   Dali::Radian *result = 0 ;
6751
6752   result = (Dali::Radian *)&Dali::ANGLE_45;
6753   jresult = (void *)result;
6754   return jresult;
6755 }
6756
6757
6758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
6759   void * jresult ;
6760   Dali::Radian *result = 0 ;
6761
6762   result = (Dali::Radian *)&Dali::ANGLE_30;
6763   jresult = (void *)result;
6764   return jresult;
6765 }
6766
6767
6768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
6769   void * jresult ;
6770   Dali::Radian *result = 0 ;
6771
6772   result = (Dali::Radian *)&Dali::ANGLE_0;
6773   jresult = (void *)result;
6774   return jresult;
6775 }
6776
6777
6778 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
6779   bool jresult ;
6780   Dali::Degree *arg1 = 0 ;
6781   Dali::Degree *arg2 = 0 ;
6782   bool result;
6783
6784   arg1 = (Dali::Degree *)jarg1;
6785   if (!arg1) {
6786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6787     return 0;
6788   }
6789   arg2 = (Dali::Degree *)jarg2;
6790   if (!arg2) {
6791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6792     return 0;
6793   }
6794   {
6795     try {
6796       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
6797     } CALL_CATCH_EXCEPTION(0);
6798   }
6799
6800   jresult = result;
6801   return jresult;
6802 }
6803
6804
6805 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
6806   bool jresult ;
6807   Dali::Degree *arg1 = 0 ;
6808   Dali::Degree *arg2 = 0 ;
6809   bool result;
6810
6811   arg1 = (Dali::Degree *)jarg1;
6812   if (!arg1) {
6813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6814     return 0;
6815   }
6816   arg2 = (Dali::Degree *)jarg2;
6817   if (!arg2) {
6818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6819     return 0;
6820   }
6821   {
6822     try {
6823       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
6824     } CALL_CATCH_EXCEPTION(0);
6825   }
6826
6827   jresult = result;
6828   return jresult;
6829 }
6830
6831
6832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
6833   void * jresult ;
6834   Dali::Degree arg1 ;
6835   float arg2 ;
6836   float arg3 ;
6837   Dali::Degree *argp1 ;
6838   Dali::Degree result;
6839
6840   argp1 = (Dali::Degree *)jarg1;
6841   if (!argp1) {
6842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
6843     return 0;
6844   }
6845   arg1 = *argp1;
6846   arg2 = (float)jarg2;
6847   arg3 = (float)jarg3;
6848   {
6849     try {
6850       result = Dali::Clamp(arg1,arg2,arg3);
6851     } CALL_CATCH_EXCEPTION(0);
6852   }
6853
6854   jresult = new Dali::Degree((const Dali::Degree &)result);
6855   return jresult;
6856 }
6857
6858
6859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
6860   void * jresult ;
6861   Dali::Radian *result = 0 ;
6862
6863   {
6864     try {
6865       result = (Dali::Radian *)new Dali::Radian();
6866     } CALL_CATCH_EXCEPTION(0);
6867   }
6868
6869   jresult = (void *)result;
6870   return jresult;
6871 }
6872
6873
6874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
6875   void * jresult ;
6876   float arg1 ;
6877   Dali::Radian *result = 0 ;
6878
6879   arg1 = (float)jarg1;
6880   {
6881     try {
6882       result = (Dali::Radian *)new Dali::Radian(arg1);
6883     } CALL_CATCH_EXCEPTION(0);
6884   }
6885
6886   jresult = (void *)result;
6887   return jresult;
6888 }
6889
6890
6891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
6892   void * jresult ;
6893   Dali::Degree arg1 ;
6894   Dali::Degree *argp1 ;
6895   Dali::Radian *result = 0 ;
6896
6897   argp1 = (Dali::Degree *)jarg1;
6898   if (!argp1) {
6899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
6900     return 0;
6901   }
6902   arg1 = *argp1;
6903   {
6904     try {
6905       result = (Dali::Radian *)new Dali::Radian(arg1);
6906     } CALL_CATCH_EXCEPTION(0);
6907   }
6908
6909   jresult = (void *)result;
6910   return jresult;
6911 }
6912
6913
6914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
6915   void * jresult ;
6916   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
6917   float arg2 ;
6918   Dali::Radian *result = 0 ;
6919
6920   arg1 = (Dali::Radian *)jarg1;
6921   arg2 = (float)jarg2;
6922   {
6923     try {
6924       result = (Dali::Radian *) &(arg1)->operator =(arg2);
6925     } CALL_CATCH_EXCEPTION(0);
6926   }
6927
6928   jresult = (void *)result;
6929   return jresult;
6930 }
6931
6932
6933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
6934   void * jresult ;
6935   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
6936   Dali::Degree arg2 ;
6937   Dali::Degree *argp2 ;
6938   Dali::Radian *result = 0 ;
6939
6940   arg1 = (Dali::Radian *)jarg1;
6941   argp2 = (Dali::Degree *)jarg2;
6942   if (!argp2) {
6943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
6944     return 0;
6945   }
6946   arg2 = *argp2;
6947   {
6948     try {
6949       result = (Dali::Radian *) &(arg1)->operator =(arg2);
6950     } CALL_CATCH_EXCEPTION(0);
6951   }
6952
6953   jresult = (void *)result;
6954   return jresult;
6955 }
6956
6957
6958 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
6959   float jresult ;
6960   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
6961   float result;
6962
6963   arg1 = (Dali::Radian *)jarg1;
6964   {
6965     try {
6966       result = (float)((Dali::Radian const *)arg1)->operator float();
6967     } CALL_CATCH_EXCEPTION(0);
6968   }
6969
6970   jresult = result;
6971   return jresult;
6972 }
6973
6974
6975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
6976   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
6977   float arg2 ;
6978
6979   arg1 = (Dali::Radian *)jarg1;
6980   arg2 = (float)jarg2;
6981   if (arg1) (arg1)->radian = arg2;
6982 }
6983
6984
6985 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
6986   float jresult ;
6987   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
6988   float result;
6989
6990   arg1 = (Dali::Radian *)jarg1;
6991   result = (float) ((arg1)->radian);
6992   jresult = result;
6993   return jresult;
6994 }
6995
6996
6997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
6998   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
6999
7000   arg1 = (Dali::Radian *)jarg1;
7001   {
7002     try {
7003       delete arg1;
7004     } CALL_CATCH_EXCEPTION();
7005   }
7006
7007 }
7008
7009
7010 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
7011   bool jresult ;
7012   Dali::Radian arg1 ;
7013   Dali::Radian arg2 ;
7014   Dali::Radian *argp1 ;
7015   Dali::Radian *argp2 ;
7016   bool result;
7017
7018   argp1 = (Dali::Radian *)jarg1;
7019   if (!argp1) {
7020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7021     return 0;
7022   }
7023   arg1 = *argp1;
7024   argp2 = (Dali::Radian *)jarg2;
7025   if (!argp2) {
7026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7027     return 0;
7028   }
7029   arg2 = *argp2;
7030   {
7031     try {
7032       result = (bool)Dali::operator ==(arg1,arg2);
7033     } CALL_CATCH_EXCEPTION(0);
7034   }
7035
7036   jresult = result;
7037   return jresult;
7038 }
7039
7040
7041 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
7042   bool jresult ;
7043   Dali::Radian arg1 ;
7044   Dali::Radian arg2 ;
7045   Dali::Radian *argp1 ;
7046   Dali::Radian *argp2 ;
7047   bool result;
7048
7049   argp1 = (Dali::Radian *)jarg1;
7050   if (!argp1) {
7051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7052     return 0;
7053   }
7054   arg1 = *argp1;
7055   argp2 = (Dali::Radian *)jarg2;
7056   if (!argp2) {
7057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7058     return 0;
7059   }
7060   arg2 = *argp2;
7061   {
7062     try {
7063       result = (bool)Dali::operator !=(arg1,arg2);
7064     } CALL_CATCH_EXCEPTION(0);
7065   }
7066
7067   jresult = result;
7068   return jresult;
7069 }
7070
7071
7072 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
7073   bool jresult ;
7074   Dali::Radian arg1 ;
7075   Dali::Degree arg2 ;
7076   Dali::Radian *argp1 ;
7077   Dali::Degree *argp2 ;
7078   bool result;
7079
7080   argp1 = (Dali::Radian *)jarg1;
7081   if (!argp1) {
7082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7083     return 0;
7084   }
7085   arg1 = *argp1;
7086   argp2 = (Dali::Degree *)jarg2;
7087   if (!argp2) {
7088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7089     return 0;
7090   }
7091   arg2 = *argp2;
7092   {
7093     try {
7094       result = (bool)Dali::operator ==(arg1,arg2);
7095     } CALL_CATCH_EXCEPTION(0);
7096   }
7097
7098   jresult = result;
7099   return jresult;
7100 }
7101
7102
7103 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
7104   bool jresult ;
7105   Dali::Radian arg1 ;
7106   Dali::Degree arg2 ;
7107   Dali::Radian *argp1 ;
7108   Dali::Degree *argp2 ;
7109   bool result;
7110
7111   argp1 = (Dali::Radian *)jarg1;
7112   if (!argp1) {
7113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7114     return 0;
7115   }
7116   arg1 = *argp1;
7117   argp2 = (Dali::Degree *)jarg2;
7118   if (!argp2) {
7119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7120     return 0;
7121   }
7122   arg2 = *argp2;
7123   {
7124     try {
7125       result = (bool)Dali::operator !=(arg1,arg2);
7126     } CALL_CATCH_EXCEPTION(0);
7127   }
7128
7129   jresult = result;
7130   return jresult;
7131 }
7132
7133
7134 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
7135   bool jresult ;
7136   Dali::Degree arg1 ;
7137   Dali::Radian arg2 ;
7138   Dali::Degree *argp1 ;
7139   Dali::Radian *argp2 ;
7140   bool result;
7141
7142   argp1 = (Dali::Degree *)jarg1;
7143   if (!argp1) {
7144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7145     return 0;
7146   }
7147   arg1 = *argp1;
7148   argp2 = (Dali::Radian *)jarg2;
7149   if (!argp2) {
7150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7151     return 0;
7152   }
7153   arg2 = *argp2;
7154   {
7155     try {
7156       result = (bool)Dali::operator ==(arg1,arg2);
7157     } CALL_CATCH_EXCEPTION(0);
7158   }
7159
7160   jresult = result;
7161   return jresult;
7162 }
7163
7164
7165 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
7166   bool jresult ;
7167   Dali::Degree arg1 ;
7168   Dali::Radian arg2 ;
7169   Dali::Degree *argp1 ;
7170   Dali::Radian *argp2 ;
7171   bool result;
7172
7173   argp1 = (Dali::Degree *)jarg1;
7174   if (!argp1) {
7175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7176     return 0;
7177   }
7178   arg1 = *argp1;
7179   argp2 = (Dali::Radian *)jarg2;
7180   if (!argp2) {
7181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7182     return 0;
7183   }
7184   arg2 = *argp2;
7185   {
7186     try {
7187       result = (bool)Dali::operator !=(arg1,arg2);
7188     } CALL_CATCH_EXCEPTION(0);
7189   }
7190
7191   jresult = result;
7192   return jresult;
7193 }
7194
7195
7196 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
7197   bool jresult ;
7198   Dali::Radian arg1 ;
7199   Dali::Radian arg2 ;
7200   Dali::Radian *argp1 ;
7201   Dali::Radian *argp2 ;
7202   bool result;
7203
7204   argp1 = (Dali::Radian *)jarg1;
7205   if (!argp1) {
7206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7207     return 0;
7208   }
7209   arg1 = *argp1;
7210   argp2 = (Dali::Radian *)jarg2;
7211   if (!argp2) {
7212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7213     return 0;
7214   }
7215   arg2 = *argp2;
7216   {
7217     try {
7218       result = (bool)Dali::operator >(arg1,arg2);
7219     } CALL_CATCH_EXCEPTION(0);
7220   }
7221
7222   jresult = result;
7223   return jresult;
7224 }
7225
7226
7227 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
7228   bool jresult ;
7229   Dali::Radian arg1 ;
7230   Dali::Degree arg2 ;
7231   Dali::Radian *argp1 ;
7232   Dali::Degree *argp2 ;
7233   bool result;
7234
7235   argp1 = (Dali::Radian *)jarg1;
7236   if (!argp1) {
7237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7238     return 0;
7239   }
7240   arg1 = *argp1;
7241   argp2 = (Dali::Degree *)jarg2;
7242   if (!argp2) {
7243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7244     return 0;
7245   }
7246   arg2 = *argp2;
7247   {
7248     try {
7249       result = (bool)Dali::operator >(arg1,arg2);
7250     } CALL_CATCH_EXCEPTION(0);
7251   }
7252
7253   jresult = result;
7254   return jresult;
7255 }
7256
7257
7258 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
7259   bool jresult ;
7260   Dali::Degree arg1 ;
7261   Dali::Radian arg2 ;
7262   Dali::Degree *argp1 ;
7263   Dali::Radian *argp2 ;
7264   bool result;
7265
7266   argp1 = (Dali::Degree *)jarg1;
7267   if (!argp1) {
7268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7269     return 0;
7270   }
7271   arg1 = *argp1;
7272   argp2 = (Dali::Radian *)jarg2;
7273   if (!argp2) {
7274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7275     return 0;
7276   }
7277   arg2 = *argp2;
7278   {
7279     try {
7280       result = (bool)Dali::operator >(arg1,arg2);
7281     } CALL_CATCH_EXCEPTION(0);
7282   }
7283
7284   jresult = result;
7285   return jresult;
7286 }
7287
7288
7289 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
7290   bool jresult ;
7291   Dali::Radian arg1 ;
7292   Dali::Radian arg2 ;
7293   Dali::Radian *argp1 ;
7294   Dali::Radian *argp2 ;
7295   bool result;
7296
7297   argp1 = (Dali::Radian *)jarg1;
7298   if (!argp1) {
7299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7300     return 0;
7301   }
7302   arg1 = *argp1;
7303   argp2 = (Dali::Radian *)jarg2;
7304   if (!argp2) {
7305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7306     return 0;
7307   }
7308   arg2 = *argp2;
7309   {
7310     try {
7311       result = (bool)Dali::operator <(arg1,arg2);
7312     } CALL_CATCH_EXCEPTION(0);
7313   }
7314
7315   jresult = result;
7316   return jresult;
7317 }
7318
7319
7320 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
7321   bool jresult ;
7322   Dali::Radian arg1 ;
7323   Dali::Degree arg2 ;
7324   Dali::Radian *argp1 ;
7325   Dali::Degree *argp2 ;
7326   bool result;
7327
7328   argp1 = (Dali::Radian *)jarg1;
7329   if (!argp1) {
7330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7331     return 0;
7332   }
7333   arg1 = *argp1;
7334   argp2 = (Dali::Degree *)jarg2;
7335   if (!argp2) {
7336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7337     return 0;
7338   }
7339   arg2 = *argp2;
7340   {
7341     try {
7342       result = (bool)Dali::operator <(arg1,arg2);
7343     } CALL_CATCH_EXCEPTION(0);
7344   }
7345
7346   jresult = result;
7347   return jresult;
7348 }
7349
7350
7351 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
7352   bool jresult ;
7353   Dali::Degree arg1 ;
7354   Dali::Radian arg2 ;
7355   Dali::Degree *argp1 ;
7356   Dali::Radian *argp2 ;
7357   bool result;
7358
7359   argp1 = (Dali::Degree *)jarg1;
7360   if (!argp1) {
7361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7362     return 0;
7363   }
7364   arg1 = *argp1;
7365   argp2 = (Dali::Radian *)jarg2;
7366   if (!argp2) {
7367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7368     return 0;
7369   }
7370   arg2 = *argp2;
7371   {
7372     try {
7373       result = (bool)Dali::operator <(arg1,arg2);
7374     } CALL_CATCH_EXCEPTION(0);
7375   }
7376
7377   jresult = result;
7378   return jresult;
7379 }
7380
7381
7382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
7383   void * jresult ;
7384   Dali::Radian arg1 ;
7385   float arg2 ;
7386   Dali::Radian *argp1 ;
7387   Dali::Radian result;
7388
7389   argp1 = (Dali::Radian *)jarg1;
7390   if (!argp1) {
7391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7392     return 0;
7393   }
7394   arg1 = *argp1;
7395   arg2 = (float)jarg2;
7396   {
7397     try {
7398       result = Dali::operator *(arg1,arg2);
7399     } CALL_CATCH_EXCEPTION(0);
7400   }
7401
7402   jresult = new Dali::Radian((const Dali::Radian &)result);
7403   return jresult;
7404 }
7405
7406
7407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
7408   void * jresult ;
7409   Dali::Radian arg1 ;
7410   Dali::Radian *argp1 ;
7411   Dali::Radian result;
7412
7413   argp1 = (Dali::Radian *)jarg1;
7414   if (!argp1) {
7415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7416     return 0;
7417   }
7418   arg1 = *argp1;
7419   {
7420     try {
7421       result = Dali::operator -(arg1);
7422     } CALL_CATCH_EXCEPTION(0);
7423   }
7424
7425   jresult = new Dali::Radian((const Dali::Radian &)result);
7426   return jresult;
7427 }
7428
7429
7430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
7431   void * jresult ;
7432   Dali::Radian arg1 ;
7433   float arg2 ;
7434   float arg3 ;
7435   Dali::Radian *argp1 ;
7436   Dali::Radian result;
7437
7438   argp1 = (Dali::Radian *)jarg1;
7439   if (!argp1) {
7440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7441     return 0;
7442   }
7443   arg1 = *argp1;
7444   arg2 = (float)jarg2;
7445   arg3 = (float)jarg3;
7446   {
7447     try {
7448       result = Dali::Clamp(arg1,arg2,arg3);
7449     } CALL_CATCH_EXCEPTION(0);
7450   }
7451
7452   jresult = new Dali::Radian((const Dali::Radian &)result);
7453   return jresult;
7454 }
7455
7456
7457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
7458   void * jresult ;
7459   Dali::Matrix *result = 0 ;
7460
7461   {
7462     try {
7463       result = (Dali::Matrix *)new Dali::Matrix();
7464     } CALL_CATCH_EXCEPTION(0);
7465   }
7466
7467   jresult = (void *)result;
7468   return jresult;
7469 }
7470
7471
7472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(bool jarg1) {
7473   void * jresult ;
7474   bool arg1 ;
7475   Dali::Matrix *result = 0 ;
7476
7477   arg1 = jarg1 ? true : false;
7478   {
7479     try {
7480       result = (Dali::Matrix *)new Dali::Matrix(arg1);
7481     } CALL_CATCH_EXCEPTION(0);
7482   }
7483
7484   jresult = (void *)result;
7485   return jresult;
7486 }
7487
7488
7489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
7490   void * jresult ;
7491   float *arg1 = (float *) 0 ;
7492   Dali::Matrix *result = 0 ;
7493
7494   arg1 = jarg1;
7495   {
7496     try {
7497       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
7498     } CALL_CATCH_EXCEPTION(0);
7499   }
7500
7501   jresult = (void *)result;
7502
7503
7504   return jresult;
7505 }
7506
7507
7508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
7509   void * jresult ;
7510   Dali::Quaternion *arg1 = 0 ;
7511   Dali::Matrix *result = 0 ;
7512
7513   arg1 = (Dali::Quaternion *)jarg1;
7514   if (!arg1) {
7515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7516     return 0;
7517   }
7518   {
7519     try {
7520       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
7521     } CALL_CATCH_EXCEPTION(0);
7522   }
7523
7524   jresult = (void *)result;
7525   return jresult;
7526 }
7527
7528
7529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
7530   void * jresult ;
7531   Dali::Matrix *arg1 = 0 ;
7532   Dali::Matrix *result = 0 ;
7533
7534   arg1 = (Dali::Matrix *)jarg1;
7535   if (!arg1) {
7536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7537     return 0;
7538   }
7539   {
7540     try {
7541       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
7542     } CALL_CATCH_EXCEPTION(0);
7543   }
7544
7545   jresult = (void *)result;
7546   return jresult;
7547 }
7548
7549
7550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
7551   void * jresult ;
7552   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7553   Dali::Matrix *arg2 = 0 ;
7554   Dali::Matrix *result = 0 ;
7555
7556   arg1 = (Dali::Matrix *)jarg1;
7557   arg2 = (Dali::Matrix *)jarg2;
7558   if (!arg2) {
7559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7560     return 0;
7561   }
7562   {
7563     try {
7564       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
7565     } CALL_CATCH_EXCEPTION(0);
7566   }
7567
7568   jresult = (void *)result;
7569   return jresult;
7570 }
7571
7572
7573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
7574   void * jresult ;
7575   Dali::Matrix *result = 0 ;
7576
7577   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
7578   jresult = (void *)result;
7579   return jresult;
7580 }
7581
7582
7583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
7584   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7585
7586   arg1 = (Dali::Matrix *)jarg1;
7587   {
7588     try {
7589       (arg1)->SetIdentity();
7590     } CALL_CATCH_EXCEPTION();
7591   }
7592
7593 }
7594
7595
7596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
7597   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7598   Dali::Vector3 *arg2 = 0 ;
7599
7600   arg1 = (Dali::Matrix *)jarg1;
7601   arg2 = (Dali::Vector3 *)jarg2;
7602   if (!arg2) {
7603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7604     return ;
7605   }
7606   {
7607     try {
7608       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
7609     } CALL_CATCH_EXCEPTION();
7610   }
7611
7612 }
7613
7614
7615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
7616   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7617   Dali::Matrix *arg2 = 0 ;
7618
7619   arg1 = (Dali::Matrix *)jarg1;
7620   arg2 = (Dali::Matrix *)jarg2;
7621   if (!arg2) {
7622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
7623     return ;
7624   }
7625   {
7626     try {
7627       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
7628     } CALL_CATCH_EXCEPTION();
7629   }
7630
7631 }
7632
7633
7634 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
7635   bool jresult ;
7636   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7637   bool result;
7638
7639   arg1 = (Dali::Matrix *)jarg1;
7640   {
7641     try {
7642       result = (bool)(arg1)->Invert();
7643     } CALL_CATCH_EXCEPTION(0);
7644   }
7645
7646   jresult = result;
7647   return jresult;
7648 }
7649
7650
7651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
7652   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7653
7654   arg1 = (Dali::Matrix *)jarg1;
7655   {
7656     try {
7657       (arg1)->Transpose();
7658     } CALL_CATCH_EXCEPTION();
7659   }
7660
7661 }
7662
7663
7664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
7665   void * jresult ;
7666   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7667   Dali::Vector3 result;
7668
7669   arg1 = (Dali::Matrix *)jarg1;
7670   {
7671     try {
7672       result = ((Dali::Matrix const *)arg1)->GetXAxis();
7673     } CALL_CATCH_EXCEPTION(0);
7674   }
7675
7676   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7677   return jresult;
7678 }
7679
7680
7681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
7682   void * jresult ;
7683   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7684   Dali::Vector3 result;
7685
7686   arg1 = (Dali::Matrix *)jarg1;
7687   {
7688     try {
7689       result = ((Dali::Matrix const *)arg1)->GetYAxis();
7690     } CALL_CATCH_EXCEPTION(0);
7691   }
7692
7693   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7694   return jresult;
7695 }
7696
7697
7698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
7699   void * jresult ;
7700   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7701   Dali::Vector3 result;
7702
7703   arg1 = (Dali::Matrix *)jarg1;
7704   {
7705     try {
7706       result = ((Dali::Matrix const *)arg1)->GetZAxis();
7707     } CALL_CATCH_EXCEPTION(0);
7708   }
7709
7710   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7711   return jresult;
7712 }
7713
7714
7715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
7716   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7717   Dali::Vector3 *arg2 = 0 ;
7718
7719   arg1 = (Dali::Matrix *)jarg1;
7720   arg2 = (Dali::Vector3 *)jarg2;
7721   if (!arg2) {
7722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7723     return ;
7724   }
7725   {
7726     try {
7727       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
7728     } CALL_CATCH_EXCEPTION();
7729   }
7730
7731 }
7732
7733
7734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
7735   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7736   Dali::Vector3 *arg2 = 0 ;
7737
7738   arg1 = (Dali::Matrix *)jarg1;
7739   arg2 = (Dali::Vector3 *)jarg2;
7740   if (!arg2) {
7741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7742     return ;
7743   }
7744   {
7745     try {
7746       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
7747     } CALL_CATCH_EXCEPTION();
7748   }
7749
7750 }
7751
7752
7753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(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)->SetZAxis((Dali::Vector3 const &)*arg2);
7766     } CALL_CATCH_EXCEPTION();
7767   }
7768
7769 }
7770
7771
7772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
7773   void * jresult ;
7774   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7775   Dali::Vector4 *result = 0 ;
7776
7777   arg1 = (Dali::Matrix *)jarg1;
7778   {
7779     try {
7780       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
7781     } CALL_CATCH_EXCEPTION(0);
7782   }
7783
7784   jresult = (void *)result;
7785   return jresult;
7786 }
7787
7788
7789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
7790   void * jresult ;
7791   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7792   Dali::Vector3 *result = 0 ;
7793
7794   arg1 = (Dali::Matrix *)jarg1;
7795   {
7796     try {
7797       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
7798     } CALL_CATCH_EXCEPTION(0);
7799   }
7800
7801   jresult = (void *)result;
7802   return jresult;
7803 }
7804
7805
7806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
7807   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7808   Dali::Vector4 *arg2 = 0 ;
7809
7810   arg1 = (Dali::Matrix *)jarg1;
7811   arg2 = (Dali::Vector4 *)jarg2;
7812   if (!arg2) {
7813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7814     return ;
7815   }
7816   {
7817     try {
7818       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
7819     } CALL_CATCH_EXCEPTION();
7820   }
7821
7822 }
7823
7824
7825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
7826   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7827   Dali::Vector3 *arg2 = 0 ;
7828
7829   arg1 = (Dali::Matrix *)jarg1;
7830   arg2 = (Dali::Vector3 *)jarg2;
7831   if (!arg2) {
7832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7833     return ;
7834   }
7835   {
7836     try {
7837       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
7838     } CALL_CATCH_EXCEPTION();
7839   }
7840
7841 }
7842
7843
7844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
7845   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7846
7847   arg1 = (Dali::Matrix *)jarg1;
7848   {
7849     try {
7850       (arg1)->OrthoNormalize();
7851     } CALL_CATCH_EXCEPTION();
7852   }
7853
7854 }
7855
7856
7857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
7858   void * jresult ;
7859   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7860   float *result = 0 ;
7861
7862   arg1 = (Dali::Matrix *)jarg1;
7863   {
7864     try {
7865       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
7866     } CALL_CATCH_EXCEPTION(0);
7867   }
7868
7869   jresult = (void *)result;
7870   return jresult;
7871 }
7872
7873
7874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
7875   Dali::Matrix *arg1 = 0 ;
7876   Dali::Matrix *arg2 = 0 ;
7877   Dali::Matrix *arg3 = 0 ;
7878
7879   arg1 = (Dali::Matrix *)jarg1;
7880   if (!arg1) {
7881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
7882     return ;
7883   }
7884   arg2 = (Dali::Matrix *)jarg2;
7885   if (!arg2) {
7886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7887     return ;
7888   }
7889   arg3 = (Dali::Matrix *)jarg3;
7890   if (!arg3) {
7891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7892     return ;
7893   }
7894   {
7895     try {
7896       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
7897     } CALL_CATCH_EXCEPTION();
7898   }
7899
7900 }
7901
7902
7903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
7904   Dali::Matrix *arg1 = 0 ;
7905   Dali::Matrix *arg2 = 0 ;
7906   Dali::Quaternion *arg3 = 0 ;
7907
7908   arg1 = (Dali::Matrix *)jarg1;
7909   if (!arg1) {
7910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
7911     return ;
7912   }
7913   arg2 = (Dali::Matrix *)jarg2;
7914   if (!arg2) {
7915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7916     return ;
7917   }
7918   arg3 = (Dali::Quaternion *)jarg3;
7919   if (!arg3) {
7920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7921     return ;
7922   }
7923   {
7924     try {
7925       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
7926     } CALL_CATCH_EXCEPTION();
7927   }
7928
7929 }
7930
7931
7932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
7933   void * jresult ;
7934   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7935   Dali::Vector4 *arg2 = 0 ;
7936   Dali::Vector4 result;
7937
7938   arg1 = (Dali::Matrix *)jarg1;
7939   if (!arg1) {
7940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7941     return 0;
7942   }
7943   arg2 = (Dali::Vector4 *)jarg2;
7944   if (!arg2) {
7945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7946     return 0;
7947   }
7948   {
7949     try {
7950       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7951     } CALL_CATCH_EXCEPTION(0);
7952   }
7953
7954   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7955   return jresult;
7956 }
7957
7958
7959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_3(void * nuiMatrixLhs, void * nuiMatrixRhs) {
7960   void * jresult ;
7961   Dali::Matrix *lhsPtr = (Dali::Matrix *) 0 ;
7962   Dali::Matrix *rhsPtr = (Dali::Matrix *) 0 ;
7963   Dali::Matrix result(false);
7964
7965   lhsPtr = (Dali::Matrix *)nuiMatrixLhs;
7966   if (!lhsPtr) {
7967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix const & type is null", 0);
7968     return 0;
7969   }
7970   rhsPtr = (Dali::Matrix *)nuiMatrixRhs;
7971   if (!rhsPtr) {
7972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix const & type is null", 0);
7973     return 0;
7974   }
7975   {
7976     try {
7977       result = ((Dali::Matrix const *)lhsPtr)->operator *((Dali::Matrix const &)*rhsPtr);
7978     } CALL_CATCH_EXCEPTION(0);
7979   }
7980
7981   jresult = new Dali::Matrix((const Dali::Matrix &)result);
7982   return jresult;
7983 }
7984
7985
7986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_4(void * nuiMatrixLhs, void * nuiMatrixRhs) {
7987   // Faster mulitply operation without memcpy
7988
7989   Dali::Matrix *jresult = (Dali::Matrix *)0;
7990   Dali::Matrix *lhsPtr  = (Dali::Matrix *)0;
7991   Dali::Matrix *rhsPtr  = (Dali::Matrix *)0;
7992
7993   lhsPtr = (Dali::Matrix *)nuiMatrixLhs;
7994   if (!lhsPtr) {
7995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix const & type is null", 0);
7996     return 0;
7997   }
7998   rhsPtr = (Dali::Matrix *)nuiMatrixRhs;
7999   if (!rhsPtr) {
8000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix const & type is null", 0);
8001     return 0;
8002   }
8003   {
8004     try {
8005       jresult = new Dali::Matrix(false);
8006       Dali::Matrix::Multiply((Dali::Matrix &)*jresult,(Dali::Matrix const &)*rhsPtr,(Dali::Matrix const &)*lhsPtr);
8007     } CALL_CATCH_EXCEPTION(0);
8008   }
8009
8010   return jresult;
8011 }
8012
8013
8014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_MultiplyAssign(void * nuiMatrix, void * nuiMatrixRhs) {
8015   void * jresult = 0;
8016   Dali::Matrix *lhsPtr = (Dali::Matrix *) 0 ;
8017   Dali::Matrix *rhsPtr = (Dali::Matrix *) 0 ;
8018   Dali::Matrix *retPtr = (Dali::Matrix *) 0 ;
8019
8020   lhsPtr = (Dali::Matrix *)nuiMatrix;
8021   if (!lhsPtr) {
8022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix const & type is null", 0);
8023     return 0;
8024   }
8025   rhsPtr = (Dali::Matrix *)nuiMatrixRhs;
8026   if (!rhsPtr) {
8027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix const & type is null", 0);
8028     return 0;
8029   }
8030   {
8031     try {
8032       retPtr = (Dali::Matrix *) &(lhsPtr)->operator *=((Dali::Matrix const &)*rhsPtr);
8033     } CALL_CATCH_EXCEPTION(0);
8034   }
8035
8036   jresult = (void *)retPtr;
8037   return jresult;
8038 }
8039
8040
8041 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
8042   bool jresult ;
8043   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8044   Dali::Matrix *arg2 = 0 ;
8045   bool result;
8046
8047   arg1 = (Dali::Matrix *)jarg1;
8048   arg2 = (Dali::Matrix *)jarg2;
8049   if (!arg2) {
8050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8051     return 0;
8052   }
8053   {
8054     try {
8055       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
8056     } CALL_CATCH_EXCEPTION(0);
8057   }
8058
8059   jresult = result;
8060   return jresult;
8061 }
8062
8063
8064 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
8065   bool jresult ;
8066   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8067   Dali::Matrix *arg2 = 0 ;
8068   bool result;
8069
8070   arg1 = (Dali::Matrix *)jarg1;
8071   arg2 = (Dali::Matrix *)jarg2;
8072   if (!arg2) {
8073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8074     return 0;
8075   }
8076   {
8077     try {
8078       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
8079     } CALL_CATCH_EXCEPTION(0);
8080   }
8081
8082   jresult = result;
8083   return jresult;
8084 }
8085
8086 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix_ValueOfIndex__SWIG_0(void * nuiMatrix, unsigned int index) {
8087   float jresult ;
8088   Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ;
8089
8090   pMatrix = (Dali::Matrix *)nuiMatrix;
8091   if (!pMatrix) {
8092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8093     return 0;
8094   }
8095   if (index >= 16) {
8096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 16.)", 0);
8097     return 0;
8098   }
8099   {
8100     try {
8101       const float* temp = ((Dali::Matrix const *)pMatrix)->AsFloat();
8102       jresult = temp[index];
8103     } CALL_CATCH_EXCEPTION(0);
8104   }
8105   return jresult;
8106 }
8107
8108 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix_ValueOfIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn) {
8109   float jresult ;
8110   Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ;
8111
8112   pMatrix = (Dali::Matrix *)nuiMatrix;
8113   if (!pMatrix) {
8114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8115     return 0;
8116   }
8117   if (indexRow >= 4) {
8118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 4.)", 0);
8119     return 0;
8120   }
8121   if (indexColumn >= 4) {
8122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 4.)", 0);
8123     return 0;
8124   }
8125   {
8126     try {
8127       const float* temp = ((Dali::Matrix const *)pMatrix)->AsFloat();
8128       jresult = temp[(indexColumn << 2) | indexRow];
8129     } CALL_CATCH_EXCEPTION(0);
8130   }
8131   return jresult;
8132 }
8133
8134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetValueAtIndex__SWIG_0(void * nuiMatrix, unsigned int index, float value) {
8135   Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ;
8136
8137   pMatrix = (Dali::Matrix *)nuiMatrix;
8138   if (!pMatrix) {
8139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8140     return;
8141   }
8142   if (index >= 16) {
8143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 16.)", 0);
8144     return;
8145   }
8146   {
8147     try {
8148       float* temp = ((Dali::Matrix *)pMatrix)->AsFloat();
8149       temp[index] = value;
8150     } CALL_CATCH_EXCEPTION();
8151   }
8152 }
8153
8154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetValueAtIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn, float value) {
8155   Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ;
8156
8157   pMatrix = (Dali::Matrix *)nuiMatrix;
8158   if (!pMatrix) {
8159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8160     return;
8161   }
8162   if (indexRow >= 4) {
8163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 4.)", 0);
8164     return;
8165   }
8166   if (indexColumn >= 4) {
8167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 4.)", 0);
8168     return;
8169   }
8170   {
8171     try {
8172       float* temp = ((Dali::Matrix *)pMatrix)->AsFloat();
8173       temp[(indexColumn << 2) | indexRow] = value;
8174     } CALL_CATCH_EXCEPTION();
8175   }
8176 }
8177
8178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
8179   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8180   Dali::Vector3 *arg2 = 0 ;
8181   Dali::Quaternion *arg3 = 0 ;
8182   Dali::Vector3 *arg4 = 0 ;
8183
8184   arg1 = (Dali::Matrix *)jarg1;
8185   arg2 = (Dali::Vector3 *)jarg2;
8186   if (!arg2) {
8187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8188     return ;
8189   }
8190   arg3 = (Dali::Quaternion *)jarg3;
8191   if (!arg3) {
8192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8193     return ;
8194   }
8195   arg4 = (Dali::Vector3 *)jarg4;
8196   if (!arg4) {
8197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8198     return ;
8199   }
8200   {
8201     try {
8202       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
8203     } CALL_CATCH_EXCEPTION();
8204   }
8205
8206 }
8207
8208
8209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
8210   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8211   Dali::Vector3 *arg2 = 0 ;
8212   Dali::Quaternion *arg3 = 0 ;
8213   Dali::Vector3 *arg4 = 0 ;
8214
8215   arg1 = (Dali::Matrix *)jarg1;
8216   arg2 = (Dali::Vector3 *)jarg2;
8217   if (!arg2) {
8218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8219     return ;
8220   }
8221   arg3 = (Dali::Quaternion *)jarg3;
8222   if (!arg3) {
8223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8224     return ;
8225   }
8226   arg4 = (Dali::Vector3 *)jarg4;
8227   if (!arg4) {
8228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8229     return ;
8230   }
8231   {
8232     try {
8233       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
8234     } CALL_CATCH_EXCEPTION();
8235   }
8236
8237 }
8238
8239
8240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
8241   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8242   Dali::Vector3 *arg2 = 0 ;
8243   Dali::Vector3 *arg3 = 0 ;
8244   Dali::Vector3 *arg4 = 0 ;
8245   Dali::Vector3 *arg5 = 0 ;
8246
8247   arg1 = (Dali::Matrix *)jarg1;
8248   arg2 = (Dali::Vector3 *)jarg2;
8249   if (!arg2) {
8250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8251     return ;
8252   }
8253   arg3 = (Dali::Vector3 *)jarg3;
8254   if (!arg3) {
8255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8256     return ;
8257   }
8258   arg4 = (Dali::Vector3 *)jarg4;
8259   if (!arg4) {
8260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8261     return ;
8262   }
8263   arg5 = (Dali::Vector3 *)jarg5;
8264   if (!arg5) {
8265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8266     return ;
8267   }
8268   {
8269     try {
8270       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
8271     } CALL_CATCH_EXCEPTION();
8272   }
8273
8274 }
8275
8276
8277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
8278   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8279   Dali::Vector3 *arg2 = 0 ;
8280   Dali::Quaternion *arg3 = 0 ;
8281   Dali::Vector3 *arg4 = 0 ;
8282
8283   arg1 = (Dali::Matrix *)jarg1;
8284   arg2 = (Dali::Vector3 *)jarg2;
8285   if (!arg2) {
8286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
8287     return ;
8288   }
8289   arg3 = (Dali::Quaternion *)jarg3;
8290   if (!arg3) {
8291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
8292     return ;
8293   }
8294   arg4 = (Dali::Vector3 *)jarg4;
8295   if (!arg4) {
8296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
8297     return ;
8298   }
8299   {
8300     try {
8301       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
8302     } CALL_CATCH_EXCEPTION();
8303   }
8304
8305 }
8306
8307
8308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
8309   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8310
8311   arg1 = (Dali::Matrix *)jarg1;
8312   {
8313     try {
8314       delete arg1;
8315     } CALL_CATCH_EXCEPTION();
8316   }
8317
8318 }
8319
8320
8321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
8322   void * jresult ;
8323   Dali::Matrix3 *result = 0 ;
8324
8325   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
8326   jresult = (void *)result;
8327   return jresult;
8328 }
8329
8330
8331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
8332   void * jresult ;
8333   Dali::Matrix3 *result = 0 ;
8334
8335   {
8336     try {
8337       result = (Dali::Matrix3 *)new Dali::Matrix3();
8338     } CALL_CATCH_EXCEPTION(0);
8339   }
8340
8341   jresult = (void *)result;
8342   return jresult;
8343 }
8344
8345
8346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
8347   void * jresult ;
8348   Dali::Matrix3 *arg1 = 0 ;
8349   Dali::Matrix3 *result = 0 ;
8350
8351   arg1 = (Dali::Matrix3 *)jarg1;
8352   if (!arg1) {
8353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8354     return 0;
8355   }
8356   {
8357     try {
8358       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
8359     } CALL_CATCH_EXCEPTION(0);
8360   }
8361
8362   jresult = (void *)result;
8363   return jresult;
8364 }
8365
8366
8367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
8368   void * jresult ;
8369   Dali::Matrix *arg1 = 0 ;
8370   Dali::Matrix3 *result = 0 ;
8371
8372   arg1 = (Dali::Matrix *)jarg1;
8373   if (!arg1) {
8374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8375     return 0;
8376   }
8377   {
8378     try {
8379       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
8380     } CALL_CATCH_EXCEPTION(0);
8381   }
8382
8383   jresult = (void *)result;
8384   return jresult;
8385 }
8386
8387
8388 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) {
8389   void * jresult ;
8390   float arg1 ;
8391   float arg2 ;
8392   float arg3 ;
8393   float arg4 ;
8394   float arg5 ;
8395   float arg6 ;
8396   float arg7 ;
8397   float arg8 ;
8398   float arg9 ;
8399   Dali::Matrix3 *result = 0 ;
8400
8401   arg1 = (float)jarg1;
8402   arg2 = (float)jarg2;
8403   arg3 = (float)jarg3;
8404   arg4 = (float)jarg4;
8405   arg5 = (float)jarg5;
8406   arg6 = (float)jarg6;
8407   arg7 = (float)jarg7;
8408   arg8 = (float)jarg8;
8409   arg9 = (float)jarg9;
8410   {
8411     try {
8412       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
8413     } CALL_CATCH_EXCEPTION(0);
8414   }
8415
8416   jresult = (void *)result;
8417   return jresult;
8418 }
8419
8420
8421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
8422   void * jresult ;
8423   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8424   Dali::Matrix3 *arg2 = 0 ;
8425   Dali::Matrix3 *result = 0 ;
8426
8427   arg1 = (Dali::Matrix3 *)jarg1;
8428   arg2 = (Dali::Matrix3 *)jarg2;
8429   if (!arg2) {
8430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8431     return 0;
8432   }
8433   {
8434     try {
8435       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
8436     } CALL_CATCH_EXCEPTION(0);
8437   }
8438
8439   jresult = (void *)result;
8440   return jresult;
8441 }
8442
8443
8444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
8445   void * jresult ;
8446   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8447   Dali::Matrix *arg2 = 0 ;
8448   Dali::Matrix3 *result = 0 ;
8449
8450   arg1 = (Dali::Matrix3 *)jarg1;
8451   arg2 = (Dali::Matrix *)jarg2;
8452   if (!arg2) {
8453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8454     return 0;
8455   }
8456   {
8457     try {
8458       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
8459     } CALL_CATCH_EXCEPTION(0);
8460   }
8461
8462   jresult = (void *)result;
8463   return jresult;
8464 }
8465
8466
8467 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
8468   bool jresult ;
8469   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8470   Dali::Matrix3 *arg2 = 0 ;
8471   bool result;
8472
8473   arg1 = (Dali::Matrix3 *)jarg1;
8474   arg2 = (Dali::Matrix3 *)jarg2;
8475   if (!arg2) {
8476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8477     return 0;
8478   }
8479   {
8480     try {
8481       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
8482     } CALL_CATCH_EXCEPTION(0);
8483   }
8484
8485   jresult = result;
8486   return jresult;
8487 }
8488
8489
8490 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
8491   bool jresult ;
8492   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8493   Dali::Matrix3 *arg2 = 0 ;
8494   bool result;
8495
8496   arg1 = (Dali::Matrix3 *)jarg1;
8497   arg2 = (Dali::Matrix3 *)jarg2;
8498   if (!arg2) {
8499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8500     return 0;
8501   }
8502   {
8503     try {
8504       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
8505     } CALL_CATCH_EXCEPTION(0);
8506   }
8507
8508   jresult = result;
8509   return jresult;
8510 }
8511
8512
8513 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_ValueOfIndex__SWIG_0(void * nuiMatrix, unsigned int index) {
8514   float jresult ;
8515   Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ;
8516
8517   pMatrix = (Dali::Matrix3 *)nuiMatrix;
8518   if (!pMatrix) {
8519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8520     return 0;
8521   }
8522   if (index >= 9) {
8523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 9.)", 0);
8524     return 0;
8525   }
8526   {
8527     try {
8528       const float* temp = ((Dali::Matrix3 const *)pMatrix)->AsFloat();
8529       jresult = temp[index];
8530     } CALL_CATCH_EXCEPTION(0);
8531   }
8532   return jresult;
8533 }
8534
8535 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_ValueOfIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn) {
8536   float jresult ;
8537   Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ;
8538
8539   pMatrix = (Dali::Matrix3 *)nuiMatrix;
8540   if (!pMatrix) {
8541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8542     return 0;
8543   }
8544   if (indexRow >= 3) {
8545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 3.)", 0);
8546     return 0;
8547   }
8548   if (indexColumn >= 3) {
8549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 3.)", 0);
8550     return 0;
8551   }
8552   {
8553     try {
8554       const float* temp = ((Dali::Matrix3 const *)pMatrix)->AsFloat();
8555       jresult = temp[indexColumn * 3 + indexRow];
8556     } CALL_CATCH_EXCEPTION(0);
8557   }
8558   return jresult;
8559 }
8560
8561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetValueAtIndex__SWIG_0(void * nuiMatrix, unsigned int index, float value) {
8562   Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ;
8563
8564   pMatrix = (Dali::Matrix3 *)nuiMatrix;
8565   if (!pMatrix) {
8566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8567     return;
8568   }
8569   if (index >= 9) {
8570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 9.)", 0);
8571     return;
8572   }
8573   {
8574     try {
8575       float* temp = ((Dali::Matrix3 *)pMatrix)->AsFloat();
8576       temp[index] = value;
8577     } CALL_CATCH_EXCEPTION();
8578   }
8579 }
8580
8581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetValueAtIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn, float value) {
8582   Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ;
8583
8584   pMatrix = (Dali::Matrix3 *)nuiMatrix;
8585   if (!pMatrix) {
8586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8587     return;
8588   }
8589   if (indexRow >= 3) {
8590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 3.)", 0);
8591     return;
8592   }
8593   if (indexColumn >= 3) {
8594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 3.)", 0);
8595     return;
8596   }
8597   {
8598     try {
8599       float* temp = ((Dali::Matrix3 *)pMatrix)->AsFloat();
8600       temp[indexColumn * 3 + indexRow] = value;
8601     } CALL_CATCH_EXCEPTION();
8602   }
8603 }
8604
8605
8606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
8607   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8608
8609   arg1 = (Dali::Matrix3 *)jarg1;
8610   {
8611     try {
8612       delete arg1;
8613     } CALL_CATCH_EXCEPTION();
8614   }
8615
8616 }
8617
8618
8619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
8620   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8621
8622   arg1 = (Dali::Matrix3 *)jarg1;
8623   {
8624     try {
8625       (arg1)->SetIdentity();
8626     } CALL_CATCH_EXCEPTION();
8627   }
8628
8629 }
8630
8631
8632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
8633   void * jresult ;
8634   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8635   float *result = 0 ;
8636
8637   arg1 = (Dali::Matrix3 *)jarg1;
8638   {
8639     try {
8640       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
8641     } CALL_CATCH_EXCEPTION(0);
8642   }
8643
8644   jresult = (void *)result;
8645   return jresult;
8646 }
8647
8648
8649 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
8650   bool jresult ;
8651   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8652   bool result;
8653
8654   arg1 = (Dali::Matrix3 *)jarg1;
8655   {
8656     try {
8657       result = (bool)(arg1)->Invert();
8658     } CALL_CATCH_EXCEPTION(0);
8659   }
8660
8661   jresult = result;
8662   return jresult;
8663 }
8664
8665
8666 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
8667   bool jresult ;
8668   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8669   bool result;
8670
8671   arg1 = (Dali::Matrix3 *)jarg1;
8672   {
8673     try {
8674       result = (bool)(arg1)->Transpose();
8675     } CALL_CATCH_EXCEPTION(0);
8676   }
8677
8678   jresult = result;
8679   return jresult;
8680 }
8681
8682
8683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
8684   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8685   float arg2 ;
8686
8687   arg1 = (Dali::Matrix3 *)jarg1;
8688   arg2 = (float)jarg2;
8689   {
8690     try {
8691       (arg1)->Scale(arg2);
8692     } CALL_CATCH_EXCEPTION();
8693   }
8694
8695 }
8696
8697
8698 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
8699   float jresult ;
8700   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8701   float result;
8702
8703   arg1 = (Dali::Matrix3 *)jarg1;
8704   {
8705     try {
8706       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
8707     } CALL_CATCH_EXCEPTION(0);
8708   }
8709
8710   jresult = result;
8711   return jresult;
8712 }
8713
8714
8715 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
8716   bool jresult ;
8717   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8718   bool result;
8719
8720   arg1 = (Dali::Matrix3 *)jarg1;
8721   {
8722     try {
8723       result = (bool)(arg1)->ScaledInverseTranspose();
8724     } CALL_CATCH_EXCEPTION(0);
8725   }
8726
8727   jresult = result;
8728   return jresult;
8729 }
8730
8731
8732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
8733   Dali::Matrix3 *arg1 = 0 ;
8734   Dali::Matrix3 *arg2 = 0 ;
8735   Dali::Matrix3 *arg3 = 0 ;
8736
8737   arg1 = (Dali::Matrix3 *)jarg1;
8738   if (!arg1) {
8739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
8740     return ;
8741   }
8742   arg2 = (Dali::Matrix3 *)jarg2;
8743   if (!arg2) {
8744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8745     return ;
8746   }
8747   arg3 = (Dali::Matrix3 *)jarg3;
8748   if (!arg3) {
8749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8750     return ;
8751   }
8752   {
8753     try {
8754       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
8755     } CALL_CATCH_EXCEPTION();
8756   }
8757
8758 }
8759
8760
8761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Multiply__SWIG_1(void * jarg1, void * jarg2) {
8762   void * jresult ;
8763   Dali::Matrix3 *arg1 = 0 ;
8764   Dali::Vector3 *arg2 = 0 ;
8765   Dali::Vector3 result;
8766
8767   arg1 = (Dali::Matrix3 *)jarg1;
8768   if (!arg1) {
8769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8770     return 0;
8771   }
8772   arg2 = (Dali::Vector3 *)jarg2;
8773   if (!arg2) {
8774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8775     return 0;
8776   }
8777   {
8778     try {
8779       result = ((Dali::Matrix3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
8780     } CALL_CATCH_EXCEPTION(0);
8781   }
8782
8783   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
8784   return jresult;
8785 }
8786
8787
8788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Multiply__SWIG_2(void * nuiMatrix3Lhs, void * nuiMatrix3Rhs) {
8789   void * jresult ;
8790   Dali::Matrix3 *lhsPtr = 0 ;
8791   Dali::Matrix3 *rhsPtr = 0 ;
8792   Dali::Matrix3 result;
8793
8794   lhsPtr = (Dali::Matrix3 *)nuiMatrix3Lhs;
8795   if (!lhsPtr) {
8796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix3 const & type is null", 0);
8797     return 0;
8798   }
8799   rhsPtr = (Dali::Matrix3 *)nuiMatrix3Rhs;
8800   if (!rhsPtr) {
8801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix3 const & type is null", 0);
8802     return 0;
8803   }
8804   {
8805     try {
8806       result = ((Dali::Matrix3 const *)lhsPtr)->operator *((Dali::Matrix3 const &)*rhsPtr);
8807     } CALL_CATCH_EXCEPTION(0);
8808   }
8809
8810   jresult = new Dali::Matrix3((const Dali::Matrix3 &)result);
8811   return jresult;
8812 }
8813
8814
8815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Multiply__SWIG_3(void * nuiMatrix3Lhs, void * nuiMatrix3Rhs) {
8816   // Faster mulitply operation without memcpy
8817
8818   Dali::Matrix3 *jresult = 0;
8819   Dali::Matrix3 *lhsPtr  = 0;
8820   Dali::Matrix3 *rhsPtr  = 0;
8821
8822   lhsPtr = (Dali::Matrix3 *)nuiMatrix3Lhs;
8823   if (!lhsPtr) {
8824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix3 const & type is null", 0);
8825     return 0;
8826   }
8827   rhsPtr = (Dali::Matrix3 *)nuiMatrix3Rhs;
8828   if (!rhsPtr) {
8829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix3 const & type is null", 0);
8830     return 0;
8831   }
8832   {
8833     try {
8834       jresult = new Dali::Matrix3();
8835       Dali::Matrix3::Multiply((Dali::Matrix3 &)*jresult,(Dali::Matrix3 const &)*rhsPtr,(Dali::Matrix3 const &)*lhsPtr);
8836     } CALL_CATCH_EXCEPTION(0);
8837   }
8838
8839   return jresult;
8840 }
8841
8842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_MultiplyAssign(void * nuiMatrix, void * nuiMatrixRhs) {
8843   void * jresult = 0;
8844   Dali::Matrix3 *lhsPtr = (Dali::Matrix3 *) 0 ;
8845   Dali::Matrix3 *rhsPtr = (Dali::Matrix3 *) 0 ;
8846   Dali::Matrix3 *retPtr = (Dali::Matrix3 *) 0 ;
8847
8848   lhsPtr = (Dali::Matrix3 *)nuiMatrix;
8849   if (!lhsPtr) {
8850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix3 const & type is null", 0);
8851     return 0;
8852   }
8853   rhsPtr = (Dali::Matrix3 *)nuiMatrixRhs;
8854   if (!rhsPtr) {
8855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix3 const & type is null", 0);
8856     return 0;
8857   }
8858   {
8859     try {
8860       retPtr = (Dali::Matrix3 *) &(lhsPtr)->operator *=((Dali::Matrix3 const &)*rhsPtr);
8861     } CALL_CATCH_EXCEPTION(0);
8862   }
8863
8864   jresult = (void *)retPtr;
8865   return jresult;
8866 }
8867
8868
8869 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
8870   float jresult ;
8871   float arg1 ;
8872   float arg2 ;
8873   float result;
8874
8875   arg1 = (float)jarg1;
8876   arg2 = (float)jarg2;
8877   {
8878     try {
8879       result = (float)Dali::Random::Range(arg1,arg2);
8880     } CALL_CATCH_EXCEPTION(0);
8881   }
8882
8883   jresult = result;
8884   return jresult;
8885 }
8886
8887
8888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
8889   void * jresult ;
8890   Dali::Vector4 result;
8891
8892   {
8893     try {
8894       result = Dali::Random::Axis();
8895     } CALL_CATCH_EXCEPTION(0);
8896   }
8897
8898   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8899   return jresult;
8900 }
8901
8902
8903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
8904   void * jresult ;
8905   Dali::AngleAxis *result = 0 ;
8906
8907   {
8908     try {
8909       result = (Dali::AngleAxis *)new Dali::AngleAxis();
8910     } CALL_CATCH_EXCEPTION(0);
8911   }
8912
8913   jresult = (void *)result;
8914   return jresult;
8915 }
8916
8917
8918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
8919   void * jresult ;
8920   Dali::Radian arg1 ;
8921   Dali::Vector3 *arg2 = 0 ;
8922   Dali::Radian *argp1 ;
8923   Dali::AngleAxis *result = 0 ;
8924
8925   argp1 = (Dali::Radian *)jarg1;
8926   if (!argp1) {
8927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8928     return 0;
8929   }
8930   arg1 = *argp1;
8931   arg2 = (Dali::Vector3 *)jarg2;
8932   if (!arg2) {
8933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8934     return 0;
8935   }
8936   {
8937     try {
8938       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
8939     } CALL_CATCH_EXCEPTION(0);
8940   }
8941
8942   jresult = (void *)result;
8943   return jresult;
8944 }
8945
8946
8947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
8948   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
8949   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
8950
8951   arg1 = (Dali::AngleAxis *)jarg1;
8952   arg2 = (Dali::Radian *)jarg2;
8953   if (arg1) (arg1)->angle = *arg2;
8954 }
8955
8956
8957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
8958   void * jresult ;
8959   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
8960   Dali::Radian *result = 0 ;
8961
8962   arg1 = (Dali::AngleAxis *)jarg1;
8963   result = (Dali::Radian *)& ((arg1)->angle);
8964   jresult = (void *)result;
8965   return jresult;
8966 }
8967
8968
8969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
8970   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
8971   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
8972
8973   arg1 = (Dali::AngleAxis *)jarg1;
8974   arg2 = (Dali::Vector3 *)jarg2;
8975   if (arg1) (arg1)->axis = *arg2;
8976 }
8977
8978
8979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
8980   void * jresult ;
8981   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
8982   Dali::Vector3 *result = 0 ;
8983
8984   arg1 = (Dali::AngleAxis *)jarg1;
8985   result = (Dali::Vector3 *)& ((arg1)->axis);
8986   jresult = (void *)result;
8987   return jresult;
8988 }
8989
8990
8991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
8992   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
8993
8994   arg1 = (Dali::AngleAxis *)jarg1;
8995   {
8996     try {
8997       delete arg1;
8998     } CALL_CATCH_EXCEPTION();
8999   }
9000
9001 }
9002
9003
9004 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
9005   bool jresult ;
9006   Dali::AngleAxis *arg1 = 0 ;
9007   Dali::AngleAxis *arg2 = 0 ;
9008   bool result;
9009
9010   arg1 = (Dali::AngleAxis *)jarg1;
9011   if (!arg1) {
9012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
9013     return 0;
9014   }
9015   arg2 = (Dali::AngleAxis *)jarg2;
9016   if (!arg2) {
9017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
9018     return 0;
9019   }
9020   {
9021     try {
9022       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
9023     } CALL_CATCH_EXCEPTION(0);
9024   }
9025
9026   jresult = result;
9027   return jresult;
9028 }
9029
9030
9031 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
9032   unsigned int jresult ;
9033   unsigned int arg1 ;
9034   unsigned int result;
9035
9036   arg1 = (unsigned int)jarg1;
9037   {
9038     try {
9039       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
9040     } CALL_CATCH_EXCEPTION(0);
9041   }
9042
9043   jresult = result;
9044   return jresult;
9045 }
9046
9047
9048 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
9049   bool jresult ;
9050   unsigned int arg1 ;
9051   bool result;
9052
9053   arg1 = (unsigned int)jarg1;
9054   {
9055     try {
9056       result = (bool)Dali::IsPowerOfTwo(arg1);
9057     } CALL_CATCH_EXCEPTION(0);
9058   }
9059
9060   jresult = result;
9061   return jresult;
9062 }
9063
9064
9065 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
9066   float jresult ;
9067   float arg1 ;
9068   float arg2 ;
9069   float result;
9070
9071   arg1 = (float)jarg1;
9072   arg2 = (float)jarg2;
9073   {
9074     try {
9075       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
9076     } CALL_CATCH_EXCEPTION(0);
9077   }
9078
9079   jresult = result;
9080   return jresult;
9081 }
9082
9083
9084 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
9085   bool jresult ;
9086   float arg1 ;
9087   bool result;
9088
9089   arg1 = (float)jarg1;
9090   {
9091     try {
9092       result = (bool)Dali::EqualsZero(arg1);
9093     } CALL_CATCH_EXCEPTION(0);
9094   }
9095
9096   jresult = result;
9097   return jresult;
9098 }
9099
9100
9101 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
9102   bool jresult ;
9103   float arg1 ;
9104   float arg2 ;
9105   bool result;
9106
9107   arg1 = (float)jarg1;
9108   arg2 = (float)jarg2;
9109   {
9110     try {
9111       result = (bool)Dali::Equals(arg1,arg2);
9112     } CALL_CATCH_EXCEPTION(0);
9113   }
9114
9115   jresult = result;
9116   return jresult;
9117 }
9118
9119
9120 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
9121   bool jresult ;
9122   float arg1 ;
9123   float arg2 ;
9124   float arg3 ;
9125   bool result;
9126
9127   arg1 = (float)jarg1;
9128   arg2 = (float)jarg2;
9129   arg3 = (float)jarg3;
9130   {
9131     try {
9132       result = (bool)Dali::Equals(arg1,arg2,arg3);
9133     } CALL_CATCH_EXCEPTION(0);
9134   }
9135
9136   jresult = result;
9137   return jresult;
9138 }
9139
9140
9141 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
9142   float jresult ;
9143   float arg1 ;
9144   int arg2 ;
9145   float result;
9146
9147   arg1 = (float)jarg1;
9148   arg2 = (int)jarg2;
9149   {
9150     try {
9151       result = (float)Dali::Round(arg1,arg2);
9152     } CALL_CATCH_EXCEPTION(0);
9153   }
9154
9155   jresult = result;
9156   return jresult;
9157 }
9158
9159
9160 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
9161   float jresult ;
9162   float arg1 ;
9163   float arg2 ;
9164   float arg3 ;
9165   float result;
9166
9167   arg1 = (float)jarg1;
9168   arg2 = (float)jarg2;
9169   arg3 = (float)jarg3;
9170   {
9171     try {
9172       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
9173     } CALL_CATCH_EXCEPTION(0);
9174   }
9175
9176   jresult = result;
9177   return jresult;
9178 }
9179
9180
9181 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
9182   float jresult ;
9183   float arg1 ;
9184   float arg2 ;
9185   float arg3 ;
9186   float arg4 ;
9187   float result;
9188
9189   arg1 = (float)jarg1;
9190   arg2 = (float)jarg2;
9191   arg3 = (float)jarg3;
9192   arg4 = (float)jarg4;
9193   {
9194     try {
9195       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
9196     } CALL_CATCH_EXCEPTION(0);
9197   }
9198
9199   jresult = result;
9200   return jresult;
9201 }
9202
9203
9204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
9205   int jresult ;
9206   int result;
9207
9208   result = (int)(int)Dali::Property::INVALID_INDEX;
9209   jresult = result;
9210   return jresult;
9211 }
9212
9213
9214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
9215   int jresult ;
9216   int result;
9217
9218   result = (int)(int)Dali::Property::INVALID_KEY;
9219   jresult = result;
9220   return jresult;
9221 }
9222
9223
9224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
9225   int jresult ;
9226   int result;
9227
9228   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
9229   jresult = result;
9230   return jresult;
9231 }
9232
9233
9234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
9235   void * jresult ;
9236   Dali::Handle *arg1 = 0 ;
9237   Dali::Property::Index arg2 ;
9238   Dali::Property *result = 0 ;
9239
9240   arg1 = (Dali::Handle *)jarg1;
9241   if (!arg1) {
9242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9243     return 0;
9244   }
9245   arg2 = (Dali::Property::Index)jarg2;
9246   {
9247     try {
9248       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
9249     } CALL_CATCH_EXCEPTION(0);
9250   }
9251
9252   jresult = (void *)result;
9253   return jresult;
9254 }
9255
9256
9257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
9258   void * jresult ;
9259   Dali::Handle *arg1 = 0 ;
9260   Dali::Property::Index arg2 ;
9261   int arg3 ;
9262   Dali::Property *result = 0 ;
9263
9264   arg1 = (Dali::Handle *)jarg1;
9265   if (!arg1) {
9266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9267     return 0;
9268   }
9269   arg2 = (Dali::Property::Index)jarg2;
9270   arg3 = (int)jarg3;
9271   {
9272     try {
9273       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
9274     } CALL_CATCH_EXCEPTION(0);
9275   }
9276
9277   jresult = (void *)result;
9278   return jresult;
9279 }
9280
9281
9282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
9283   void * jresult ;
9284   Dali::Handle *arg1 = 0 ;
9285   std::string *arg2 = 0 ;
9286   Dali::Property *result = 0 ;
9287
9288   arg1 = (Dali::Handle *)jarg1;
9289   if (!arg1) {
9290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9291     return 0;
9292   }
9293   if (!jarg2) {
9294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9295     return 0;
9296   }
9297   std::string arg2_str(jarg2);
9298   arg2 = &arg2_str;
9299   {
9300     try {
9301       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
9302     } CALL_CATCH_EXCEPTION(0);
9303   }
9304
9305   jresult = (void *)result;
9306
9307   //argout typemap for const std::string&
9308
9309   return jresult;
9310 }
9311
9312
9313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
9314   void * jresult ;
9315   Dali::Handle *arg1 = 0 ;
9316   std::string *arg2 = 0 ;
9317   int arg3 ;
9318   Dali::Property *result = 0 ;
9319
9320   arg1 = (Dali::Handle *)jarg1;
9321   if (!arg1) {
9322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9323     return 0;
9324   }
9325   if (!jarg2) {
9326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9327     return 0;
9328   }
9329   std::string arg2_str(jarg2);
9330   arg2 = &arg2_str;
9331   arg3 = (int)jarg3;
9332   {
9333     try {
9334       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
9335     } CALL_CATCH_EXCEPTION(0);
9336   }
9337
9338   jresult = (void *)result;
9339
9340   //argout typemap for const std::string&
9341
9342   return jresult;
9343 }
9344
9345
9346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
9347   Dali::Property *arg1 = (Dali::Property *) 0 ;
9348
9349   arg1 = (Dali::Property *)jarg1;
9350   {
9351     try {
9352       delete arg1;
9353     } CALL_CATCH_EXCEPTION();
9354   }
9355
9356 }
9357
9358
9359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
9360   Dali::Property *arg1 = (Dali::Property *) 0 ;
9361   Dali::Handle *arg2 = 0 ;
9362
9363   arg1 = (Dali::Property *)jarg1;
9364   arg2 = (Dali::Handle *)jarg2;
9365   if (!arg2) {
9366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9367     return ;
9368   }
9369   if (arg1) (arg1)->object = *arg2;
9370 }
9371
9372
9373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
9374   void * jresult ;
9375   Dali::Property *arg1 = (Dali::Property *) 0 ;
9376   Dali::Handle *result = 0 ;
9377
9378   arg1 = (Dali::Property *)jarg1;
9379   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
9380   jresult = (void *)result;
9381   return jresult;
9382 }
9383
9384
9385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
9386   Dali::Property *arg1 = (Dali::Property *) 0 ;
9387   Dali::Property::Index arg2 ;
9388
9389   arg1 = (Dali::Property *)jarg1;
9390   arg2 = (Dali::Property::Index)jarg2;
9391   if (arg1) (arg1)->propertyIndex = arg2;
9392 }
9393
9394
9395 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
9396   int jresult ;
9397   Dali::Property *arg1 = (Dali::Property *) 0 ;
9398   Dali::Property::Index result;
9399
9400   arg1 = (Dali::Property *)jarg1;
9401   result = (Dali::Property::Index) ((arg1)->propertyIndex);
9402   jresult = result;
9403   return jresult;
9404 }
9405
9406
9407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
9408   Dali::Property *arg1 = (Dali::Property *) 0 ;
9409   int arg2 ;
9410
9411   arg1 = (Dali::Property *)jarg1;
9412   arg2 = (int)jarg2;
9413   if (arg1) (arg1)->componentIndex = arg2;
9414 }
9415
9416
9417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
9418   int jresult ;
9419   Dali::Property *arg1 = (Dali::Property *) 0 ;
9420   int result;
9421
9422   arg1 = (Dali::Property *)jarg1;
9423   result = (int) ((arg1)->componentIndex);
9424   jresult = result;
9425   return jresult;
9426 }
9427
9428
9429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
9430   void * jresult ;
9431   Dali::Property::Array *result = 0 ;
9432
9433   {
9434     try {
9435       result = (Dali::Property::Array *)new Dali::Property::Array();
9436     } CALL_CATCH_EXCEPTION(0);
9437   }
9438
9439   jresult = (void *)result;
9440   return jresult;
9441 }
9442
9443
9444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
9445   void * jresult ;
9446   Dali::Property::Array *arg1 = 0 ;
9447   Dali::Property::Array *result = 0 ;
9448
9449   arg1 = (Dali::Property::Array *)jarg1;
9450   if (!arg1) {
9451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
9452     return 0;
9453   }
9454   {
9455     try {
9456       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
9457     } CALL_CATCH_EXCEPTION(0);
9458   }
9459
9460   jresult = (void *)result;
9461   return jresult;
9462 }
9463
9464
9465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
9466   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9467
9468   arg1 = (Dali::Property::Array *)jarg1;
9469   {
9470     try {
9471       delete arg1;
9472     } CALL_CATCH_EXCEPTION();
9473   }
9474
9475 }
9476
9477
9478 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
9479   unsigned long jresult ;
9480   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9481   Dali::Property::Array::SizeType result;
9482
9483   arg1 = (Dali::Property::Array *)jarg1;
9484   {
9485     try {
9486       result = ((Dali::Property::Array const *)arg1)->Size();
9487     } CALL_CATCH_EXCEPTION(0);
9488   }
9489
9490   jresult = (unsigned long)result;
9491   return jresult;
9492 }
9493
9494
9495 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
9496   unsigned long jresult ;
9497   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9498   Dali::Property::Array::SizeType result;
9499
9500   arg1 = (Dali::Property::Array *)jarg1;
9501   {
9502     try {
9503       result = ((Dali::Property::Array const *)arg1)->Count();
9504     } CALL_CATCH_EXCEPTION(0);
9505   }
9506
9507   jresult = (unsigned long)result;
9508   return jresult;
9509 }
9510
9511
9512 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
9513   bool jresult ;
9514   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9515   bool result;
9516
9517   arg1 = (Dali::Property::Array *)jarg1;
9518   {
9519     try {
9520       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
9521     } CALL_CATCH_EXCEPTION(0);
9522   }
9523
9524   jresult = result;
9525   return jresult;
9526 }
9527
9528
9529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
9530   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9531
9532   arg1 = (Dali::Property::Array *)jarg1;
9533   {
9534     try {
9535       (arg1)->Clear();
9536     } CALL_CATCH_EXCEPTION();
9537   }
9538
9539 }
9540
9541
9542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
9543   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9544   Dali::Property::Array::SizeType arg2 ;
9545
9546   arg1 = (Dali::Property::Array *)jarg1;
9547   arg2 = (Dali::Property::Array::SizeType)jarg2;
9548   {
9549     try {
9550       (arg1)->Reserve(arg2);
9551     } CALL_CATCH_EXCEPTION();
9552   }
9553
9554 }
9555
9556
9557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
9558   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9559   Dali::Property::Array::SizeType arg2 ;
9560
9561   arg1 = (Dali::Property::Array *)jarg1;
9562   arg2 = (Dali::Property::Array::SizeType)jarg2;
9563   {
9564     try {
9565       (arg1)->Resize(arg2);
9566     } CALL_CATCH_EXCEPTION();
9567   }
9568
9569 }
9570
9571
9572 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
9573   unsigned long jresult ;
9574   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9575   Dali::Property::Array::SizeType result;
9576
9577   arg1 = (Dali::Property::Array *)jarg1;
9578   {
9579     try {
9580       result = (arg1)->Capacity();
9581     } CALL_CATCH_EXCEPTION(0);
9582   }
9583
9584   jresult = (unsigned long)result;
9585   return jresult;
9586 }
9587
9588
9589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
9590   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9591   Dali::Property::Value *arg2 = 0 ;
9592
9593   arg1 = (Dali::Property::Array *)jarg1;
9594   arg2 = (Dali::Property::Value *)jarg2;
9595   if (!arg2) {
9596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
9597     return ;
9598   }
9599   {
9600     try {
9601       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
9602     } CALL_CATCH_EXCEPTION();
9603   }
9604
9605 }
9606
9607
9608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
9609   void * jresult ;
9610   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9611   Dali::Property::Value *arg2 = 0 ;
9612   Dali::Property::Array *result = 0 ;
9613
9614   arg1 = (Dali::Property::Array *)jarg1;
9615   arg2 = (Dali::Property::Value *)jarg2;
9616   if (!arg2) {
9617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
9618     return 0;
9619   }
9620   {
9621     try {
9622       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
9623     } CALL_CATCH_EXCEPTION(0);
9624   }
9625
9626   jresult = (void *)result;
9627   return jresult;
9628 }
9629
9630
9631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
9632   void * jresult ;
9633   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9634   Dali::Property::Array::SizeType arg2 ;
9635   Dali::Property::Value *result = 0 ;
9636
9637   arg1 = (Dali::Property::Array *)jarg1;
9638   arg2 = (Dali::Property::Array::SizeType)jarg2;
9639   {
9640     try {
9641       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
9642     } CALL_CATCH_EXCEPTION(0);
9643   }
9644
9645   jresult = (void *)result;
9646   return jresult;
9647 }
9648
9649
9650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
9651   void * jresult ;
9652   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9653   Dali::Property::Array::SizeType arg2 ;
9654   Dali::Property::Value *result = 0 ;
9655
9656   arg1 = (Dali::Property::Array *)jarg1;
9657   arg2 = (Dali::Property::Array::SizeType)jarg2;
9658   {
9659     try {
9660       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
9661     } CALL_CATCH_EXCEPTION(0);
9662   }
9663
9664   jresult = (void *)result;
9665   return jresult;
9666 }
9667
9668
9669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
9670   void * jresult ;
9671   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9672   Dali::Property::Array *arg2 = 0 ;
9673   Dali::Property::Array *result = 0 ;
9674
9675   arg1 = (Dali::Property::Array *)jarg1;
9676   arg2 = (Dali::Property::Array *)jarg2;
9677   if (!arg2) {
9678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
9679     return 0;
9680   }
9681   {
9682     try {
9683       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
9684     } CALL_CATCH_EXCEPTION(0);
9685   }
9686
9687   jresult = (void *)result;
9688   return jresult;
9689 }
9690
9691
9692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
9693   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9694   enum Dali::Property::Key::Type arg2 ;
9695
9696   arg1 = (Dali::Property::Key *)jarg1;
9697   arg2 = (enum Dali::Property::Key::Type)jarg2;
9698   if (arg1) (arg1)->type = arg2;
9699 }
9700
9701
9702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
9703   int jresult ;
9704   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9705   enum Dali::Property::Key::Type result;
9706
9707   arg1 = (Dali::Property::Key *)jarg1;
9708   result = (enum Dali::Property::Key::Type) ((arg1)->type);
9709   jresult = (int)result;
9710   return jresult;
9711 }
9712
9713
9714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
9715   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9716   Dali::Property::Index arg2 ;
9717
9718   arg1 = (Dali::Property::Key *)jarg1;
9719   arg2 = (Dali::Property::Index)jarg2;
9720   if (arg1) (arg1)->indexKey = arg2;
9721 }
9722
9723
9724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
9725   int jresult ;
9726   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9727   Dali::Property::Index result;
9728
9729   arg1 = (Dali::Property::Key *)jarg1;
9730   result = (Dali::Property::Index) ((arg1)->indexKey);
9731   jresult = result;
9732   return jresult;
9733 }
9734
9735
9736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
9737   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9738   std::string *arg2 = 0 ;
9739
9740   arg1 = (Dali::Property::Key *)jarg1;
9741   if (!jarg2) {
9742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9743     return ;
9744   }
9745   std::string arg2_str(jarg2);
9746   arg2 = &arg2_str;
9747   if (arg1) (arg1)->stringKey = *arg2;
9748
9749   //argout typemap for const std::string&
9750
9751 }
9752
9753
9754 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
9755   char * jresult ;
9756   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9757   std::string *result = 0 ;
9758
9759   arg1 = (Dali::Property::Key *)jarg1;
9760   result = (std::string *) & ((arg1)->stringKey);
9761   jresult = SWIG_csharp_string_callback(result->c_str());
9762   return jresult;
9763 }
9764
9765
9766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
9767   void * jresult ;
9768   std::string *arg1 = 0 ;
9769   Dali::Property::Key *result = 0 ;
9770
9771   if (!jarg1) {
9772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9773     return 0;
9774   }
9775   std::string arg1_str(jarg1);
9776   arg1 = &arg1_str;
9777   {
9778     try {
9779       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
9780     } CALL_CATCH_EXCEPTION(0);
9781   }
9782
9783   jresult = (void *)result;
9784
9785   //argout typemap for const std::string&
9786
9787   return jresult;
9788 }
9789
9790
9791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
9792   void * jresult ;
9793   Dali::Property::Index arg1 ;
9794   Dali::Property::Key *result = 0 ;
9795
9796   arg1 = (Dali::Property::Index)jarg1;
9797   {
9798     try {
9799       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
9800     } CALL_CATCH_EXCEPTION(0);
9801   }
9802
9803   jresult = (void *)result;
9804   return jresult;
9805 }
9806
9807
9808 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
9809   bool jresult ;
9810   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9811   std::string *arg2 = 0 ;
9812   bool result;
9813
9814   arg1 = (Dali::Property::Key *)jarg1;
9815   if (!jarg2) {
9816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9817     return 0;
9818   }
9819   std::string arg2_str(jarg2);
9820   arg2 = &arg2_str;
9821   {
9822     try {
9823       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
9824     } CALL_CATCH_EXCEPTION(0);
9825   }
9826
9827   jresult = result;
9828
9829   //argout typemap for const std::string&
9830
9831   return jresult;
9832 }
9833
9834
9835 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
9836   bool jresult ;
9837   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9838   Dali::Property::Index arg2 ;
9839   bool result;
9840
9841   arg1 = (Dali::Property::Key *)jarg1;
9842   arg2 = (Dali::Property::Index)jarg2;
9843   {
9844     try {
9845       result = (bool)(arg1)->operator ==(arg2);
9846     } CALL_CATCH_EXCEPTION(0);
9847   }
9848
9849   jresult = result;
9850   return jresult;
9851 }
9852
9853
9854 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
9855   bool jresult ;
9856   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9857   Dali::Property::Key *arg2 = 0 ;
9858   bool result;
9859
9860   arg1 = (Dali::Property::Key *)jarg1;
9861   arg2 = (Dali::Property::Key *)jarg2;
9862   if (!arg2) {
9863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
9864     return 0;
9865   }
9866   {
9867     try {
9868       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
9869     } CALL_CATCH_EXCEPTION(0);
9870   }
9871
9872   jresult = result;
9873   return jresult;
9874 }
9875
9876
9877 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
9878   bool jresult ;
9879   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9880   std::string *arg2 = 0 ;
9881   bool result;
9882
9883   arg1 = (Dali::Property::Key *)jarg1;
9884   if (!jarg2) {
9885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9886     return 0;
9887   }
9888   std::string arg2_str(jarg2);
9889   arg2 = &arg2_str;
9890   {
9891     try {
9892       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
9893     } CALL_CATCH_EXCEPTION(0);
9894   }
9895
9896   jresult = result;
9897
9898   //argout typemap for const std::string&
9899
9900   return jresult;
9901 }
9902
9903
9904 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
9905   bool jresult ;
9906   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9907   Dali::Property::Index arg2 ;
9908   bool result;
9909
9910   arg1 = (Dali::Property::Key *)jarg1;
9911   arg2 = (Dali::Property::Index)jarg2;
9912   {
9913     try {
9914       result = (bool)(arg1)->operator !=(arg2);
9915     } CALL_CATCH_EXCEPTION(0);
9916   }
9917
9918   jresult = result;
9919   return jresult;
9920 }
9921
9922
9923 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
9924   bool jresult ;
9925   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9926   Dali::Property::Key *arg2 = 0 ;
9927   bool result;
9928
9929   arg1 = (Dali::Property::Key *)jarg1;
9930   arg2 = (Dali::Property::Key *)jarg2;
9931   if (!arg2) {
9932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
9933     return 0;
9934   }
9935   {
9936     try {
9937       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
9938     } CALL_CATCH_EXCEPTION(0);
9939   }
9940
9941   jresult = result;
9942   return jresult;
9943 }
9944
9945
9946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
9947   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9948
9949   arg1 = (Dali::Property::Key *)jarg1;
9950   {
9951     try {
9952       delete arg1;
9953     } CALL_CATCH_EXCEPTION();
9954   }
9955
9956 }
9957
9958
9959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
9960   void * jresult ;
9961   Dali::Property::Map *result = 0 ;
9962
9963   {
9964     try {
9965       result = (Dali::Property::Map *)new Dali::Property::Map();
9966     } CALL_CATCH_EXCEPTION(0);
9967   }
9968
9969   jresult = (void *)result;
9970   return jresult;
9971 }
9972
9973
9974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
9975   void * jresult ;
9976   Dali::Property::Map *arg1 = 0 ;
9977   Dali::Property::Map *result = 0 ;
9978
9979   arg1 = (Dali::Property::Map *)jarg1;
9980   if (!arg1) {
9981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
9982     return 0;
9983   }
9984   {
9985     try {
9986       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
9987     } CALL_CATCH_EXCEPTION(0);
9988   }
9989
9990   jresult = (void *)result;
9991   return jresult;
9992 }
9993
9994
9995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
9996   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
9997
9998   arg1 = (Dali::Property::Map *)jarg1;
9999   {
10000     try {
10001       delete arg1;
10002     } CALL_CATCH_EXCEPTION();
10003   }
10004
10005 }
10006
10007
10008 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
10009   unsigned long jresult ;
10010   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10011   Dali::Property::Map::SizeType result;
10012
10013   arg1 = (Dali::Property::Map *)jarg1;
10014   {
10015     try {
10016       result = ((Dali::Property::Map const *)arg1)->Count();
10017     } CALL_CATCH_EXCEPTION(0);
10018   }
10019
10020   jresult = (unsigned long)result;
10021   return jresult;
10022 }
10023
10024
10025 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
10026   bool jresult ;
10027   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10028   bool result;
10029
10030   arg1 = (Dali::Property::Map *)jarg1;
10031   {
10032     try {
10033       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
10034     } CALL_CATCH_EXCEPTION(0);
10035   }
10036
10037   jresult = result;
10038   return jresult;
10039 }
10040
10041
10042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
10043   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10044   char *arg2 = (char *) 0 ;
10045   Dali::Property::Value *arg3 = 0 ;
10046
10047   arg1 = (Dali::Property::Map *)jarg1;
10048   arg2 = (char *)jarg2;
10049   arg3 = (Dali::Property::Value *)jarg3;
10050   if (!arg3) {
10051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10052     return ;
10053   }
10054   {
10055     try {
10056       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
10057     } CALL_CATCH_EXCEPTION();
10058   }
10059
10060 }
10061
10062
10063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
10064   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10065   Dali::Property::Index arg2 ;
10066   Dali::Property::Value *arg3 = 0 ;
10067
10068   arg1 = (Dali::Property::Map *)jarg1;
10069   arg2 = (Dali::Property::Index)jarg2;
10070   arg3 = (Dali::Property::Value *)jarg3;
10071   if (!arg3) {
10072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10073     return ;
10074   }
10075   {
10076     try {
10077       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
10078     } CALL_CATCH_EXCEPTION();
10079   }
10080
10081 }
10082
10083
10084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
10085   void * jresult ;
10086   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10087   char *arg2 = (char *) 0 ;
10088   Dali::Property::Value *arg3 = 0 ;
10089   Dali::Property::Map *result = 0 ;
10090
10091   arg1 = (Dali::Property::Map *)jarg1;
10092   arg2 = (char *)jarg2;
10093   arg3 = (Dali::Property::Value *)jarg3;
10094   if (!arg3) {
10095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10096     return 0;
10097   }
10098   {
10099     try {
10100       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
10101     } CALL_CATCH_EXCEPTION(0);
10102   }
10103
10104   jresult = (void *)result;
10105   return jresult;
10106 }
10107
10108
10109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
10110   void * jresult ;
10111   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10112   Dali::Property::Index arg2 ;
10113   Dali::Property::Value *arg3 = 0 ;
10114   Dali::Property::Map *result = 0 ;
10115
10116   arg1 = (Dali::Property::Map *)jarg1;
10117   arg2 = (Dali::Property::Index)jarg2;
10118   arg3 = (Dali::Property::Value *)jarg3;
10119   if (!arg3) {
10120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10121     return 0;
10122   }
10123   {
10124     try {
10125       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
10126     } CALL_CATCH_EXCEPTION(0);
10127   }
10128
10129   jresult = (void *)result;
10130   return jresult;
10131 }
10132
10133
10134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
10135   void * jresult ;
10136   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10137   Dali::Property::Map::SizeType arg2 ;
10138   Dali::Property::Value *result = 0 ;
10139
10140   arg1 = (Dali::Property::Map *)jarg1;
10141   arg2 = (Dali::Property::Map::SizeType)jarg2;
10142   {
10143     try {
10144       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
10145     } CALL_CATCH_EXCEPTION(0);
10146   }
10147
10148   jresult = (void *)result;
10149   return jresult;
10150 }
10151
10152
10153 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
10154   char * jresult ;
10155   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10156   Dali::Property::Map::SizeType arg2 ;
10157   std::string *result = 0 ;
10158
10159   arg1 = (Dali::Property::Map *)jarg1;
10160   arg2 = (Dali::Property::Map::SizeType)jarg2;
10161   {
10162     try {
10163       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
10164     } CALL_CATCH_EXCEPTION(0);
10165   }
10166
10167   jresult = SWIG_csharp_string_callback(result->c_str());
10168   return jresult;
10169 }
10170
10171
10172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
10173   void * jresult ;
10174   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10175   Dali::Property::Map::SizeType arg2 ;
10176   SwigValueWrapper< Dali::Property::Key > result;
10177
10178   arg1 = (Dali::Property::Map *)jarg1;
10179   arg2 = (Dali::Property::Map::SizeType)jarg2;
10180   {
10181     try {
10182       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
10183     } CALL_CATCH_EXCEPTION(0);
10184   }
10185
10186   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
10187   return jresult;
10188 }
10189
10190
10191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
10192   void * jresult ;
10193   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10194   Dali::Property::Map::SizeType arg2 ;
10195   StringValuePair *result = 0 ;
10196
10197   arg1 = (Dali::Property::Map *)jarg1;
10198   arg2 = (Dali::Property::Map::SizeType)jarg2;
10199   {
10200     try {
10201       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
10202     } CALL_CATCH_EXCEPTION(0);
10203   }
10204
10205   jresult = (void *)result;
10206   return jresult;
10207 }
10208
10209
10210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
10211   void * jresult ;
10212   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10213   char *arg2 = (char *) 0 ;
10214   Dali::Property::Value *result = 0 ;
10215
10216   arg1 = (Dali::Property::Map *)jarg1;
10217   arg2 = (char *)jarg2;
10218   {
10219     try {
10220       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
10221     } CALL_CATCH_EXCEPTION(0);
10222   }
10223
10224   jresult = (void *)result;
10225   return jresult;
10226 }
10227
10228
10229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
10230   void * jresult ;
10231   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10232   Dali::Property::Index arg2 ;
10233   Dali::Property::Value *result = 0 ;
10234
10235   arg1 = (Dali::Property::Map *)jarg1;
10236   arg2 = (Dali::Property::Index)jarg2;
10237   {
10238     try {
10239       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
10240     } CALL_CATCH_EXCEPTION(0);
10241   }
10242
10243   jresult = (void *)result;
10244   return jresult;
10245 }
10246
10247
10248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
10249   void * jresult ;
10250   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10251   Dali::Property::Index arg2 ;
10252   std::string *arg3 = 0 ;
10253   Dali::Property::Value *result = 0 ;
10254
10255   arg1 = (Dali::Property::Map *)jarg1;
10256   arg2 = (Dali::Property::Index)jarg2;
10257   if (!jarg3) {
10258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10259     return 0;
10260   }
10261   std::string arg3_str(jarg3);
10262   arg3 = &arg3_str;
10263   {
10264     try {
10265       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
10266     } CALL_CATCH_EXCEPTION(0);
10267   }
10268
10269   jresult = (void *)result;
10270
10271   //argout typemap for const std::string&
10272
10273   return jresult;
10274 }
10275
10276
10277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
10278   void * jresult ;
10279   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10280   std::string *arg2 = 0 ;
10281   Dali::Property::Type arg3 ;
10282   Dali::Property::Value *result = 0 ;
10283
10284   arg1 = (Dali::Property::Map *)jarg1;
10285   if (!jarg2) {
10286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10287     return 0;
10288   }
10289   std::string arg2_str(jarg2);
10290   arg2 = &arg2_str;
10291   arg3 = (Dali::Property::Type)jarg3;
10292   {
10293     try {
10294       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
10295     } CALL_CATCH_EXCEPTION(0);
10296   }
10297
10298   jresult = (void *)result;
10299
10300   //argout typemap for const std::string&
10301
10302   return jresult;
10303 }
10304
10305
10306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
10307   void * jresult ;
10308   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10309   Dali::Property::Index arg2 ;
10310   Dali::Property::Type arg3 ;
10311   Dali::Property::Value *result = 0 ;
10312
10313   arg1 = (Dali::Property::Map *)jarg1;
10314   arg2 = (Dali::Property::Index)jarg2;
10315   arg3 = (Dali::Property::Type)jarg3;
10316   {
10317     try {
10318       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
10319     } CALL_CATCH_EXCEPTION(0);
10320   }
10321
10322   jresult = (void *)result;
10323   return jresult;
10324 }
10325
10326
10327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
10328   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10329
10330   arg1 = (Dali::Property::Map *)jarg1;
10331   {
10332     try {
10333       (arg1)->Clear();
10334     } CALL_CATCH_EXCEPTION();
10335   }
10336
10337 }
10338
10339
10340 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Map_Remove__SWIG_0(void * map, int key) {
10341   Dali::Property::Map *propertyMap = (Dali::Property::Map *)map;
10342   Dali::Property::Index intKey = (Dali::Property::Index)key;
10343   bool isRemoved = false;
10344   {
10345     try {
10346       isRemoved = propertyMap->Remove(intKey);
10347     } CALL_CATCH_EXCEPTION(0);
10348   }
10349   return isRemoved;
10350 }
10351
10352
10353 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Map_Remove__SWIG_1(void * map, char * key) {
10354   Dali::Property::Map *propertyMap = (Dali::Property::Map *)map;
10355   std::string strKey(key);
10356   bool isRemoved = false;
10357   {
10358     try {
10359       isRemoved = propertyMap->Remove(strKey);
10360     } CALL_CATCH_EXCEPTION(0);
10361   }
10362   return isRemoved;
10363 }
10364
10365
10366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
10367   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10368   Dali::Property::Map *arg2 = 0 ;
10369
10370   arg1 = (Dali::Property::Map *)jarg1;
10371   arg2 = (Dali::Property::Map *)jarg2;
10372   if (!arg2) {
10373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
10374     return ;
10375   }
10376   {
10377     try {
10378       (arg1)->Merge((Dali::Property::Map const &)*arg2);
10379     } CALL_CATCH_EXCEPTION();
10380   }
10381
10382 }
10383
10384
10385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
10386   void * jresult ;
10387   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10388   std::string *arg2 = 0 ;
10389   Dali::Property::Value *result = 0 ;
10390
10391   arg1 = (Dali::Property::Map *)jarg1;
10392   if (!jarg2) {
10393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10394     return 0;
10395   }
10396   std::string arg2_str(jarg2);
10397   arg2 = &arg2_str;
10398   {
10399     try {
10400       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
10401     } CALL_CATCH_EXCEPTION(0);
10402   }
10403
10404   jresult = (void *)result;
10405
10406   //argout typemap for const std::string&
10407
10408   return jresult;
10409 }
10410
10411
10412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
10413   void * jresult ;
10414   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10415   Dali::Property::Index arg2 ;
10416   Dali::Property::Value *result = 0 ;
10417
10418   arg1 = (Dali::Property::Map *)jarg1;
10419   arg2 = (Dali::Property::Index)jarg2;
10420   {
10421     try {
10422       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
10423     } CALL_CATCH_EXCEPTION(0);
10424   }
10425
10426   jresult = (void *)result;
10427   return jresult;
10428 }
10429
10430
10431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
10432   void * jresult ;
10433   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10434   Dali::Property::Map *arg2 = 0 ;
10435   Dali::Property::Map *result = 0 ;
10436
10437   arg1 = (Dali::Property::Map *)jarg1;
10438   arg2 = (Dali::Property::Map *)jarg2;
10439   if (!arg2) {
10440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
10441     return 0;
10442   }
10443   {
10444     try {
10445       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
10446     } CALL_CATCH_EXCEPTION(0);
10447   }
10448
10449   jresult = (void *)result;
10450   return jresult;
10451 }
10452
10453
10454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) {
10455
10456   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10457
10458   if (!jarg2) {
10459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10460     return;
10461   }
10462   std::string arg2_str(jarg2);
10463   std::string* arg2 = &arg2_str;
10464
10465   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
10466
10467   {
10468     try {
10469       arg1->operator[]((std::string const &)*arg2) = *arg3;
10470     } CALL_CATCH_EXCEPTION();
10471   }
10472 }
10473
10474
10475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
10476
10477   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10478   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
10479   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
10480
10481   {
10482     try {
10483       arg1->operator[](arg2) = *arg3;
10484     } CALL_CATCH_EXCEPTION();
10485   }
10486 }
10487
10488
10489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
10490   void * jresult ;
10491   Dali::Property::Value *result = 0 ;
10492
10493   {
10494     try {
10495       result = (Dali::Property::Value *)new Dali::Property::Value();
10496     } CALL_CATCH_EXCEPTION(0);
10497   }
10498
10499   jresult = (void *)result;
10500   return jresult;
10501 }
10502
10503
10504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(bool jarg1) {
10505   void * jresult ;
10506   bool arg1 ;
10507   Dali::Property::Value *result = 0 ;
10508
10509   arg1 = jarg1 ? true : false;
10510   {
10511     try {
10512       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
10513     } CALL_CATCH_EXCEPTION(0);
10514   }
10515
10516   jresult = (void *)result;
10517   return jresult;
10518 }
10519
10520
10521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
10522   void * jresult ;
10523   int arg1 ;
10524   Dali::Property::Value *result = 0 ;
10525
10526   arg1 = (int)jarg1;
10527   {
10528     try {
10529       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
10530     } CALL_CATCH_EXCEPTION(0);
10531   }
10532
10533   jresult = (void *)result;
10534   return jresult;
10535 }
10536
10537
10538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
10539   void * jresult ;
10540   float arg1 ;
10541   Dali::Property::Value *result = 0 ;
10542
10543   arg1 = (float)jarg1;
10544   {
10545     try {
10546       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
10547     } CALL_CATCH_EXCEPTION(0);
10548   }
10549
10550   jresult = (void *)result;
10551   return jresult;
10552 }
10553
10554
10555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
10556   void * jresult ;
10557   Dali::Vector2 *arg1 = 0 ;
10558   Dali::Property::Value *result = 0 ;
10559
10560   arg1 = (Dali::Vector2 *)jarg1;
10561   if (!arg1) {
10562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
10563     return 0;
10564   }
10565   {
10566     try {
10567       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
10568     } CALL_CATCH_EXCEPTION(0);
10569   }
10570
10571   jresult = (void *)result;
10572   return jresult;
10573 }
10574
10575
10576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
10577   void * jresult ;
10578   Dali::Vector3 *arg1 = 0 ;
10579   Dali::Property::Value *result = 0 ;
10580
10581   arg1 = (Dali::Vector3 *)jarg1;
10582   if (!arg1) {
10583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10584     return 0;
10585   }
10586   {
10587     try {
10588       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
10589     } CALL_CATCH_EXCEPTION(0);
10590   }
10591
10592   jresult = (void *)result;
10593   return jresult;
10594 }
10595
10596
10597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
10598   void * jresult ;
10599   Dali::Vector4 *arg1 = 0 ;
10600   Dali::Property::Value *result = 0 ;
10601
10602   arg1 = (Dali::Vector4 *)jarg1;
10603   if (!arg1) {
10604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
10605     return 0;
10606   }
10607   {
10608     try {
10609       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
10610     } CALL_CATCH_EXCEPTION(0);
10611   }
10612
10613   jresult = (void *)result;
10614   return jresult;
10615 }
10616
10617
10618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
10619   void * jresult ;
10620   Dali::Matrix3 *arg1 = 0 ;
10621   Dali::Property::Value *result = 0 ;
10622
10623   arg1 = (Dali::Matrix3 *)jarg1;
10624   if (!arg1) {
10625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
10626     return 0;
10627   }
10628   {
10629     try {
10630       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
10631     } CALL_CATCH_EXCEPTION(0);
10632   }
10633
10634   jresult = (void *)result;
10635   return jresult;
10636 }
10637
10638
10639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
10640   void * jresult ;
10641   Dali::Matrix *arg1 = 0 ;
10642   Dali::Property::Value *result = 0 ;
10643
10644   arg1 = (Dali::Matrix *)jarg1;
10645   if (!arg1) {
10646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
10647     return 0;
10648   }
10649   {
10650     try {
10651       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
10652     } CALL_CATCH_EXCEPTION(0);
10653   }
10654
10655   jresult = (void *)result;
10656   return jresult;
10657 }
10658
10659
10660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
10661   void * jresult ;
10662   Dali::Rect< int > *arg1 = 0 ;
10663   Dali::Property::Value *result = 0 ;
10664
10665   arg1 = (Dali::Rect< int > *)jarg1;
10666   if (!arg1) {
10667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
10668     return 0;
10669   }
10670   {
10671     try {
10672       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
10673     } CALL_CATCH_EXCEPTION(0);
10674   }
10675
10676   jresult = (void *)result;
10677   return jresult;
10678 }
10679
10680
10681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
10682   void * jresult ;
10683   Dali::AngleAxis *arg1 = 0 ;
10684   Dali::Property::Value *result = 0 ;
10685
10686   arg1 = (Dali::AngleAxis *)jarg1;
10687   if (!arg1) {
10688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
10689     return 0;
10690   }
10691   {
10692     try {
10693       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
10694     } CALL_CATCH_EXCEPTION(0);
10695   }
10696
10697   jresult = (void *)result;
10698   return jresult;
10699 }
10700
10701
10702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
10703   void * jresult ;
10704   Dali::Quaternion *arg1 = 0 ;
10705   Dali::Property::Value *result = 0 ;
10706
10707   arg1 = (Dali::Quaternion *)jarg1;
10708   if (!arg1) {
10709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10710     return 0;
10711   }
10712   {
10713     try {
10714       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
10715     } CALL_CATCH_EXCEPTION(0);
10716   }
10717
10718   jresult = (void *)result;
10719   return jresult;
10720 }
10721
10722
10723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
10724   void * jresult ;
10725   std::string *arg1 = 0 ;
10726   Dali::Property::Value *result = 0 ;
10727
10728   if (!jarg1) {
10729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10730     return 0;
10731   }
10732   std::string arg1_str(jarg1);
10733   arg1 = &arg1_str;
10734   {
10735     try {
10736       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
10737     } CALL_CATCH_EXCEPTION(0);
10738   }
10739
10740   jresult = (void *)result;
10741
10742   //argout typemap for const std::string&
10743
10744   return jresult;
10745 }
10746
10747
10748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
10749   void * jresult ;
10750   Dali::Property::Array *arg1 = 0 ;
10751   Dali::Property::Value *result = 0 ;
10752
10753   arg1 = (Dali::Property::Array *)jarg1;
10754   if (!arg1) {
10755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
10756     return 0;
10757   }
10758   {
10759     try {
10760       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
10761     } CALL_CATCH_EXCEPTION(0);
10762   }
10763
10764   jresult = (void *)result;
10765   return jresult;
10766 }
10767
10768
10769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
10770   void * jresult ;
10771   Dali::Property::Map *arg1 = 0 ;
10772   Dali::Property::Value *result = 0 ;
10773
10774   arg1 = (Dali::Property::Map *)jarg1;
10775   if (!arg1) {
10776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
10777     return 0;
10778   }
10779   {
10780     try {
10781       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
10782     } CALL_CATCH_EXCEPTION(0);
10783   }
10784
10785   jresult = (void *)result;
10786   return jresult;
10787 }
10788
10789
10790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
10791   void * jresult ;
10792   Extents *arg1 = 0 ;
10793   Dali::Property::Value *result = 0 ;
10794
10795   arg1 = (Extents *)jarg1;
10796   if (!arg1) {
10797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
10798     return 0;
10799   }
10800   {
10801     try {
10802       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
10803     } CALL_CATCH_EXCEPTION(0);
10804   }
10805
10806   jresult = (void*) result;
10807   return jresult;
10808 }
10809
10810
10811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
10812   void * jresult ;
10813   Dali::Property::Type arg1 ;
10814   Dali::Property::Value *result = 0 ;
10815
10816   arg1 = (Dali::Property::Type)jarg1;
10817   {
10818     try {
10819       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
10820     } CALL_CATCH_EXCEPTION(0);
10821   }
10822
10823   jresult = (void *)result;
10824   return jresult;
10825 }
10826
10827
10828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
10829   void * jresult ;
10830   Dali::Property::Value *arg1 = 0 ;
10831   Dali::Property::Value *result = 0 ;
10832
10833   arg1 = (Dali::Property::Value *)jarg1;
10834   if (!arg1) {
10835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10836     return 0;
10837   }
10838   {
10839     try {
10840       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
10841     } CALL_CATCH_EXCEPTION(0);
10842   }
10843
10844   jresult = (void *)result;
10845   return jresult;
10846 }
10847
10848
10849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
10850   void * jresult ;
10851   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10852   Dali::Property::Value *arg2 = 0 ;
10853   Dali::Property::Value *result = 0 ;
10854
10855   arg1 = (Dali::Property::Value *)jarg1;
10856   arg2 = (Dali::Property::Value *)jarg2;
10857   if (!arg2) {
10858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10859     return 0;
10860   }
10861   {
10862     try {
10863       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
10864     } CALL_CATCH_EXCEPTION(0);
10865   }
10866
10867   jresult = (void *)result;
10868   return jresult;
10869 }
10870
10871
10872 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_EqualTo(void * jarg1, void * jarg2) {
10873   bool jresult;
10874   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10875   Dali::Property::Value *arg2 = 0 ;
10876   bool result;
10877
10878   arg1 = (Dali::Property::Value *)jarg1;
10879   arg2 = (Dali::Property::Value *)jarg2;
10880   if (!arg2) {
10881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10882     return 0;
10883   }
10884   {
10885     try {
10886       result = (bool)((Dali::Property::Value const *)arg1)->operator ==((Dali::Property::Value const &)*arg2);
10887     } CALL_CATCH_EXCEPTION(0);
10888   }
10889
10890   jresult = result;
10891   return jresult;
10892 }
10893
10894 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_NotEqualTo(void * jarg1, void * jarg2) {
10895   bool jresult;
10896   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10897   Dali::Property::Value *arg2 = 0 ;
10898   bool result;
10899
10900   arg1 = (Dali::Property::Value *)jarg1;
10901   arg2 = (Dali::Property::Value *)jarg2;
10902   if (!arg2) {
10903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10904     return 0;
10905   }
10906   {
10907     try {
10908       result = (bool)((Dali::Property::Value const *)arg1)->operator !=((Dali::Property::Value const &)*arg2);
10909     } CALL_CATCH_EXCEPTION(0);
10910   }
10911
10912   jresult = result;
10913   return jresult;
10914 }
10915
10916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
10917   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10918
10919   arg1 = (Dali::Property::Value *)jarg1;
10920   {
10921     try {
10922       delete arg1;
10923     } CALL_CATCH_EXCEPTION();
10924   }
10925
10926 }
10927
10928
10929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
10930   int jresult ;
10931   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10932   Dali::Property::Type result;
10933
10934   arg1 = (Dali::Property::Value *)jarg1;
10935   {
10936     try {
10937       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
10938     } CALL_CATCH_EXCEPTION(0);
10939   }
10940
10941   jresult = (int)result;
10942   return jresult;
10943 }
10944
10945
10946 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, bool * jarg2) {
10947   bool jresult ;
10948   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10949   bool *arg2 = 0 ;
10950   bool result;
10951
10952   arg1 = (Dali::Property::Value *)jarg1;
10953   arg2 = (bool *)jarg2;
10954   {
10955     try {
10956       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
10957     } CALL_CATCH_EXCEPTION(0);
10958   }
10959
10960   jresult = result;
10961   return jresult;
10962 }
10963
10964
10965 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
10966   bool jresult ;
10967   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10968   float *arg2 = 0 ;
10969   bool result;
10970
10971   arg1 = (Dali::Property::Value *)jarg1;
10972   arg2 = (float *)jarg2;
10973   {
10974     try {
10975       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
10976     } CALL_CATCH_EXCEPTION(0);
10977   }
10978
10979   jresult = result;
10980   return jresult;
10981 }
10982
10983
10984 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
10985   bool jresult ;
10986   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10987   int *arg2 = 0 ;
10988   bool result;
10989
10990   arg1 = (Dali::Property::Value *)jarg1;
10991   arg2 = (int *)jarg2;
10992   {
10993     try {
10994       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
10995     } CALL_CATCH_EXCEPTION(0);
10996   }
10997
10998   jresult = result;
10999   return jresult;
11000 }
11001
11002
11003 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
11004   bool jresult ;
11005   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11006   Dali::Rect< int > *arg2 = 0 ;
11007   bool result;
11008
11009   arg1 = (Dali::Property::Value *)jarg1;
11010   arg2 = (Dali::Rect< int > *)jarg2;
11011   if (!arg2) {
11012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
11013     return 0;
11014   }
11015   {
11016     try {
11017       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11018     } CALL_CATCH_EXCEPTION(0);
11019   }
11020
11021   jresult = result;
11022   return jresult;
11023 }
11024
11025
11026 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
11027   bool jresult ;
11028   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11029   Dali::Vector2 *arg2 = 0 ;
11030   bool result;
11031
11032   arg1 = (Dali::Property::Value *)jarg1;
11033   arg2 = (Dali::Vector2 *)jarg2;
11034   if (!arg2) {
11035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
11036     return 0;
11037   }
11038   {
11039     try {
11040       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11041     } CALL_CATCH_EXCEPTION(0);
11042   }
11043
11044   jresult = result;
11045   return jresult;
11046 }
11047
11048
11049 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
11050   bool jresult ;
11051   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11052   Dali::Vector3 *arg2 = 0 ;
11053   bool result;
11054
11055   arg1 = (Dali::Property::Value *)jarg1;
11056   arg2 = (Dali::Vector3 *)jarg2;
11057   if (!arg2) {
11058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11059     return 0;
11060   }
11061   {
11062     try {
11063       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11064     } CALL_CATCH_EXCEPTION(0);
11065   }
11066
11067   jresult = result;
11068   return jresult;
11069 }
11070
11071
11072 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
11073   bool jresult ;
11074   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11075   Dali::Vector4 *arg2 = 0 ;
11076   bool result;
11077
11078   arg1 = (Dali::Property::Value *)jarg1;
11079   arg2 = (Dali::Vector4 *)jarg2;
11080   if (!arg2) {
11081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
11082     return 0;
11083   }
11084   {
11085     try {
11086       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11087     } CALL_CATCH_EXCEPTION(0);
11088   }
11089
11090   jresult = result;
11091   return jresult;
11092 }
11093
11094
11095 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
11096   bool jresult ;
11097   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11098   Dali::Matrix3 *arg2 = 0 ;
11099   bool result;
11100
11101   arg1 = (Dali::Property::Value *)jarg1;
11102   arg2 = (Dali::Matrix3 *)jarg2;
11103   if (!arg2) {
11104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
11105     return 0;
11106   }
11107   {
11108     try {
11109       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11110     } CALL_CATCH_EXCEPTION(0);
11111   }
11112
11113   jresult = result;
11114   return jresult;
11115 }
11116
11117
11118 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
11119   bool jresult ;
11120   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11121   Dali::Matrix *arg2 = 0 ;
11122   bool result;
11123
11124   arg1 = (Dali::Property::Value *)jarg1;
11125   arg2 = (Dali::Matrix *)jarg2;
11126   if (!arg2) {
11127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11128     return 0;
11129   }
11130   {
11131     try {
11132       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11133     } CALL_CATCH_EXCEPTION(0);
11134   }
11135
11136   jresult = result;
11137   return jresult;
11138 }
11139
11140
11141 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
11142   bool jresult ;
11143   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11144   Dali::AngleAxis *arg2 = 0 ;
11145   bool result;
11146
11147   arg1 = (Dali::Property::Value *)jarg1;
11148   arg2 = (Dali::AngleAxis *)jarg2;
11149   if (!arg2) {
11150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
11151     return 0;
11152   }
11153   {
11154     try {
11155       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11156     } CALL_CATCH_EXCEPTION(0);
11157   }
11158
11159   jresult = result;
11160   return jresult;
11161 }
11162
11163
11164 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
11165   bool jresult ;
11166   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11167   Dali::Quaternion *arg2 = 0 ;
11168   bool result;
11169
11170   arg1 = (Dali::Property::Value *)jarg1;
11171   arg2 = (Dali::Quaternion *)jarg2;
11172   if (!arg2) {
11173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11174     return 0;
11175   }
11176   {
11177     try {
11178       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11179     } CALL_CATCH_EXCEPTION(0);
11180   }
11181
11182   jresult = result;
11183   return jresult;
11184 }
11185
11186
11187 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
11188   bool jresult ;
11189   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11190   std::string *arg2 = 0 ;
11191   bool result;
11192
11193   arg1 = (Dali::Property::Value *)jarg1;
11194
11195   //typemap in
11196   std::string temp;
11197   arg2 = &temp;
11198
11199   {
11200     try {
11201       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11202     } CALL_CATCH_EXCEPTION(0);
11203   }
11204
11205   jresult = result;
11206
11207   //Typemap argout in c++ file.
11208   //This will convert c++ string to c# string
11209   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
11210
11211   return jresult;
11212 }
11213
11214
11215 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
11216   bool jresult ;
11217   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11218   Dali::Property::Array *arg2 = 0 ;
11219   bool result;
11220
11221   arg1 = (Dali::Property::Value *)jarg1;
11222   arg2 = (Dali::Property::Array *)jarg2;
11223   if (!arg2) {
11224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
11225     return 0;
11226   }
11227   {
11228     try {
11229       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11230     } CALL_CATCH_EXCEPTION(0);
11231   }
11232
11233   jresult = result;
11234   return jresult;
11235 }
11236
11237
11238 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
11239   bool jresult ;
11240   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11241   Dali::Property::Map *arg2 = 0 ;
11242   bool result;
11243
11244   arg1 = (Dali::Property::Value *)jarg1;
11245   arg2 = (Dali::Property::Map *)jarg2;
11246   if (!arg2) {
11247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
11248     return 0;
11249   }
11250   {
11251     try {
11252       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11253     } CALL_CATCH_EXCEPTION(0);
11254   }
11255
11256   jresult = result;
11257   return jresult;
11258 }
11259
11260
11261 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
11262   bool jresult ;
11263   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11264   Extents *arg2 = 0 ;
11265   bool result;
11266
11267   arg1 = (Dali::Property::Value *)jarg1;
11268   arg2 = (Extents *)jarg2;
11269   if (!arg2) {
11270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
11271     return 0;
11272   }
11273   {
11274     try {
11275       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11276     } CALL_CATCH_EXCEPTION(0);
11277   }
11278   jresult = result;
11279   return jresult;
11280 }
11281
11282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
11283   void * jresult ;
11284   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11285   Dali::Property::Array *result = 0 ;
11286
11287   arg1 = (Dali::Property::Value *)jarg1;
11288   {
11289     try {
11290       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
11291     } CALL_CATCH_EXCEPTION(0);
11292   }
11293
11294   jresult = (void *)result;
11295   return jresult;
11296 }
11297
11298
11299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
11300   void * jresult ;
11301   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11302   Dali::Property::Map *result = 0 ;
11303
11304   arg1 = (Dali::Property::Value *)jarg1;
11305   {
11306     try {
11307       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
11308     } CALL_CATCH_EXCEPTION(0);
11309   }
11310
11311   jresult = (void *)result;
11312   return jresult;
11313 }
11314
11315
11316 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
11317   char * jresult ;
11318   Dali::Property::Type arg1 ;
11319   char *result = 0 ;
11320
11321   arg1 = (Dali::Property::Type)jarg1;
11322   {
11323     try {
11324       result = (char *)Dali::PropertyTypes::GetName(arg1);
11325     } CALL_CATCH_EXCEPTION(0);
11326   }
11327
11328   jresult = SWIG_csharp_string_callback((const char *)result);
11329   return jresult;
11330 }
11331
11332
11333 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
11334   bool jresult ;
11335   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11336   std::string *arg2 = 0 ;
11337   Dali::Property::Map *arg3 = 0 ;
11338   bool result;
11339
11340   arg1 = (Dali::BaseObject *)jarg1;
11341   if (!jarg2) {
11342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11343     return 0;
11344   }
11345   std::string arg2_str(jarg2);
11346   arg2 = &arg2_str;
11347   arg3 = (Dali::Property::Map *)jarg3;
11348   if (!arg3) {
11349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
11350     return 0;
11351   }
11352   {
11353     try {
11354       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
11355     } CALL_CATCH_EXCEPTION(0);
11356   }
11357
11358   jresult = result;
11359
11360   //argout typemap for const std::string&
11361
11362   return jresult;
11363 }
11364
11365
11366 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
11367   char * jresult ;
11368   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11369   std::string *result = 0 ;
11370
11371   arg1 = (Dali::BaseObject *)jarg1;
11372   {
11373     try {
11374       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
11375     } CALL_CATCH_EXCEPTION(0);
11376   }
11377
11378   jresult = SWIG_csharp_string_callback(result->c_str());
11379   return jresult;
11380 }
11381
11382
11383 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
11384   bool jresult ;
11385   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11386   Dali::TypeInfo *arg2 = 0 ;
11387   bool result;
11388
11389   arg1 = (Dali::BaseObject *)jarg1;
11390   arg2 = (Dali::TypeInfo *)jarg2;
11391   if (!arg2) {
11392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
11393     return 0;
11394   }
11395   {
11396     try {
11397       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
11398     } CALL_CATCH_EXCEPTION(0);
11399   }
11400
11401   jresult = result;
11402   return jresult;
11403 }
11404
11405
11406 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
11407   bool jresult ;
11408   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11409   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
11410   std::string *arg3 = 0 ;
11411   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
11412   bool result;
11413
11414   arg1 = (Dali::BaseObject *)jarg1;
11415   arg2 = (ConnectionTrackerInterface *)jarg2;
11416   if (!jarg3) {
11417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11418     return 0;
11419   }
11420   std::string arg3_str(jarg3);
11421   arg3 = &arg3_str;
11422   arg4 = (FunctorDelegate *)jarg4;
11423   {
11424     try {
11425       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
11426     } CALL_CATCH_EXCEPTION(0);
11427   }
11428
11429   jresult = result;
11430
11431   //argout typemap for const std::string&
11432
11433   return jresult;
11434 }
11435
11436
11437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
11438   void * jresult ;
11439   Dali::BaseHandle *arg1 = 0 ;
11440   Dali::BaseObject *result = 0 ;
11441
11442   arg1 = (Dali::BaseHandle *)jarg1;
11443   if (!arg1) {
11444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11445     return 0;
11446   }
11447   {
11448     try {
11449       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
11450     } CALL_CATCH_EXCEPTION(0);
11451   }
11452
11453   jresult = (void *)result;
11454   return jresult;
11455 }
11456
11457
11458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
11459   void * jresult ;
11460   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11461   Dali::BaseHandle *result = 0 ;
11462
11463   arg1 = (Dali::BaseObject *)jarg1;
11464   {
11465     try {
11466       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
11467     } CALL_CATCH_EXCEPTION(0);
11468   }
11469
11470   jresult = (void *)result;
11471   return jresult;
11472 }
11473
11474
11475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
11476   void * jresult ;
11477   Dali::BaseHandle *result = 0 ;
11478
11479   {
11480     try {
11481       result = (Dali::BaseHandle *)new Dali::BaseHandle();
11482     } CALL_CATCH_EXCEPTION(0);
11483   }
11484
11485   jresult = (void *)result;
11486   return jresult;
11487 }
11488
11489
11490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
11491   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11492
11493   arg1 = (Dali::BaseHandle *)jarg1;
11494   {
11495     try {
11496       delete arg1;
11497     } CALL_CATCH_EXCEPTION();
11498   }
11499
11500 }
11501
11502
11503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
11504   void * jresult ;
11505   Dali::BaseHandle *arg1 = 0 ;
11506   Dali::BaseHandle *result = 0 ;
11507
11508   arg1 = (Dali::BaseHandle *)jarg1;
11509   if (!arg1) {
11510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11511     return 0;
11512   }
11513   {
11514     try {
11515       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
11516     } CALL_CATCH_EXCEPTION(0);
11517   }
11518
11519   jresult = (void *)result;
11520   return jresult;
11521 }
11522
11523
11524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
11525   void * jresult ;
11526   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11527   Dali::BaseHandle *arg2 = 0 ;
11528   Dali::BaseHandle *result = 0 ;
11529
11530   arg1 = (Dali::BaseHandle *)jarg1;
11531   arg2 = (Dali::BaseHandle *)jarg2;
11532   if (!arg2) {
11533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11534     return 0;
11535   }
11536   {
11537     try {
11538       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
11539     } CALL_CATCH_EXCEPTION(0);
11540   }
11541
11542   jresult = (void *)result;
11543   return jresult;
11544 }
11545
11546
11547 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
11548   bool jresult ;
11549   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11550   std::string *arg2 = 0 ;
11551   Dali::Property::Map *arg3 = 0 ;
11552   bool result;
11553
11554   arg1 = (Dali::BaseHandle *)jarg1;
11555   if (!jarg2) {
11556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11557     return 0;
11558   }
11559   std::string arg2_str(jarg2);
11560   arg2 = &arg2_str;
11561   arg3 = (Dali::Property::Map *)jarg3;
11562   if (!arg3) {
11563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
11564     return 0;
11565   }
11566   {
11567     try {
11568       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
11569     } CALL_CATCH_EXCEPTION(0);
11570   }
11571
11572   jresult = result;
11573
11574   //argout typemap for const std::string&
11575
11576   return jresult;
11577 }
11578
11579
11580 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
11581   char * jresult ;
11582   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11583   std::string *result = 0 ;
11584
11585   arg1 = (Dali::BaseHandle *)jarg1;
11586   {
11587     try {
11588       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
11589     } CALL_CATCH_EXCEPTION(0);
11590   }
11591
11592   jresult = SWIG_csharp_string_callback(result->c_str());
11593   return jresult;
11594 }
11595
11596
11597 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
11598   bool jresult ;
11599   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11600   Dali::TypeInfo *arg2 = 0 ;
11601   bool result;
11602
11603   arg1 = (Dali::BaseHandle *)jarg1;
11604   arg2 = (Dali::TypeInfo *)jarg2;
11605   if (!arg2) {
11606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
11607     return 0;
11608   }
11609   {
11610     try {
11611       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
11612     } CALL_CATCH_EXCEPTION(0);
11613   }
11614
11615   jresult = result;
11616   return jresult;
11617 }
11618
11619
11620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
11621   void * jresult ;
11622   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11623   Dali::BaseObject *result = 0 ;
11624
11625   arg1 = (Dali::BaseHandle *)jarg1;
11626   {
11627     try {
11628       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
11629     } CALL_CATCH_EXCEPTION(0);
11630   }
11631
11632   jresult = (void *)result;
11633   return jresult;
11634 }
11635
11636
11637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
11638   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11639
11640   arg1 = (Dali::BaseHandle *)jarg1;
11641   {
11642     try {
11643       (arg1)->Reset();
11644     } CALL_CATCH_EXCEPTION();
11645   }
11646
11647 }
11648
11649
11650 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
11651   bool jresult ;
11652   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11653   Dali::BaseHandle *arg2 = 0 ;
11654   bool result;
11655
11656   arg1 = (Dali::BaseHandle *)jarg1;
11657   arg2 = (Dali::BaseHandle *)jarg2;
11658   if (!arg2) {
11659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11660     return 0;
11661   }
11662   {
11663     try {
11664       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
11665     } CALL_CATCH_EXCEPTION(0);
11666   }
11667
11668   jresult = result;
11669   return jresult;
11670 }
11671
11672
11673 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
11674   bool jresult ;
11675   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11676   Dali::BaseHandle *arg2 = 0 ;
11677   bool result;
11678
11679   arg1 = (Dali::BaseHandle *)jarg1;
11680   arg2 = (Dali::BaseHandle *)jarg2;
11681   if (!arg2) {
11682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11683     return 0;
11684   }
11685   {
11686     try {
11687       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
11688     } CALL_CATCH_EXCEPTION(0);
11689   }
11690
11691   jresult = result;
11692   return jresult;
11693 }
11694
11695
11696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
11697   void * jresult ;
11698   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11699   Dali::RefObject *result = 0 ;
11700
11701   arg1 = (Dali::BaseHandle *)jarg1;
11702   {
11703     try {
11704       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
11705     } CALL_CATCH_EXCEPTION(0);
11706   }
11707
11708   jresult = (void *)result;
11709   return jresult;
11710 }
11711
11712
11713 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
11714   bool jresult ;
11715   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11716   bool result;
11717
11718   arg1 = (Dali::BaseHandle *)jarg1;
11719   {
11720     try {
11721       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
11722     } CALL_CATCH_EXCEPTION(0);
11723   }
11724
11725   jresult = result;
11726   return jresult;
11727 }
11728
11729
11730 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
11731   bool jresult ;
11732   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11733   Dali::BaseHandle *arg2 = 0 ;
11734   bool result;
11735
11736   arg1 = (Dali::BaseHandle *)jarg1;
11737   arg2 = (Dali::BaseHandle *)jarg2;
11738   if (!arg2) {
11739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11740     return 0;
11741   }
11742   {
11743     try {
11744       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
11745     } CALL_CATCH_EXCEPTION(0);
11746   }
11747
11748   jresult = result;
11749   return jresult;
11750 }
11751
11752
11753 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
11754   bool jresult ;
11755   Dali::BaseHandle *arg1 = 0 ;
11756   Dali::BaseHandle *arg2 = 0 ;
11757   bool result;
11758
11759   arg1 = (Dali::BaseHandle *)jarg1;
11760   if (!arg1) {
11761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11762     return 0;
11763   }
11764   arg2 = (Dali::BaseHandle *)jarg2;
11765   if (!arg2) {
11766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11767     return 0;
11768   }
11769   {
11770     try {
11771       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
11772     } CALL_CATCH_EXCEPTION(0);
11773   }
11774
11775   jresult = result;
11776   return jresult;
11777 }
11778
11779
11780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
11781   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
11782
11783   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
11784   {
11785     try {
11786       delete arg1;
11787     } CALL_CATCH_EXCEPTION();
11788   }
11789
11790 }
11791
11792
11793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
11794   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
11795   SlotObserver *arg2 = (SlotObserver *) 0 ;
11796   CallbackBase *arg3 = (CallbackBase *) 0 ;
11797
11798   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
11799   arg2 = (SlotObserver *)jarg2;
11800   arg3 = (CallbackBase *)jarg3;
11801   {
11802     try {
11803       (arg1)->SignalConnected(arg2,arg3);
11804     } CALL_CATCH_EXCEPTION();
11805   }
11806
11807 }
11808
11809
11810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
11811   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
11812
11813   arg1 = (Dali::SignalObserver *)jarg1;
11814   {
11815     try {
11816       delete arg1;
11817     } CALL_CATCH_EXCEPTION();
11818   }
11819
11820 }
11821
11822
11823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
11824   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
11825   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
11826   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
11827
11828   arg1 = (Dali::SignalObserver *)jarg1;
11829   arg2 = (Dali::SlotObserver *)jarg2;
11830   arg3 = (Dali::CallbackBase *)jarg3;
11831   {
11832     try {
11833       (arg1)->SignalDisconnected(arg2,arg3);
11834     } CALL_CATCH_EXCEPTION();
11835   }
11836
11837 }
11838
11839
11840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
11841   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
11842
11843   arg1 = (Dali::SlotObserver *)jarg1;
11844   {
11845     try {
11846       delete arg1;
11847     } CALL_CATCH_EXCEPTION();
11848   }
11849
11850 }
11851
11852
11853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
11854   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
11855   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
11856
11857   arg1 = (Dali::SlotObserver *)jarg1;
11858   arg2 = (Dali::CallbackBase *)jarg2;
11859   {
11860     try {
11861       (arg1)->SlotDisconnected(arg2);
11862     } CALL_CATCH_EXCEPTION();
11863   }
11864
11865 }
11866
11867
11868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
11869   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
11870
11871   arg1 = (Dali::ConnectionTracker *)jarg1;
11872   {
11873     try {
11874       delete arg1;
11875     } CALL_CATCH_EXCEPTION();
11876   }
11877
11878 }
11879
11880
11881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
11882   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
11883
11884   arg1 = (Dali::ConnectionTracker *)jarg1;
11885   {
11886     try {
11887       (arg1)->DisconnectAll();
11888     } CALL_CATCH_EXCEPTION();
11889   }
11890
11891 }
11892
11893
11894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
11895   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
11896   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
11897   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
11898
11899   arg1 = (Dali::ConnectionTracker *)jarg1;
11900   arg2 = (Dali::SlotObserver *)jarg2;
11901   arg3 = (Dali::CallbackBase *)jarg3;
11902   {
11903     try {
11904       (arg1)->SignalConnected(arg2,arg3);
11905     } CALL_CATCH_EXCEPTION();
11906   }
11907
11908 }
11909
11910
11911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
11912   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
11913   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
11914   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
11915
11916   arg1 = (Dali::ConnectionTracker *)jarg1;
11917   arg2 = (Dali::SlotObserver *)jarg2;
11918   arg3 = (Dali::CallbackBase *)jarg3;
11919   {
11920     try {
11921       (arg1)->SignalDisconnected(arg2,arg3);
11922     } CALL_CATCH_EXCEPTION();
11923   }
11924
11925 }
11926
11927
11928 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
11929   unsigned long jresult ;
11930   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
11931   std::size_t result;
11932
11933   arg1 = (Dali::ConnectionTracker *)jarg1;
11934   {
11935     try {
11936       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
11937     } CALL_CATCH_EXCEPTION(0);
11938   }
11939
11940   jresult = (unsigned long)result;
11941   return jresult;
11942 }
11943
11944
11945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
11946   void * jresult ;
11947   Dali::ObjectRegistry *result = 0 ;
11948
11949   {
11950     try {
11951       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
11952     } CALL_CATCH_EXCEPTION(0);
11953   }
11954
11955   jresult = (void *)result;
11956   return jresult;
11957 }
11958
11959
11960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
11961   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
11962
11963   arg1 = (Dali::ObjectRegistry *)jarg1;
11964   {
11965     try {
11966       delete arg1;
11967     } CALL_CATCH_EXCEPTION();
11968   }
11969
11970 }
11971
11972
11973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
11974   void * jresult ;
11975   Dali::ObjectRegistry *arg1 = 0 ;
11976   Dali::ObjectRegistry *result = 0 ;
11977
11978   arg1 = (Dali::ObjectRegistry *)jarg1;
11979   if (!arg1) {
11980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
11981     return 0;
11982   }
11983   {
11984     try {
11985       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
11986     } CALL_CATCH_EXCEPTION(0);
11987   }
11988
11989   jresult = (void *)result;
11990   return jresult;
11991 }
11992
11993
11994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
11995   void * jresult ;
11996   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
11997   Dali::ObjectRegistry *arg2 = 0 ;
11998   Dali::ObjectRegistry *result = 0 ;
11999
12000   arg1 = (Dali::ObjectRegistry *)jarg1;
12001   arg2 = (Dali::ObjectRegistry *)jarg2;
12002   if (!arg2) {
12003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
12004     return 0;
12005   }
12006   {
12007     try {
12008       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
12009     } CALL_CATCH_EXCEPTION(0);
12010   }
12011
12012   jresult = (void *)result;
12013   return jresult;
12014 }
12015
12016
12017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
12018   void * jresult ;
12019   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
12020   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
12021
12022   arg1 = (Dali::ObjectRegistry *)jarg1;
12023   {
12024     try {
12025       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
12026     } CALL_CATCH_EXCEPTION(0);
12027   }
12028
12029   jresult = (void *)result;
12030   return jresult;
12031 }
12032
12033
12034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
12035   void * jresult ;
12036   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
12037   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
12038
12039   arg1 = (Dali::ObjectRegistry *)jarg1;
12040   {
12041     try {
12042       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
12043     } CALL_CATCH_EXCEPTION(0);
12044   }
12045
12046   jresult = (void *)result;
12047   return jresult;
12048 }
12049
12050
12051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
12052   void * jresult ;
12053   Dali::PropertyCondition *result = 0 ;
12054
12055   {
12056     try {
12057       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
12058     } CALL_CATCH_EXCEPTION(0);
12059   }
12060
12061   jresult = (void *)result;
12062   return jresult;
12063 }
12064
12065
12066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
12067   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
12068
12069   arg1 = (Dali::PropertyCondition *)jarg1;
12070   {
12071     try {
12072       delete arg1;
12073     } CALL_CATCH_EXCEPTION();
12074   }
12075
12076 }
12077
12078
12079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
12080   void * jresult ;
12081   Dali::PropertyCondition *arg1 = 0 ;
12082   Dali::PropertyCondition *result = 0 ;
12083
12084   arg1 = (Dali::PropertyCondition *)jarg1;
12085   if (!arg1) {
12086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
12087     return 0;
12088   }
12089   {
12090     try {
12091       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
12092     } CALL_CATCH_EXCEPTION(0);
12093   }
12094
12095   jresult = (void *)result;
12096   return jresult;
12097 }
12098
12099
12100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
12101   void * jresult ;
12102   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
12103   Dali::PropertyCondition *arg2 = 0 ;
12104   Dali::PropertyCondition *result = 0 ;
12105
12106   arg1 = (Dali::PropertyCondition *)jarg1;
12107   arg2 = (Dali::PropertyCondition *)jarg2;
12108   if (!arg2) {
12109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
12110     return 0;
12111   }
12112   {
12113     try {
12114       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
12115     } CALL_CATCH_EXCEPTION(0);
12116   }
12117
12118   jresult = (void *)result;
12119   return jresult;
12120 }
12121
12122
12123 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
12124   unsigned long jresult ;
12125   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
12126   std::size_t result;
12127
12128   arg1 = (Dali::PropertyCondition *)jarg1;
12129   {
12130     try {
12131       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
12132     } CALL_CATCH_EXCEPTION(0);
12133   }
12134   jresult = (unsigned long)result;
12135   return jresult;
12136 }
12137
12138
12139 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
12140   float jresult ;
12141   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
12142   std::size_t arg2 ;
12143   float result;
12144
12145   arg1 = (Dali::PropertyCondition *)jarg1;
12146   arg2 = (std::size_t)jarg2;
12147   {
12148     try {
12149       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
12150     } CALL_CATCH_EXCEPTION(0);
12151   }
12152   jresult = result;
12153   return jresult;
12154 }
12155
12156
12157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
12158   void * jresult ;
12159   float arg1 ;
12160   Dali::PropertyCondition result;
12161
12162   arg1 = (float)jarg1;
12163   {
12164     try {
12165       result = Dali::LessThanCondition(arg1);
12166     } CALL_CATCH_EXCEPTION(0);
12167   }
12168
12169   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12170   return jresult;
12171 }
12172
12173
12174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
12175   void * jresult ;
12176   float arg1 ;
12177   Dali::PropertyCondition result;
12178
12179   arg1 = (float)jarg1;
12180   {
12181     try {
12182       result = Dali::GreaterThanCondition(arg1);
12183     } CALL_CATCH_EXCEPTION(0);
12184   }
12185
12186   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12187   return jresult;
12188 }
12189
12190
12191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
12192   void * jresult ;
12193   float arg1 ;
12194   float arg2 ;
12195   Dali::PropertyCondition result;
12196
12197   arg1 = (float)jarg1;
12198   arg2 = (float)jarg2;
12199   {
12200     try {
12201       result = Dali::InsideCondition(arg1,arg2);
12202     } CALL_CATCH_EXCEPTION(0);
12203   }
12204
12205   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12206   return jresult;
12207 }
12208
12209
12210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
12211   void * jresult ;
12212   float arg1 ;
12213   float arg2 ;
12214   Dali::PropertyCondition result;
12215
12216   arg1 = (float)jarg1;
12217   arg2 = (float)jarg2;
12218   {
12219     try {
12220       result = Dali::OutsideCondition(arg1,arg2);
12221     } CALL_CATCH_EXCEPTION(0);
12222   }
12223
12224   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12225   return jresult;
12226 }
12227
12228
12229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
12230   void * jresult ;
12231   float arg1 ;
12232   float arg2 ;
12233   Dali::PropertyCondition result;
12234
12235   arg1 = (float)jarg1;
12236   arg2 = (float)jarg2;
12237   {
12238     try {
12239       result = Dali::StepCondition(arg1,arg2);
12240     } CALL_CATCH_EXCEPTION(0);
12241   }
12242
12243   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12244   return jresult;
12245 }
12246
12247
12248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
12249   void * jresult ;
12250   float arg1 ;
12251   Dali::PropertyCondition result;
12252
12253   arg1 = (float)jarg1;
12254   {
12255     try {
12256       result = Dali::StepCondition(arg1);
12257     } CALL_CATCH_EXCEPTION(0);
12258   }
12259
12260   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12261   return jresult;
12262 }
12263
12264
12265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
12266   void * jresult ;
12267   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
12268   Dali::PropertyCondition result;
12269
12270   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
12271   if (!arg1) {
12272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
12273     return 0;
12274   }
12275   {
12276     try {
12277       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
12278     } CALL_CATCH_EXCEPTION(0);
12279   }
12280
12281   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12282   return jresult;
12283 }
12284
12285
12286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
12287   void * jresult ;
12288   Dali::PropertyNotification *result = 0 ;
12289
12290   {
12291     try {
12292       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
12293     } CALL_CATCH_EXCEPTION(0);
12294   }
12295
12296   jresult = (void *)result;
12297   return jresult;
12298 }
12299
12300
12301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
12302   void * jresult ;
12303   Dali::BaseHandle arg1 ;
12304   Dali::BaseHandle *argp1 ;
12305   Dali::PropertyNotification result;
12306
12307   argp1 = (Dali::BaseHandle *)jarg1;
12308   if (!argp1) {
12309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
12310     return 0;
12311   }
12312   arg1 = *argp1;
12313   {
12314     try {
12315       result = Dali::PropertyNotification::DownCast(arg1);
12316     } CALL_CATCH_EXCEPTION(0);
12317   }
12318
12319   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
12320   return jresult;
12321 }
12322
12323
12324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
12325   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12326
12327   arg1 = (Dali::PropertyNotification *)jarg1;
12328   {
12329     try {
12330       delete arg1;
12331     } CALL_CATCH_EXCEPTION();
12332   }
12333
12334 }
12335
12336
12337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
12338   void * jresult ;
12339   Dali::PropertyNotification *arg1 = 0 ;
12340   Dali::PropertyNotification *result = 0 ;
12341
12342   arg1 = (Dali::PropertyNotification *)jarg1;
12343   if (!arg1) {
12344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
12345     return 0;
12346   }
12347   {
12348     try {
12349       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
12350     } CALL_CATCH_EXCEPTION(0);
12351   }
12352
12353   jresult = (void *)result;
12354   return jresult;
12355 }
12356
12357
12358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
12359   void * jresult ;
12360   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12361   Dali::PropertyNotification *arg2 = 0 ;
12362   Dali::PropertyNotification *result = 0 ;
12363
12364   arg1 = (Dali::PropertyNotification *)jarg1;
12365   arg2 = (Dali::PropertyNotification *)jarg2;
12366   if (!arg2) {
12367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
12368     return 0;
12369   }
12370   {
12371     try {
12372       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
12373     } CALL_CATCH_EXCEPTION(0);
12374   }
12375
12376   jresult = (void *)result;
12377   return jresult;
12378 }
12379
12380
12381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
12382   void * jresult ;
12383   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12384   Dali::PropertyCondition result;
12385
12386   arg1 = (Dali::PropertyNotification *)jarg1;
12387   {
12388     try {
12389       result = (arg1)->GetCondition();
12390     } CALL_CATCH_EXCEPTION(0);
12391   }
12392
12393   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12394   return jresult;
12395 }
12396
12397
12398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
12399   void * jresult ;
12400   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12401   Dali::Handle result;
12402
12403   arg1 = (Dali::PropertyNotification *)jarg1;
12404   {
12405     try {
12406       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
12407     } CALL_CATCH_EXCEPTION(0);
12408   }
12409
12410   jresult = new Dali::Handle((const Dali::Handle &)result);
12411   return jresult;
12412 }
12413
12414
12415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
12416   int jresult ;
12417   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12418   Dali::Property::Index result;
12419
12420   arg1 = (Dali::PropertyNotification *)jarg1;
12421   {
12422     try {
12423       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
12424     } CALL_CATCH_EXCEPTION(0);
12425   }
12426
12427   jresult = result;
12428   return jresult;
12429 }
12430
12431
12432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
12433   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12434   Dali::PropertyNotification::NotifyMode arg2 ;
12435
12436   arg1 = (Dali::PropertyNotification *)jarg1;
12437   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
12438   {
12439     try {
12440       (arg1)->SetNotifyMode(arg2);
12441     } CALL_CATCH_EXCEPTION();
12442   }
12443
12444 }
12445
12446
12447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
12448   int jresult ;
12449   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12450   Dali::PropertyNotification::NotifyMode result;
12451
12452   arg1 = (Dali::PropertyNotification *)jarg1;
12453   {
12454     try {
12455       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
12456     } CALL_CATCH_EXCEPTION(0);
12457   }
12458
12459   jresult = (int)result;
12460   return jresult;
12461 }
12462
12463
12464 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
12465   bool jresult ;
12466   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12467   bool result;
12468
12469   arg1 = (Dali::PropertyNotification *)jarg1;
12470   {
12471     try {
12472       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
12473     } CALL_CATCH_EXCEPTION(0);
12474   }
12475
12476   jresult = result;
12477   return jresult;
12478 }
12479
12480
12481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
12482   void * jresult ;
12483   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12484   Dali::PropertyNotifySignalType *result = 0 ;
12485
12486   arg1 = (Dali::PropertyNotification *)jarg1;
12487   {
12488     try {
12489       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
12490     } CALL_CATCH_EXCEPTION(0);
12491   }
12492
12493   jresult = (void *)result;
12494   return jresult;
12495 }
12496
12497
12498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
12499   void * jresult ;
12500   Dali::Handle *result = 0 ;
12501
12502   {
12503     try {
12504       result = (Dali::Handle *)new Dali::Handle();
12505     } CALL_CATCH_EXCEPTION(0);
12506   }
12507
12508   jresult = (void *)result;
12509   return jresult;
12510 }
12511
12512
12513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
12514   void * jresult ;
12515   Dali::Handle result;
12516
12517   {
12518     try {
12519       result = Dali::Handle::New();
12520     } CALL_CATCH_EXCEPTION(0);
12521   }
12522
12523   jresult = new Dali::Handle((const Dali::Handle &)result);
12524   return jresult;
12525 }
12526
12527
12528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
12529   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12530
12531   arg1 = (Dali::Handle *)jarg1;
12532   {
12533     try {
12534       delete arg1;
12535     } CALL_CATCH_EXCEPTION();
12536   }
12537
12538 }
12539
12540
12541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
12542   void * jresult ;
12543   Dali::Handle *arg1 = 0 ;
12544   Dali::Handle *result = 0 ;
12545
12546   arg1 = (Dali::Handle *)jarg1;
12547   if (!arg1) {
12548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
12549     return 0;
12550   }
12551   {
12552     try {
12553       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
12554     } CALL_CATCH_EXCEPTION(0);
12555   }
12556
12557   jresult = (void *)result;
12558   return jresult;
12559 }
12560
12561
12562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
12563   void * jresult ;
12564   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12565   Dali::Handle *arg2 = 0 ;
12566   Dali::Handle *result = 0 ;
12567
12568   arg1 = (Dali::Handle *)jarg1;
12569   arg2 = (Dali::Handle *)jarg2;
12570   if (!arg2) {
12571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
12572     return 0;
12573   }
12574   {
12575     try {
12576       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
12577     } CALL_CATCH_EXCEPTION(0);
12578   }
12579
12580   jresult = (void *)result;
12581   return jresult;
12582 }
12583
12584
12585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
12586   void * jresult ;
12587   Dali::BaseHandle arg1 ;
12588   Dali::BaseHandle *argp1 ;
12589   Dali::Handle result;
12590
12591   argp1 = (Dali::BaseHandle *)jarg1;
12592   if (!argp1) {
12593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
12594     return 0;
12595   }
12596   arg1 = *argp1;
12597   {
12598     try {
12599       result = Dali::Handle::DownCast(arg1);
12600     } CALL_CATCH_EXCEPTION(0);
12601   }
12602
12603   jresult = new Dali::Handle((const Dali::Handle &)result);
12604   return jresult;
12605 }
12606
12607
12608 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
12609   bool jresult ;
12610   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12611   Dali::Handle::Capability arg2 ;
12612   bool result;
12613
12614   arg1 = (Dali::Handle *)jarg1;
12615   arg2 = (Dali::Handle::Capability)jarg2;
12616   {
12617     try {
12618       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
12619     } CALL_CATCH_EXCEPTION(0);
12620   }
12621
12622   jresult = result;
12623   return jresult;
12624 }
12625
12626
12627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
12628   unsigned int jresult ;
12629   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12630   unsigned int result;
12631
12632   arg1 = (Dali::Handle *)jarg1;
12633   {
12634     try {
12635       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
12636     } CALL_CATCH_EXCEPTION(0);
12637   }
12638
12639   jresult = result;
12640   return jresult;
12641 }
12642
12643
12644 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
12645   char * jresult ;
12646   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12647   Dali::Property::Index arg2 ;
12648   std::string result;
12649
12650   arg1 = (Dali::Handle *)jarg1;
12651   arg2 = (Dali::Property::Index)jarg2;
12652   {
12653     try {
12654       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
12655     } CALL_CATCH_EXCEPTION(0);
12656   }
12657
12658   jresult = SWIG_csharp_string_callback((&result)->c_str());
12659   return jresult;
12660 }
12661
12662
12663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
12664   int jresult ;
12665   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12666   std::string *arg2 = 0 ;
12667   Dali::Property::Index result;
12668
12669   arg1 = (Dali::Handle *)jarg1;
12670   if (!jarg2) {
12671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
12672     return 0;
12673   }
12674   std::string arg2_str(jarg2);
12675   arg2 = &arg2_str;
12676   {
12677     try {
12678       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
12679     } CALL_CATCH_EXCEPTION(0);
12680   }
12681
12682   jresult = result;
12683
12684   //argout typemap for const std::string&
12685
12686   return jresult;
12687 }
12688
12689
12690 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
12691   bool jresult ;
12692   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12693   Dali::Property::Index arg2 ;
12694   bool result;
12695
12696   arg1 = (Dali::Handle *)jarg1;
12697   arg2 = (Dali::Property::Index)jarg2;
12698   {
12699     try {
12700       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
12701     } CALL_CATCH_EXCEPTION(0);
12702   }
12703
12704   jresult = result;
12705   return jresult;
12706 }
12707
12708
12709 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
12710   bool jresult ;
12711   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12712   Dali::Property::Index arg2 ;
12713   bool result;
12714
12715   arg1 = (Dali::Handle *)jarg1;
12716   arg2 = (Dali::Property::Index)jarg2;
12717   {
12718     try {
12719       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
12720     } CALL_CATCH_EXCEPTION(0);
12721   }
12722
12723   jresult = result;
12724   return jresult;
12725 }
12726
12727
12728 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
12729   bool jresult ;
12730   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12731   Dali::Property::Index arg2 ;
12732   bool result;
12733
12734   arg1 = (Dali::Handle *)jarg1;
12735   arg2 = (Dali::Property::Index)jarg2;
12736   {
12737     try {
12738       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
12739     } CALL_CATCH_EXCEPTION(0);
12740   }
12741
12742   jresult = result;
12743   return jresult;
12744 }
12745
12746
12747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
12748   int jresult ;
12749   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12750   Dali::Property::Index arg2 ;
12751   Dali::Property::Type result;
12752
12753   arg1 = (Dali::Handle *)jarg1;
12754   arg2 = (Dali::Property::Index)jarg2;
12755   {
12756     try {
12757       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
12758     } CALL_CATCH_EXCEPTION(0);
12759   }
12760
12761   jresult = (int)result;
12762   return jresult;
12763 }
12764
12765
12766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
12767   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12768   Dali::Property::Index arg2 ;
12769   Dali::Property::Value *arg3 = 0 ;
12770
12771   arg1 = (Dali::Handle *)jarg1;
12772   arg2 = (Dali::Property::Index)jarg2;
12773   arg3 = (Dali::Property::Value *)jarg3;
12774   if (!arg3) {
12775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
12776     return ;
12777   }
12778   {
12779     try {
12780       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
12781     } CALL_CATCH_EXCEPTION();
12782   }
12783
12784 }
12785
12786
12787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
12788   int jresult ;
12789   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12790   std::string *arg2 = 0 ;
12791   Dali::Property::Value *arg3 = 0 ;
12792   Dali::Property::Index result;
12793
12794   arg1 = (Dali::Handle *)jarg1;
12795   if (!jarg2) {
12796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
12797     return 0;
12798   }
12799   std::string arg2_str(jarg2);
12800   arg2 = &arg2_str;
12801   arg3 = (Dali::Property::Value *)jarg3;
12802   if (!arg3) {
12803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
12804     return 0;
12805   }
12806   {
12807     try {
12808       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
12809     } CALL_CATCH_EXCEPTION(0);
12810   }
12811
12812   jresult = result;
12813
12814   //argout typemap for const std::string&
12815
12816   return jresult;
12817 }
12818
12819
12820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
12821   int jresult ;
12822   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12823   std::string *arg2 = 0 ;
12824   Dali::Property::Value *arg3 = 0 ;
12825   Dali::Property::AccessMode arg4 ;
12826   Dali::Property::Index result;
12827
12828   arg1 = (Dali::Handle *)jarg1;
12829   if (!jarg2) {
12830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
12831     return 0;
12832   }
12833   std::string arg2_str(jarg2);
12834   arg2 = &arg2_str;
12835   arg3 = (Dali::Property::Value *)jarg3;
12836   if (!arg3) {
12837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
12838     return 0;
12839   }
12840   arg4 = (Dali::Property::AccessMode)jarg4;
12841   {
12842     try {
12843       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
12844     } CALL_CATCH_EXCEPTION(0);
12845   }
12846
12847   jresult = result;
12848
12849   //argout typemap for const std::string&
12850
12851   return jresult;
12852 }
12853
12854
12855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
12856   void * jresult ;
12857   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12858   Dali::Property::Index arg2 ;
12859   Dali::Property::Value result;
12860
12861   arg1 = (Dali::Handle *)jarg1;
12862   arg2 = (Dali::Property::Index)jarg2;
12863   {
12864     try {
12865       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
12866     } CALL_CATCH_EXCEPTION(0);
12867   }
12868
12869   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
12870   return jresult;
12871 }
12872
12873
12874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
12875   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12876   Dali::Property::IndexContainer *arg2 = 0 ;
12877
12878   arg1 = (Dali::Handle *)jarg1;
12879   arg2 = (Dali::Property::IndexContainer *)jarg2;
12880   if (!arg2) {
12881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
12882     return ;
12883   }
12884   {
12885     try {
12886       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
12887     } CALL_CATCH_EXCEPTION();
12888   }
12889
12890 }
12891
12892
12893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
12894   void * jresult ;
12895   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12896   Dali::Property::Index arg2 ;
12897   Dali::PropertyCondition *arg3 = 0 ;
12898   Dali::PropertyNotification result;
12899
12900   arg1 = (Dali::Handle *)jarg1;
12901   arg2 = (Dali::Property::Index)jarg2;
12902   arg3 = (Dali::PropertyCondition *)jarg3;
12903   if (!arg3) {
12904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
12905     return 0;
12906   }
12907   {
12908     try {
12909       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
12910     } CALL_CATCH_EXCEPTION(0);
12911   }
12912
12913   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
12914   return jresult;
12915 }
12916
12917
12918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
12919   void * jresult ;
12920   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12921   Dali::Property::Index arg2 ;
12922   int arg3 ;
12923   Dali::PropertyCondition *arg4 = 0 ;
12924   Dali::PropertyNotification result;
12925
12926   arg1 = (Dali::Handle *)jarg1;
12927   arg2 = (Dali::Property::Index)jarg2;
12928   arg3 = (int)jarg3;
12929   arg4 = (Dali::PropertyCondition *)jarg4;
12930   if (!arg4) {
12931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
12932     return 0;
12933   }
12934   {
12935     try {
12936       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
12937     } CALL_CATCH_EXCEPTION(0);
12938   }
12939
12940   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
12941   return jresult;
12942 }
12943
12944
12945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
12946   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12947   Dali::PropertyNotification arg2 ;
12948   Dali::PropertyNotification *argp2 ;
12949
12950   arg1 = (Dali::Handle *)jarg1;
12951   argp2 = (Dali::PropertyNotification *)jarg2;
12952   if (!argp2) {
12953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
12954     return ;
12955   }
12956   arg2 = *argp2;
12957   {
12958     try {
12959       (arg1)->RemovePropertyNotification(arg2);
12960     } CALL_CATCH_EXCEPTION();
12961   }
12962
12963 }
12964
12965
12966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
12967   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12968
12969   arg1 = (Dali::Handle *)jarg1;
12970   {
12971     try {
12972       (arg1)->RemovePropertyNotifications();
12973     } CALL_CATCH_EXCEPTION();
12974   }
12975
12976 }
12977
12978
12979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
12980   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12981
12982   arg1 = (Dali::Handle *)jarg1;
12983   {
12984     try {
12985       (arg1)->RemoveConstraints();
12986     } CALL_CATCH_EXCEPTION();
12987   }
12988
12989 }
12990
12991
12992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
12993   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12994   unsigned int arg2 ;
12995
12996   arg1 = (Dali::Handle *)jarg1;
12997   arg2 = (unsigned int)jarg2;
12998   {
12999     try {
13000       (arg1)->RemoveConstraints(arg2);
13001     } CALL_CATCH_EXCEPTION();
13002   }
13003
13004 }
13005
13006
13007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
13008   int jresult ;
13009   Dali::Property::Index result;
13010
13011   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
13012   jresult = result;
13013   return jresult;
13014 }
13015
13016
13017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
13018   void * jresult ;
13019   Dali::Handle result;
13020
13021   {
13022     try {
13023       result = Dali::WeightObject::New();
13024     } CALL_CATCH_EXCEPTION(0);
13025   }
13026
13027   jresult = new Dali::Handle((const Dali::Handle &)result);
13028   return jresult;
13029 }
13030
13031
13032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
13033   void * jresult ;
13034   Dali::TypeInfo *result = 0 ;
13035
13036   {
13037     try {
13038       result = (Dali::TypeInfo *)new Dali::TypeInfo();
13039     } CALL_CATCH_EXCEPTION(0);
13040   }
13041
13042   jresult = (void *)result;
13043   return jresult;
13044 }
13045
13046
13047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
13048   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13049
13050   arg1 = (Dali::TypeInfo *)jarg1;
13051   {
13052     try {
13053       delete arg1;
13054     } CALL_CATCH_EXCEPTION();
13055   }
13056
13057 }
13058
13059
13060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
13061   void * jresult ;
13062   Dali::TypeInfo *arg1 = 0 ;
13063   Dali::TypeInfo *result = 0 ;
13064
13065   arg1 = (Dali::TypeInfo *)jarg1;
13066   if (!arg1) {
13067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
13068     return 0;
13069   }
13070   {
13071     try {
13072       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
13073     } CALL_CATCH_EXCEPTION(0);
13074   }
13075
13076   jresult = (void *)result;
13077   return jresult;
13078 }
13079
13080
13081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
13082   void * jresult ;
13083   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13084   Dali::TypeInfo *arg2 = 0 ;
13085   Dali::TypeInfo *result = 0 ;
13086
13087   arg1 = (Dali::TypeInfo *)jarg1;
13088   arg2 = (Dali::TypeInfo *)jarg2;
13089   if (!arg2) {
13090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
13091     return 0;
13092   }
13093   {
13094     try {
13095       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
13096     } CALL_CATCH_EXCEPTION(0);
13097   }
13098
13099   jresult = (void *)result;
13100   return jresult;
13101 }
13102
13103
13104 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
13105   char * jresult ;
13106   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13107   std::string *result = 0 ;
13108
13109   arg1 = (Dali::TypeInfo *)jarg1;
13110   {
13111     try {
13112       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
13113     } CALL_CATCH_EXCEPTION(0);
13114   }
13115
13116   jresult = SWIG_csharp_string_callback(result->c_str());
13117   return jresult;
13118 }
13119
13120
13121 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
13122   char * jresult ;
13123   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13124   std::string *result = 0 ;
13125
13126   arg1 = (Dali::TypeInfo *)jarg1;
13127   {
13128     try {
13129       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
13130     } CALL_CATCH_EXCEPTION(0);
13131   }
13132
13133   jresult = SWIG_csharp_string_callback(result->c_str());
13134   return jresult;
13135 }
13136
13137
13138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
13139   void * jresult ;
13140   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13141   Dali::BaseHandle result;
13142
13143   arg1 = (Dali::TypeInfo *)jarg1;
13144   {
13145     try {
13146       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
13147     } CALL_CATCH_EXCEPTION(0);
13148   }
13149
13150   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
13151   return jresult;
13152 }
13153
13154
13155 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
13156   unsigned long jresult ;
13157   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13158   size_t result;
13159
13160   arg1 = (Dali::TypeInfo *)jarg1;
13161   {
13162     try {
13163       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
13164     } CALL_CATCH_EXCEPTION(0);
13165   }
13166
13167   jresult = (unsigned long)result;
13168   return jresult;
13169 }
13170
13171
13172 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
13173   char * jresult ;
13174   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13175   size_t arg2 ;
13176   std::string result;
13177
13178   arg1 = (Dali::TypeInfo *)jarg1;
13179   arg2 = (size_t)jarg2;
13180   {
13181     try {
13182       result = (arg1)->GetActionName(arg2);
13183     } CALL_CATCH_EXCEPTION(0);
13184   }
13185
13186   jresult = SWIG_csharp_string_callback((&result)->c_str());
13187   return jresult;
13188 }
13189
13190
13191 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
13192   unsigned long jresult ;
13193   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13194   size_t result;
13195
13196   arg1 = (Dali::TypeInfo *)jarg1;
13197   {
13198     try {
13199       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
13200     } CALL_CATCH_EXCEPTION(0);
13201   }
13202
13203   jresult = (unsigned long)result;
13204   return jresult;
13205 }
13206
13207
13208 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
13209   char * jresult ;
13210   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13211   size_t arg2 ;
13212   std::string result;
13213
13214   arg1 = (Dali::TypeInfo *)jarg1;
13215   arg2 = (size_t)jarg2;
13216   {
13217     try {
13218       result = (arg1)->GetSignalName(arg2);
13219     } CALL_CATCH_EXCEPTION(0);
13220   }
13221
13222   jresult = SWIG_csharp_string_callback((&result)->c_str());
13223   return jresult;
13224 }
13225
13226
13227 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
13228   unsigned long jresult ;
13229   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13230   size_t result;
13231
13232   arg1 = (Dali::TypeInfo *)jarg1;
13233   {
13234     try {
13235       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
13236     } CALL_CATCH_EXCEPTION(0);
13237   }
13238
13239   jresult = (unsigned long)result;
13240   return jresult;
13241 }
13242
13243
13244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
13245   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13246   Dali::Property::IndexContainer *arg2 = 0 ;
13247
13248   arg1 = (Dali::TypeInfo *)jarg1;
13249   arg2 = (Dali::Property::IndexContainer *)jarg2;
13250   if (!arg2) {
13251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
13252     return ;
13253   }
13254   {
13255     try {
13256       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
13257     } CALL_CATCH_EXCEPTION();
13258   }
13259
13260 }
13261
13262
13263 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
13264   char * jresult ;
13265   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13266   Dali::Property::Index arg2 ;
13267   std::string_view result;
13268
13269   arg1 = (Dali::TypeInfo *)jarg1;
13270   arg2 = (Dali::Property::Index)jarg2;
13271   {
13272     try {
13273       result = ((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
13274     } CALL_CATCH_EXCEPTION(0);
13275   }
13276
13277   jresult = SWIG_csharp_string_callback(result.data());
13278   return jresult;
13279 }
13280
13281
13282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
13283   void * jresult ;
13284   Dali::TypeRegistry result;
13285
13286   {
13287     try {
13288       result = Dali::TypeRegistry::Get();
13289     } CALL_CATCH_EXCEPTION(0);
13290   }
13291
13292   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
13293   return jresult;
13294 }
13295
13296
13297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
13298   void * jresult ;
13299   Dali::TypeRegistry *result = 0 ;
13300
13301   {
13302     try {
13303       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
13304     } CALL_CATCH_EXCEPTION(0);
13305   }
13306
13307   jresult = (void *)result;
13308   return jresult;
13309 }
13310
13311
13312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
13313   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13314
13315   arg1 = (Dali::TypeRegistry *)jarg1;
13316   {
13317     try {
13318       delete arg1;
13319     } CALL_CATCH_EXCEPTION();
13320   }
13321
13322 }
13323
13324
13325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
13326   void * jresult ;
13327   Dali::TypeRegistry *arg1 = 0 ;
13328   Dali::TypeRegistry *result = 0 ;
13329
13330   arg1 = (Dali::TypeRegistry *)jarg1;
13331   if (!arg1) {
13332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
13333     return 0;
13334   }
13335   {
13336     try {
13337       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
13338     } CALL_CATCH_EXCEPTION(0);
13339   }
13340
13341   jresult = (void *)result;
13342   return jresult;
13343 }
13344
13345
13346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
13347   void * jresult ;
13348   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13349   Dali::TypeRegistry *arg2 = 0 ;
13350   Dali::TypeRegistry *result = 0 ;
13351
13352   arg1 = (Dali::TypeRegistry *)jarg1;
13353   arg2 = (Dali::TypeRegistry *)jarg2;
13354   if (!arg2) {
13355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
13356     return 0;
13357   }
13358   {
13359     try {
13360       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
13361     } CALL_CATCH_EXCEPTION(0);
13362   }
13363
13364   jresult = (void *)result;
13365   return jresult;
13366 }
13367
13368
13369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
13370   void * jresult ;
13371   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13372   std::string *arg2 = 0 ;
13373   Dali::TypeInfo result;
13374
13375   arg1 = (Dali::TypeRegistry *)jarg1;
13376   if (!jarg2) {
13377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13378     return 0;
13379   }
13380   std::string arg2_str(jarg2);
13381   arg2 = &arg2_str;
13382   {
13383     try {
13384       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
13385     } CALL_CATCH_EXCEPTION(0);
13386   }
13387
13388   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
13389
13390   //argout typemap for const std::string&
13391
13392   return jresult;
13393 }
13394
13395
13396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
13397   void * jresult ;
13398   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13399   std::type_info *arg2 = 0 ;
13400   Dali::TypeInfo result;
13401
13402   arg1 = (Dali::TypeRegistry *)jarg1;
13403   arg2 = (std::type_info *)jarg2;
13404   if (!arg2) {
13405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13406     return 0;
13407   }
13408   {
13409     try {
13410       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
13411     } CALL_CATCH_EXCEPTION(0);
13412   }
13413
13414   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
13415   return jresult;
13416 }
13417
13418
13419 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
13420   unsigned long jresult ;
13421   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13422   size_t result;
13423
13424   arg1 = (Dali::TypeRegistry *)jarg1;
13425   {
13426     try {
13427       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
13428     } CALL_CATCH_EXCEPTION(0);
13429   }
13430
13431   jresult = (unsigned long)result;
13432   return jresult;
13433 }
13434
13435
13436 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
13437   char * jresult ;
13438   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13439   size_t arg2 ;
13440   std::string result;
13441
13442   arg1 = (Dali::TypeRegistry *)jarg1;
13443   arg2 = (size_t)jarg2;
13444   {
13445     try {
13446       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
13447     } CALL_CATCH_EXCEPTION(0);
13448   }
13449
13450   jresult = SWIG_csharp_string_callback((&result)->c_str());
13451   return jresult;
13452 }
13453
13454
13455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
13456   void * jresult ;
13457   std::type_info *arg1 = 0 ;
13458   std::type_info *arg2 = 0 ;
13459   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
13460   Dali::TypeRegistration *result = 0 ;
13461
13462   arg1 = (std::type_info *)jarg1;
13463   if (!arg1) {
13464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13465     return 0;
13466   }
13467   arg2 = (std::type_info *)jarg2;
13468   if (!arg2) {
13469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13470     return 0;
13471   }
13472   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
13473   {
13474     try {
13475       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
13476     } CALL_CATCH_EXCEPTION(0);
13477   }
13478
13479   jresult = (void *)result;
13480   return jresult;
13481 }
13482
13483
13484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, bool jarg4) {
13485   void * jresult ;
13486   std::type_info *arg1 = 0 ;
13487   std::type_info *arg2 = 0 ;
13488   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
13489   bool arg4 ;
13490   Dali::TypeRegistration *result = 0 ;
13491
13492   arg1 = (std::type_info *)jarg1;
13493   if (!arg1) {
13494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13495     return 0;
13496   }
13497   arg2 = (std::type_info *)jarg2;
13498   if (!arg2) {
13499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13500     return 0;
13501   }
13502   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
13503   arg4 = jarg4 ? true : false;
13504   {
13505     try {
13506       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
13507     } CALL_CATCH_EXCEPTION(0);
13508   }
13509
13510   jresult = (void *)result;
13511   return jresult;
13512 }
13513
13514
13515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
13516   void * jresult ;
13517   std::string *arg1 = 0 ;
13518   std::type_info *arg2 = 0 ;
13519   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
13520   Dali::TypeRegistration *result = 0 ;
13521
13522   if (!jarg1) {
13523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13524     return 0;
13525   }
13526   std::string arg1_str(jarg1);
13527   arg1 = &arg1_str;
13528   arg2 = (std::type_info *)jarg2;
13529   if (!arg2) {
13530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13531     return 0;
13532   }
13533   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
13534   {
13535     try {
13536       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
13537     } CALL_CATCH_EXCEPTION(0);
13538   }
13539
13540   jresult = (void *)result;
13541
13542   //argout typemap for const std::string&
13543
13544   return jresult;
13545 }
13546
13547
13548 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
13549   char * jresult ;
13550   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
13551   std::string result;
13552
13553   arg1 = (Dali::TypeRegistration *)jarg1;
13554   {
13555     try {
13556       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
13557     } CALL_CATCH_EXCEPTION(0);
13558   }
13559
13560   jresult = SWIG_csharp_string_callback((&result)->c_str());
13561   return jresult;
13562 }
13563
13564
13565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
13566   std::string *arg1 = 0 ;
13567   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
13568
13569   if (!jarg1) {
13570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13571     return ;
13572   }
13573   std::string arg1_str(jarg1);
13574   arg1 = &arg1_str;
13575   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
13576   {
13577     try {
13578       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
13579     } CALL_CATCH_EXCEPTION();
13580   }
13581
13582
13583   //argout typemap for const std::string&
13584
13585 }
13586
13587
13588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
13589   std::string *arg1 = 0 ;
13590   std::string *arg2 = 0 ;
13591   int arg3 ;
13592   Dali::Property::Type arg4 ;
13593   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
13594   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
13595
13596   if (!jarg1) {
13597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13598     return ;
13599   }
13600   std::string arg1_str(jarg1);
13601   arg1 = &arg1_str;
13602   if (!jarg2) {
13603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13604     return ;
13605   }
13606   std::string arg2_str(jarg2);
13607   arg2 = &arg2_str;
13608   arg3 = (int)jarg3;
13609   arg4 = (Dali::Property::Type)jarg4;
13610   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
13611   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
13612   {
13613     try {
13614       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
13615     } CALL_CATCH_EXCEPTION();
13616   }
13617
13618
13619   //argout typemap for const std::string&
13620
13621
13622   //argout typemap for const std::string&
13623
13624 }
13625
13626
13627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
13628   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
13629
13630   arg1 = (Dali::TypeRegistration *)jarg1;
13631   {
13632     try {
13633       delete arg1;
13634     } CALL_CATCH_EXCEPTION();
13635   }
13636
13637 }
13638
13639
13640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
13641   void * jresult ;
13642   Dali::TypeRegistration *arg1 = 0 ;
13643   std::string *arg2 = 0 ;
13644   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
13645   Dali::SignalConnectorType *result = 0 ;
13646
13647   arg1 = (Dali::TypeRegistration *)jarg1;
13648   if (!arg1) {
13649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
13650     return 0;
13651   }
13652   if (!jarg2) {
13653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13654     return 0;
13655   }
13656   std::string arg2_str(jarg2);
13657   arg2 = &arg2_str;
13658   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
13659   {
13660     try {
13661       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
13662     } CALL_CATCH_EXCEPTION(0);
13663   }
13664
13665   jresult = (void *)result;
13666
13667   //argout typemap for const std::string&
13668
13669   return jresult;
13670 }
13671
13672
13673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
13674   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
13675
13676   arg1 = (Dali::SignalConnectorType *)jarg1;
13677   {
13678     try {
13679       delete arg1;
13680     } CALL_CATCH_EXCEPTION();
13681   }
13682
13683 }
13684
13685
13686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
13687   void * jresult ;
13688   Dali::TypeRegistration *arg1 = 0 ;
13689   std::string *arg2 = 0 ;
13690   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
13691   Dali::TypeAction *result = 0 ;
13692
13693   arg1 = (Dali::TypeRegistration *)jarg1;
13694   if (!arg1) {
13695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
13696     return 0;
13697   }
13698   if (!jarg2) {
13699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13700     return 0;
13701   }
13702   std::string arg2_str(jarg2);
13703   arg2 = &arg2_str;
13704   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
13705   {
13706     try {
13707       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
13708     } CALL_CATCH_EXCEPTION(0);
13709   }
13710
13711   jresult = (void *)result;
13712
13713   //argout typemap for const std::string&
13714
13715   return jresult;
13716 }
13717
13718
13719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
13720   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
13721
13722   arg1 = (Dali::TypeAction *)jarg1;
13723   {
13724     try {
13725       delete arg1;
13726     } CALL_CATCH_EXCEPTION();
13727   }
13728
13729 }
13730
13731
13732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
13733   void * jresult ;
13734   Dali::TypeRegistration *arg1 = 0 ;
13735   std::string *arg2 = 0 ;
13736   Dali::Property::Index arg3 ;
13737   Dali::Property::Type arg4 ;
13738   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
13739   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
13740   Dali::PropertyRegistration *result = 0 ;
13741
13742   arg1 = (Dali::TypeRegistration *)jarg1;
13743   if (!arg1) {
13744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
13745     return 0;
13746   }
13747   if (!jarg2) {
13748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13749     return 0;
13750   }
13751   std::string arg2_str(jarg2);
13752   arg2 = &arg2_str;
13753   arg3 = (Dali::Property::Index)jarg3;
13754   arg4 = (Dali::Property::Type)jarg4;
13755   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
13756   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
13757   {
13758     try {
13759       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
13760     } CALL_CATCH_EXCEPTION(0);
13761   }
13762
13763   jresult = (void *)result;
13764
13765   //argout typemap for const std::string&
13766
13767   return jresult;
13768 }
13769
13770
13771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
13772   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
13773
13774   arg1 = (Dali::PropertyRegistration *)jarg1;
13775   {
13776     try {
13777       delete arg1;
13778     } CALL_CATCH_EXCEPTION();
13779   }
13780
13781 }
13782
13783
13784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
13785   void * jresult ;
13786   Dali::TypeRegistration *arg1 = 0 ;
13787   std::string *arg2 = 0 ;
13788   Dali::Property::Index arg3 ;
13789   Dali::Property::Type arg4 ;
13790   Dali::AnimatablePropertyRegistration *result = 0 ;
13791
13792   arg1 = (Dali::TypeRegistration *)jarg1;
13793   if (!arg1) {
13794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
13795     return 0;
13796   }
13797   if (!jarg2) {
13798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13799     return 0;
13800   }
13801   std::string arg2_str(jarg2);
13802   arg2 = &arg2_str;
13803   arg3 = (Dali::Property::Index)jarg3;
13804   arg4 = (Dali::Property::Type)jarg4;
13805   {
13806     try {
13807       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
13808     } CALL_CATCH_EXCEPTION(0);
13809   }
13810
13811   jresult = (void *)result;
13812
13813   //argout typemap for const std::string&
13814
13815   return jresult;
13816 }
13817
13818
13819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
13820   void * jresult ;
13821   Dali::TypeRegistration *arg1 = 0 ;
13822   std::string *arg2 = 0 ;
13823   Dali::Property::Index arg3 ;
13824   Dali::Property::Value *arg4 = 0 ;
13825   Dali::AnimatablePropertyRegistration *result = 0 ;
13826
13827   arg1 = (Dali::TypeRegistration *)jarg1;
13828   if (!arg1) {
13829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
13830     return 0;
13831   }
13832   if (!jarg2) {
13833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13834     return 0;
13835   }
13836   std::string arg2_str(jarg2);
13837   arg2 = &arg2_str;
13838   arg3 = (Dali::Property::Index)jarg3;
13839   arg4 = (Dali::Property::Value *)jarg4;
13840   if (!arg4) {
13841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13842     return 0;
13843   }
13844   {
13845     try {
13846       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
13847     } CALL_CATCH_EXCEPTION(0);
13848   }
13849
13850   jresult = (void *)result;
13851
13852   //argout typemap for const std::string&
13853
13854   return jresult;
13855 }
13856
13857
13858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
13859   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
13860
13861   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
13862   {
13863     try {
13864       delete arg1;
13865     } CALL_CATCH_EXCEPTION();
13866   }
13867
13868 }
13869
13870
13871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
13872   void * jresult ;
13873   Dali::TypeRegistration *arg1 = 0 ;
13874   std::string *arg2 = 0 ;
13875   Dali::Property::Index arg3 ;
13876   Dali::Property::Index arg4 ;
13877   unsigned int arg5 ;
13878   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
13879
13880   arg1 = (Dali::TypeRegistration *)jarg1;
13881   if (!arg1) {
13882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
13883     return 0;
13884   }
13885   if (!jarg2) {
13886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13887     return 0;
13888   }
13889   std::string arg2_str(jarg2);
13890   arg2 = &arg2_str;
13891   arg3 = (Dali::Property::Index)jarg3;
13892   arg4 = (Dali::Property::Index)jarg4;
13893   arg5 = (unsigned int)jarg5;
13894   {
13895     try {
13896       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
13897     } CALL_CATCH_EXCEPTION(0);
13898   }
13899
13900   jresult = (void *)result;
13901
13902   //argout typemap for const std::string&
13903
13904   return jresult;
13905 }
13906
13907
13908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
13909   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
13910
13911   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
13912   {
13913     try {
13914       delete arg1;
13915     } CALL_CATCH_EXCEPTION();
13916   }
13917
13918 }
13919
13920
13921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
13922   void * jresult ;
13923   Dali::TypeRegistration *arg1 = 0 ;
13924   std::string *arg2 = 0 ;
13925   Dali::Property::Index arg3 ;
13926   Dali::Property::Type arg4 ;
13927   Dali::ChildPropertyRegistration *result = 0 ;
13928
13929   arg1 = (Dali::TypeRegistration *)jarg1;
13930   if (!arg1) {
13931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
13932     return 0;
13933   }
13934   if (!jarg2) {
13935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13936     return 0;
13937   }
13938   std::string arg2_str(jarg2);
13939   arg2 = &arg2_str;
13940   arg3 = (Dali::Property::Index)jarg3;
13941   arg4 = (Dali::Property::Type)jarg4;
13942   {
13943     try {
13944       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
13945     } CALL_CATCH_EXCEPTION(0);
13946   }
13947
13948   jresult = (void *)result;
13949
13950   //argout typemap for const std::string&
13951
13952   return jresult;
13953 }
13954
13955
13956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
13957   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
13958
13959   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
13960   {
13961     try {
13962       delete arg1;
13963     } CALL_CATCH_EXCEPTION();
13964   }
13965
13966 }
13967
13968
13969 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
13970   bool jresult ;
13971   std::string *arg1 = 0 ;
13972   std::type_info *arg2 = 0 ;
13973   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
13974   bool result;
13975
13976   if (!jarg1) {
13977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13978     return 0;
13979   }
13980   std::string arg1_str(jarg1);
13981   arg1 = &arg1_str;
13982   arg2 = (std::type_info *)jarg2;
13983   if (!arg2) {
13984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13985     return 0;
13986   }
13987   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
13988   {
13989     try {
13990       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
13991     } CALL_CATCH_EXCEPTION(0);
13992   }
13993
13994   jresult = result;
13995
13996   //argout typemap for const std::string&
13997
13998   return jresult;
13999 }
14000
14001
14002 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
14003   bool jresult ;
14004   std::string *arg1 = 0 ;
14005   std::string *arg2 = 0 ;
14006   Dali::Property::Index arg3 ;
14007   Dali::Property::Type arg4 ;
14008   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
14009   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
14010   bool result;
14011
14012   if (!jarg1) {
14013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14014     return 0;
14015   }
14016   std::string arg1_str(jarg1);
14017   arg1 = &arg1_str;
14018   if (!jarg2) {
14019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14020     return 0;
14021   }
14022   std::string arg2_str(jarg2);
14023   arg2 = &arg2_str;
14024   arg3 = (Dali::Property::Index)jarg3;
14025   arg4 = (Dali::Property::Type)jarg4;
14026   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
14027   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
14028   {
14029     try {
14030       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
14031     } CALL_CATCH_EXCEPTION(0);
14032   }
14033
14034   jresult = result;
14035
14036   //argout typemap for const std::string&
14037
14038
14039   //argout typemap for const std::string&
14040
14041   return jresult;
14042 }
14043
14044
14045 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
14046   float jresult ;
14047   float result;
14048
14049   result = (float)(float)Dali::ParentOrigin::TOP;
14050   jresult = result;
14051   return jresult;
14052 }
14053
14054
14055 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
14056   float jresult ;
14057   float result;
14058
14059   result = (float)(float)Dali::ParentOrigin::BOTTOM;
14060   jresult = result;
14061   return jresult;
14062 }
14063
14064
14065 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
14066   float jresult ;
14067   float result;
14068
14069   result = (float)(float)Dali::ParentOrigin::LEFT;
14070   jresult = result;
14071   return jresult;
14072 }
14073
14074
14075 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
14076   float jresult ;
14077   float result;
14078
14079   result = (float)(float)Dali::ParentOrigin::RIGHT;
14080   jresult = result;
14081   return jresult;
14082 }
14083
14084
14085 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
14086   float jresult ;
14087   float result;
14088
14089   result = (float)(float)Dali::ParentOrigin::MIDDLE;
14090   jresult = result;
14091   return jresult;
14092 }
14093
14094
14095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
14096   void * jresult ;
14097   Dali::Vector3 *result = 0 ;
14098
14099   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
14100   jresult = (void *)result;
14101   return jresult;
14102 }
14103
14104
14105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
14106   void * jresult ;
14107   Dali::Vector3 *result = 0 ;
14108
14109   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
14110   jresult = (void *)result;
14111   return jresult;
14112 }
14113
14114
14115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
14116   void * jresult ;
14117   Dali::Vector3 *result = 0 ;
14118
14119   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
14120   jresult = (void *)result;
14121   return jresult;
14122 }
14123
14124
14125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
14126   void * jresult ;
14127   Dali::Vector3 *result = 0 ;
14128
14129   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
14130   jresult = (void *)result;
14131   return jresult;
14132 }
14133
14134
14135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
14136   void * jresult ;
14137   Dali::Vector3 *result = 0 ;
14138
14139   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
14140   jresult = (void *)result;
14141   return jresult;
14142 }
14143
14144
14145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
14146   void * jresult ;
14147   Dali::Vector3 *result = 0 ;
14148
14149   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
14150   jresult = (void *)result;
14151   return jresult;
14152 }
14153
14154
14155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
14156   void * jresult ;
14157   Dali::Vector3 *result = 0 ;
14158
14159   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
14160   jresult = (void *)result;
14161   return jresult;
14162 }
14163
14164
14165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
14166   void * jresult ;
14167   Dali::Vector3 *result = 0 ;
14168
14169   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
14170   jresult = (void *)result;
14171   return jresult;
14172 }
14173
14174
14175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
14176   void * jresult ;
14177   Dali::Vector3 *result = 0 ;
14178
14179   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
14180   jresult = (void *)result;
14181   return jresult;
14182 }
14183
14184
14185 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
14186   float jresult ;
14187   float result;
14188
14189   result = (float)(float)Dali::AnchorPoint::TOP;
14190   jresult = result;
14191   return jresult;
14192 }
14193
14194
14195 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
14196   float jresult ;
14197   float result;
14198
14199   result = (float)(float)Dali::AnchorPoint::BOTTOM;
14200   jresult = result;
14201   return jresult;
14202 }
14203
14204
14205 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
14206   float jresult ;
14207   float result;
14208
14209   result = (float)(float)Dali::AnchorPoint::LEFT;
14210   jresult = result;
14211   return jresult;
14212 }
14213
14214
14215 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
14216   float jresult ;
14217   float result;
14218
14219   result = (float)(float)Dali::AnchorPoint::RIGHT;
14220   jresult = result;
14221   return jresult;
14222 }
14223
14224
14225 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
14226   float jresult ;
14227   float result;
14228
14229   result = (float)(float)Dali::AnchorPoint::MIDDLE;
14230   jresult = result;
14231   return jresult;
14232 }
14233
14234
14235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
14236   void * jresult ;
14237   Dali::Vector3 *result = 0 ;
14238
14239   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
14240   jresult = (void *)result;
14241   return jresult;
14242 }
14243
14244
14245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
14246   void * jresult ;
14247   Dali::Vector3 *result = 0 ;
14248
14249   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
14250   jresult = (void *)result;
14251   return jresult;
14252 }
14253
14254
14255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
14256   void * jresult ;
14257   Dali::Vector3 *result = 0 ;
14258
14259   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
14260   jresult = (void *)result;
14261   return jresult;
14262 }
14263
14264
14265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
14266   void * jresult ;
14267   Dali::Vector3 *result = 0 ;
14268
14269   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
14270   jresult = (void *)result;
14271   return jresult;
14272 }
14273
14274
14275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
14276   void * jresult ;
14277   Dali::Vector3 *result = 0 ;
14278
14279   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
14280   jresult = (void *)result;
14281   return jresult;
14282 }
14283
14284
14285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
14286   void * jresult ;
14287   Dali::Vector3 *result = 0 ;
14288
14289   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
14290   jresult = (void *)result;
14291   return jresult;
14292 }
14293
14294
14295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
14296   void * jresult ;
14297   Dali::Vector3 *result = 0 ;
14298
14299   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
14300   jresult = (void *)result;
14301   return jresult;
14302 }
14303
14304
14305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
14306   void * jresult ;
14307   Dali::Vector3 *result = 0 ;
14308
14309   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
14310   jresult = (void *)result;
14311   return jresult;
14312 }
14313
14314
14315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
14316   void * jresult ;
14317   Dali::Vector3 *result = 0 ;
14318
14319   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
14320   jresult = (void *)result;
14321   return jresult;
14322 }
14323
14324
14325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ALICE_BLUE_get() {
14326   void * jresult;
14327   Dali::Vector4 *result = 0 ;
14328
14329   result = (Dali::Vector4 *)&Dali::Color::ALICE_BLUE;
14330   jresult = (void *)result;
14331   return jresult;
14332 }
14333
14334
14335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANTIQUE_WHITE_get() {
14336   void * jresult;
14337   Dali::Vector4 *result = 0 ;
14338
14339   result = (Dali::Vector4 *)&Dali::Color::ANTIQUE_WHITE;
14340   jresult = (void *)result;
14341   return jresult;
14342 }
14343
14344
14345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AQUA_get() {
14346   void * jresult;
14347   Dali::Vector4 *result = 0 ;
14348
14349   result = (Dali::Vector4 *)&Dali::Color::AQUA;
14350   jresult = (void *)result;
14351   return jresult;
14352 }
14353
14354
14355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AQUA_MARINE_get() {
14356   void * jresult;
14357   Dali::Vector4 *result = 0 ;
14358
14359   result = (Dali::Vector4 *)&Dali::Color::AQUA_MARINE;
14360   jresult = (void *)result;
14361   return jresult;
14362 }
14363
14364
14365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AZURE_get() {
14366   void * jresult;
14367   Dali::Vector4 *result = 0 ;
14368
14369   result = (Dali::Vector4 *)&Dali::Color::AZURE;
14370   jresult = (void *)result;
14371   return jresult;
14372 }
14373
14374
14375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BEIGE_get() {
14376   void * jresult;
14377   Dali::Vector4 *result = 0 ;
14378
14379   result = (Dali::Vector4 *)&Dali::Color::BEIGE;
14380   jresult = (void *)result;
14381   return jresult;
14382 }
14383
14384
14385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BISQUE_get() {
14386   void * jresult;
14387   Dali::Vector4 *result = 0 ;
14388
14389   result = (Dali::Vector4 *)&Dali::Color::BISQUE;
14390   jresult = (void *)result;
14391   return jresult;
14392 }
14393
14394
14395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
14396   void * jresult;
14397   Dali::Vector4 *result = 0 ;
14398
14399   result = (Dali::Vector4 *)&Dali::Color::BLACK;
14400   jresult = (void *)result;
14401   return jresult;
14402 }
14403
14404
14405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLANCHE_DALMOND_get() {
14406   void * jresult;
14407   Dali::Vector4 *result = 0 ;
14408
14409   result = (Dali::Vector4 *)&Dali::Color::BLANCHE_DALMOND;
14410   jresult = (void *)result;
14411   return jresult;
14412 }
14413
14414
14415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
14416   void * jresult;
14417   Dali::Vector4 *result = 0 ;
14418
14419   result = (Dali::Vector4 *)&Dali::Color::BLUE;
14420   jresult = (void *)result;
14421   return jresult;
14422 }
14423
14424
14425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_VIOLET_get() {
14426   void * jresult;
14427   Dali::Vector4 *result = 0 ;
14428
14429   result = (Dali::Vector4 *)&Dali::Color::BLUE_VIOLET;
14430   jresult = (void *)result;
14431   return jresult;
14432 }
14433
14434
14435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BROWN_get() {
14436   void * jresult;
14437   Dali::Vector4 *result = 0 ;
14438
14439   result = (Dali::Vector4 *)&Dali::Color::BROWN;
14440   jresult = (void *)result;
14441   return jresult;
14442 }
14443
14444
14445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BURLY_WOOD_get() {
14446   void * jresult;
14447   Dali::Vector4 *result = 0 ;
14448
14449   result = (Dali::Vector4 *)&Dali::Color::BURLY_WOOD;
14450   jresult = (void *)result;
14451   return jresult;
14452 }
14453
14454
14455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CADET_BLUE_get() {
14456   void * jresult;
14457   Dali::Vector4 *result = 0 ;
14458
14459   result = (Dali::Vector4 *)&Dali::Color::CADET_BLUE;
14460   jresult = (void *)result;
14461   return jresult;
14462 }
14463
14464
14465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CHARTREUSE_get() {
14466   void * jresult;
14467   Dali::Vector4 *result = 0 ;
14468
14469   result = (Dali::Vector4 *)&Dali::Color::CHARTREUSE;
14470   jresult = (void *)result;
14471   return jresult;
14472 }
14473
14474
14475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CHOCOLATE_get() {
14476   void * jresult;
14477   Dali::Vector4 *result = 0 ;
14478
14479   result = (Dali::Vector4 *)&Dali::Color::CHOCOLATE;
14480   jresult = (void *)result;
14481   return jresult;
14482 }
14483
14484
14485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CORAL_get() {
14486   void * jresult;
14487   Dali::Vector4 *result = 0 ;
14488
14489   result = (Dali::Vector4 *)&Dali::Color::CORAL;
14490   jresult = (void *)result;
14491   return jresult;
14492 }
14493
14494
14495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CORNFLOWER_BLUE_get() {
14496   void * jresult;
14497   Dali::Vector4 *result = 0 ;
14498
14499   result = (Dali::Vector4 *)&Dali::Color::CORNFLOWER_BLUE;
14500   jresult = (void *)result;
14501   return jresult;
14502 }
14503
14504
14505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CORNSILK_get() {
14506   void * jresult;
14507   Dali::Vector4 *result = 0 ;
14508
14509   result = (Dali::Vector4 *)&Dali::Color::CORNSILK;
14510   jresult = (void *)result;
14511   return jresult;
14512 }
14513
14514
14515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CRIMSON_get() {
14516   void * jresult;
14517   Dali::Vector4 *result = 0 ;
14518
14519   result = (Dali::Vector4 *)&Dali::Color::CRIMSON;
14520   jresult = (void *)result;
14521   return jresult;
14522 }
14523
14524
14525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
14526   void * jresult;
14527   Dali::Vector4 *result = 0 ;
14528
14529   result = (Dali::Vector4 *)&Dali::Color::CYAN;
14530   jresult = (void *)result;
14531   return jresult;
14532 }
14533
14534
14535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_BLUE_get() {
14536   void * jresult;
14537   Dali::Vector4 *result = 0 ;
14538
14539   result = (Dali::Vector4 *)&Dali::Color::DARK_BLUE;
14540   jresult = (void *)result;
14541   return jresult;
14542 }
14543
14544
14545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_CYAN_get() {
14546   void * jresult;
14547   Dali::Vector4 *result = 0 ;
14548
14549   result = (Dali::Vector4 *)&Dali::Color::DARK_CYAN;
14550   jresult = (void *)result;
14551   return jresult;
14552 }
14553
14554
14555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_GOLDENROD_get() {
14556   void * jresult;
14557   Dali::Vector4 *result = 0 ;
14558
14559   result = (Dali::Vector4 *)&Dali::Color::DARK_GOLDENROD;
14560   jresult = (void *)result;
14561   return jresult;
14562 }
14563
14564
14565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_GRAY_get() {
14566   void * jresult;
14567   Dali::Vector4 *result = 0 ;
14568
14569   result = (Dali::Vector4 *)&Dali::Color::DARK_GRAY;
14570   jresult = (void *)result;
14571   return jresult;
14572 }
14573
14574
14575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_GREEN_get() {
14576   void * jresult;
14577   Dali::Vector4 *result = 0 ;
14578
14579   result = (Dali::Vector4 *)&Dali::Color::DARK_GREEN;
14580   jresult = (void *)result;
14581   return jresult;
14582 }
14583
14584
14585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_GREY_get() {
14586   void * jresult;
14587   Dali::Vector4 *result = 0 ;
14588
14589   result = (Dali::Vector4 *)&Dali::Color::DARK_GREY;
14590   jresult = (void *)result;
14591   return jresult;
14592 }
14593
14594
14595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_KHAKI_get() {
14596   void * jresult;
14597   Dali::Vector4 *result = 0 ;
14598
14599   result = (Dali::Vector4 *)&Dali::Color::DARK_KHAKI;
14600   jresult = (void *)result;
14601   return jresult;
14602 }
14603
14604
14605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_MAGENTA_get() {
14606   void * jresult;
14607   Dali::Vector4 *result = 0 ;
14608
14609   result = (Dali::Vector4 *)&Dali::Color::DARK_MAGENTA;
14610   jresult = (void *)result;
14611   return jresult;
14612 }
14613
14614
14615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_OLIVE_GREEN_get() {
14616   void * jresult;
14617   Dali::Vector4 *result = 0 ;
14618
14619   result = (Dali::Vector4 *)&Dali::Color::DARK_OLIVE_GREEN;
14620   jresult = (void *)result;
14621   return jresult;
14622 }
14623
14624
14625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_ORANGE_get() {
14626   void * jresult;
14627   Dali::Vector4 *result = 0 ;
14628
14629   result = (Dali::Vector4 *)&Dali::Color::DARK_ORANGE;
14630   jresult = (void *)result;
14631   return jresult;
14632 }
14633
14634
14635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_ORCHID_get() {
14636   void * jresult;
14637   Dali::Vector4 *result = 0 ;
14638
14639   result = (Dali::Vector4 *)&Dali::Color::DARK_ORCHID;
14640   jresult = (void *)result;
14641   return jresult;
14642 }
14643
14644
14645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_RED_get() {
14646   void * jresult;
14647   Dali::Vector4 *result = 0 ;
14648
14649   result = (Dali::Vector4 *)&Dali::Color::DARK_RED;
14650   jresult = (void *)result;
14651   return jresult;
14652 }
14653
14654
14655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SALMON_get() {
14656   void * jresult;
14657   Dali::Vector4 *result = 0 ;
14658
14659   result = (Dali::Vector4 *)&Dali::Color::DARK_SALMON;
14660   jresult = (void *)result;
14661   return jresult;
14662 }
14663
14664
14665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SEA_GREEN_get() {
14666   void * jresult;
14667   Dali::Vector4 *result = 0 ;
14668
14669   result = (Dali::Vector4 *)&Dali::Color::DARK_SEA_GREEN;
14670   jresult = (void *)result;
14671   return jresult;
14672 }
14673
14674
14675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SLATE_BLUE_get() {
14676   void * jresult;
14677   Dali::Vector4 *result = 0 ;
14678
14679   result = (Dali::Vector4 *)&Dali::Color::DARK_SLATE_BLUE;
14680   jresult = (void *)result;
14681   return jresult;
14682 }
14683
14684
14685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SLATE_GRAY_get() {
14686   void * jresult;
14687   Dali::Vector4 *result = 0 ;
14688
14689   result = (Dali::Vector4 *)&Dali::Color::DARK_SLATE_GRAY;
14690   jresult = (void *)result;
14691   return jresult;
14692 }
14693
14694
14695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SLATE_GREY_get() {
14696   void * jresult;
14697   Dali::Vector4 *result = 0 ;
14698
14699   result = (Dali::Vector4 *)&Dali::Color::DARK_SLATE_GREY;
14700   jresult = (void *)result;
14701   return jresult;
14702 }
14703
14704
14705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_TURQUOISE_get() {
14706   void * jresult;
14707   Dali::Vector4 *result = 0 ;
14708
14709   result = (Dali::Vector4 *)&Dali::Color::DARK_TURQUOISE;
14710   jresult = (void *)result;
14711   return jresult;
14712 }
14713
14714
14715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_VIOLET_get() {
14716   void * jresult;
14717   Dali::Vector4 *result = 0 ;
14718
14719   result = (Dali::Vector4 *)&Dali::Color::DARK_VIOLET;
14720   jresult = (void *)result;
14721   return jresult;
14722 }
14723
14724
14725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DEEP_PINK_get() {
14726   void * jresult;
14727   Dali::Vector4 *result = 0 ;
14728
14729   result = (Dali::Vector4 *)&Dali::Color::DEEP_PINK;
14730   jresult = (void *)result;
14731   return jresult;
14732 }
14733
14734
14735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DEEP_SKY_BLUE_get() {
14736   void * jresult;
14737   Dali::Vector4 *result = 0 ;
14738
14739   result = (Dali::Vector4 *)&Dali::Color::DEEP_SKY_BLUE;
14740   jresult = (void *)result;
14741   return jresult;
14742 }
14743
14744
14745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DIM_GRAY_get() {
14746   void * jresult;
14747   Dali::Vector4 *result = 0 ;
14748
14749   result = (Dali::Vector4 *)&Dali::Color::DIM_GRAY;
14750   jresult = (void *)result;
14751   return jresult;
14752 }
14753
14754
14755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DIM_GREY_get() {
14756   void * jresult;
14757   Dali::Vector4 *result = 0 ;
14758
14759   result = (Dali::Vector4 *)&Dali::Color::DIM_GREY;
14760   jresult = (void *)result;
14761   return jresult;
14762 }
14763
14764
14765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DODGER_BLUE_get() {
14766   void * jresult;
14767   Dali::Vector4 *result = 0 ;
14768
14769   result = (Dali::Vector4 *)&Dali::Color::DODGER_BLUE;
14770   jresult = (void *)result;
14771   return jresult;
14772 }
14773
14774
14775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FIRE_BRICK_get() {
14776   void * jresult;
14777   Dali::Vector4 *result = 0 ;
14778
14779   result = (Dali::Vector4 *)&Dali::Color::FIRE_BRICK;
14780   jresult = (void *)result;
14781   return jresult;
14782 }
14783
14784
14785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FLORAL_WHITE_get() {
14786   void * jresult;
14787   Dali::Vector4 *result = 0 ;
14788
14789   result = (Dali::Vector4 *)&Dali::Color::FLORAL_WHITE;
14790   jresult = (void *)result;
14791   return jresult;
14792 }
14793
14794
14795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FOREST_GREEN_get() {
14796   void * jresult;
14797   Dali::Vector4 *result = 0 ;
14798
14799   result = (Dali::Vector4 *)&Dali::Color::FOREST_GREEN;
14800   jresult = (void *)result;
14801   return jresult;
14802 }
14803
14804
14805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FUCHSIA_get() {
14806   void * jresult;
14807   Dali::Vector4 *result = 0 ;
14808
14809   result = (Dali::Vector4 *)&Dali::Color::FUCHSIA;
14810   jresult = (void *)result;
14811   return jresult;
14812 }
14813
14814
14815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GAINSBORO_get() {
14816   void * jresult;
14817   Dali::Vector4 *result = 0 ;
14818
14819   result = (Dali::Vector4 *)&Dali::Color::GAINSBORO;
14820   jresult = (void *)result;
14821   return jresult;
14822 }
14823
14824
14825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GHOST_WHITE_get() {
14826   void * jresult;
14827   Dali::Vector4 *result = 0 ;
14828
14829   result = (Dali::Vector4 *)&Dali::Color::GHOST_WHITE;
14830   jresult = (void *)result;
14831   return jresult;
14832 }
14833
14834
14835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GOLD_get() {
14836   void * jresult;
14837   Dali::Vector4 *result = 0 ;
14838
14839   result = (Dali::Vector4 *)&Dali::Color::GOLD;
14840   jresult = (void *)result;
14841   return jresult;
14842 }
14843
14844
14845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GOLDEN_ROD_get() {
14846   void * jresult;
14847   Dali::Vector4 *result = 0 ;
14848
14849   result = (Dali::Vector4 *)&Dali::Color::GOLDEN_ROD;
14850   jresult = (void *)result;
14851   return jresult;
14852 }
14853
14854
14855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GRAY_get() {
14856   void * jresult;
14857   Dali::Vector4 *result = 0 ;
14858
14859   result = (Dali::Vector4 *)&Dali::Color::GRAY;
14860   jresult = (void *)result;
14861   return jresult;
14862 }
14863
14864
14865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
14866   void * jresult;
14867   Dali::Vector4 *result = 0 ;
14868
14869   result = (Dali::Vector4 *)&Dali::Color::GREEN;
14870   jresult = (void *)result;
14871   return jresult;
14872 }
14873
14874
14875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_YELLOW_get() {
14876   void * jresult;
14877   Dali::Vector4 *result = 0 ;
14878
14879   result = (Dali::Vector4 *)&Dali::Color::GREEN_YELLOW;
14880   jresult = (void *)result;
14881   return jresult;
14882 }
14883
14884
14885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREY_get() {
14886   void * jresult;
14887   Dali::Vector4 *result = 0 ;
14888
14889   result = (Dali::Vector4 *)&Dali::Color::GREY;
14890   jresult = (void *)result;
14891   return jresult;
14892 }
14893
14894
14895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_HONEYDEW_get() {
14896   void * jresult;
14897   Dali::Vector4 *result = 0 ;
14898
14899   result = (Dali::Vector4 *)&Dali::Color::HONEYDEW;
14900   jresult = (void *)result;
14901   return jresult;
14902 }
14903
14904
14905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_HOT_PINK_get() {
14906   void * jresult;
14907   Dali::Vector4 *result = 0 ;
14908
14909   result = (Dali::Vector4 *)&Dali::Color::HOT_PINK;
14910   jresult = (void *)result;
14911   return jresult;
14912 }
14913
14914
14915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_INDIANRED_get() {
14916   void * jresult;
14917   Dali::Vector4 *result = 0 ;
14918
14919   result = (Dali::Vector4 *)&Dali::Color::INDIANRED;
14920   jresult = (void *)result;
14921   return jresult;
14922 }
14923
14924
14925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_INDIGO_get() {
14926   void * jresult;
14927   Dali::Vector4 *result = 0 ;
14928
14929   result = (Dali::Vector4 *)&Dali::Color::INDIGO;
14930   jresult = (void *)result;
14931   return jresult;
14932 }
14933
14934
14935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_IVORY_get() {
14936   void * jresult;
14937   Dali::Vector4 *result = 0 ;
14938
14939   result = (Dali::Vector4 *)&Dali::Color::IVORY;
14940   jresult = (void *)result;
14941   return jresult;
14942 }
14943
14944
14945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KHAKI_get() {
14946   void * jresult;
14947   Dali::Vector4 *result = 0 ;
14948
14949   result = (Dali::Vector4 *)&Dali::Color::KHAKI;
14950   jresult = (void *)result;
14951   return jresult;
14952 }
14953
14954
14955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LAVENDER_get() {
14956   void * jresult;
14957   Dali::Vector4 *result = 0 ;
14958
14959   result = (Dali::Vector4 *)&Dali::Color::LAVENDER;
14960   jresult = (void *)result;
14961   return jresult;
14962 }
14963
14964
14965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LAVENDER_BLUSH_get() {
14966   void * jresult;
14967   Dali::Vector4 *result = 0 ;
14968
14969   result = (Dali::Vector4 *)&Dali::Color::LAVENDER_BLUSH;
14970   jresult = (void *)result;
14971   return jresult;
14972 }
14973
14974
14975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LAWN_GREEN_get() {
14976   void * jresult;
14977   Dali::Vector4 *result = 0 ;
14978
14979   result = (Dali::Vector4 *)&Dali::Color::LAWN_GREEN;
14980   jresult = (void *)result;
14981   return jresult;
14982 }
14983
14984
14985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LEMON_CHIFFON_get() {
14986   void * jresult;
14987   Dali::Vector4 *result = 0 ;
14988
14989   result = (Dali::Vector4 *)&Dali::Color::LEMON_CHIFFON;
14990   jresult = (void *)result;
14991   return jresult;
14992 }
14993
14994
14995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_BLUE_get() {
14996   void * jresult;
14997   Dali::Vector4 *result = 0 ;
14998
14999   result = (Dali::Vector4 *)&Dali::Color::LIGHT_BLUE;
15000   jresult = (void *)result;
15001   return jresult;
15002 }
15003
15004
15005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_CORAL_get() {
15006   void * jresult;
15007   Dali::Vector4 *result = 0 ;
15008
15009   result = (Dali::Vector4 *)&Dali::Color::LIGHT_CORAL;
15010   jresult = (void *)result;
15011   return jresult;
15012 }
15013
15014
15015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_CYAN_get() {
15016   void * jresult;
15017   Dali::Vector4 *result = 0 ;
15018
15019   result = (Dali::Vector4 *)&Dali::Color::LIGHT_CYAN;
15020   jresult = (void *)result;
15021   return jresult;
15022 }
15023
15024
15025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_GOLDEN_ROD_YELLOW_get() {
15026   void * jresult;
15027   Dali::Vector4 *result = 0 ;
15028
15029   result = (Dali::Vector4 *)&Dali::Color::LIGHT_GOLDEN_ROD_YELLOW;
15030   jresult = (void *)result;
15031   return jresult;
15032 }
15033
15034
15035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_GRAY_get() {
15036   void * jresult;
15037   Dali::Vector4 *result = 0 ;
15038
15039   result = (Dali::Vector4 *)&Dali::Color::LIGHT_GRAY;
15040   jresult = (void *)result;
15041   return jresult;
15042 }
15043
15044
15045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_GREEN_get() {
15046   void * jresult;
15047   Dali::Vector4 *result = 0 ;
15048
15049   result = (Dali::Vector4 *)&Dali::Color::LIGHT_GREEN;
15050   jresult = (void *)result;
15051   return jresult;
15052 }
15053
15054
15055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_GREY_get() {
15056   void * jresult;
15057   Dali::Vector4 *result = 0 ;
15058
15059   result = (Dali::Vector4 *)&Dali::Color::LIGHT_GREY;
15060   jresult = (void *)result;
15061   return jresult;
15062 }
15063
15064
15065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_PINK_get() {
15066   void * jresult;
15067   Dali::Vector4 *result = 0 ;
15068
15069   result = (Dali::Vector4 *)&Dali::Color::LIGHT_PINK;
15070   jresult = (void *)result;
15071   return jresult;
15072 }
15073
15074
15075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SALMON_get() {
15076   void * jresult;
15077   Dali::Vector4 *result = 0 ;
15078
15079   result = (Dali::Vector4 *)&Dali::Color::LIGHT_SALMON;
15080   jresult = (void *)result;
15081   return jresult;
15082 }
15083
15084
15085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SEA_GREEN_get() {
15086   void * jresult;
15087   Dali::Vector4 *result = 0 ;
15088
15089   result = (Dali::Vector4 *)&Dali::Color::LIGHT_SEA_GREEN;
15090   jresult = (void *)result;
15091   return jresult;
15092 }
15093
15094
15095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SKY_BLUE_get() {
15096   void * jresult;
15097   Dali::Vector4 *result = 0 ;
15098
15099   result = (Dali::Vector4 *)&Dali::Color::LIGHT_SKY_BLUE;
15100   jresult = (void *)result;
15101   return jresult;
15102 }
15103
15104
15105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SLATE_GRAY_get() {
15106   void * jresult;
15107   Dali::Vector4 *result = 0 ;
15108
15109   result = (Dali::Vector4 *)&Dali::Color::LIGHT_SLATE_GRAY;
15110   jresult = (void *)result;
15111   return jresult;
15112 }
15113
15114
15115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SLATE_GREY_get() {
15116   void * jresult;
15117   Dali::Vector4 *result = 0 ;
15118
15119   result = (Dali::Vector4 *)&Dali::Color::LIGHT_SLATE_GREY;
15120   jresult = (void *)result;
15121   return jresult;
15122 }
15123
15124
15125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_STEEL_BLUE_get() {
15126   void * jresult;
15127   Dali::Vector4 *result = 0 ;
15128
15129   result = (Dali::Vector4 *)&Dali::Color::LIGHT_STEEL_BLUE;
15130   jresult = (void *)result;
15131   return jresult;
15132 }
15133
15134
15135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_YELLOW_get() {
15136   void * jresult;
15137   Dali::Vector4 *result = 0 ;
15138
15139   result = (Dali::Vector4 *)&Dali::Color::LIGHT_YELLOW;
15140   jresult = (void *)result;
15141   return jresult;
15142 }
15143
15144
15145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIME_get() {
15146   void * jresult;
15147   Dali::Vector4 *result = 0 ;
15148
15149   result = (Dali::Vector4 *)&Dali::Color::LIME;
15150   jresult = (void *)result;
15151   return jresult;
15152 }
15153
15154
15155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIME_GREEN_get() {
15156   void * jresult;
15157   Dali::Vector4 *result = 0 ;
15158
15159   result = (Dali::Vector4 *)&Dali::Color::LIME_GREEN;
15160   jresult = (void *)result;
15161   return jresult;
15162 }
15163
15164
15165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LINEN_get() {
15166   void * jresult;
15167   Dali::Vector4 *result = 0 ;
15168
15169   result = (Dali::Vector4 *)&Dali::Color::LINEN;
15170   jresult = (void *)result;
15171   return jresult;
15172 }
15173
15174
15175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
15176   void * jresult;
15177   Dali::Vector4 *result = 0 ;
15178
15179   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
15180   jresult = (void *)result;
15181   return jresult;
15182 }
15183
15184
15185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAROON_get() {
15186   void * jresult;
15187   Dali::Vector4 *result = 0 ;
15188
15189   result = (Dali::Vector4 *)&Dali::Color::MAROON;
15190   jresult = (void *)result;
15191   return jresult;
15192 }
15193
15194
15195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_AQUA_MARINE_get() {
15196   void * jresult;
15197   Dali::Vector4 *result = 0 ;
15198
15199   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_AQUA_MARINE;
15200   jresult = (void *)result;
15201   return jresult;
15202 }
15203
15204
15205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_BLUE_get() {
15206   void * jresult;
15207   Dali::Vector4 *result = 0 ;
15208
15209   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_BLUE;
15210   jresult = (void *)result;
15211   return jresult;
15212 }
15213
15214
15215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_ORCHID_get() {
15216   void * jresult;
15217   Dali::Vector4 *result = 0 ;
15218
15219   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_ORCHID;
15220   jresult = (void *)result;
15221   return jresult;
15222 }
15223
15224
15225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_PURPLE_get() {
15226   void * jresult;
15227   Dali::Vector4 *result = 0 ;
15228
15229   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_PURPLE;
15230   jresult = (void *)result;
15231   return jresult;
15232 }
15233
15234
15235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_SEA_GREEN_get() {
15236   void * jresult;
15237   Dali::Vector4 *result = 0 ;
15238
15239   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_SEA_GREEN;
15240   jresult = (void *)result;
15241   return jresult;
15242 }
15243
15244
15245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_SLATE_BLUE_get() {
15246   void * jresult;
15247   Dali::Vector4 *result = 0 ;
15248
15249   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_SLATE_BLUE;
15250   jresult = (void *)result;
15251   return jresult;
15252 }
15253
15254
15255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_SPRING_GREEN_get() {
15256   void * jresult;
15257   Dali::Vector4 *result = 0 ;
15258
15259   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_SPRING_GREEN;
15260   jresult = (void *)result;
15261   return jresult;
15262 }
15263
15264
15265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_TURQUOISE_get() {
15266   void * jresult;
15267   Dali::Vector4 *result = 0 ;
15268
15269   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_TURQUOISE;
15270   jresult = (void *)result;
15271   return jresult;
15272 }
15273
15274
15275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_VIOLETRED_get() {
15276   void * jresult;
15277   Dali::Vector4 *result = 0 ;
15278
15279   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_VIOLETRED;
15280   jresult = (void *)result;
15281   return jresult;
15282 }
15283
15284
15285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MIDNIGHT_BLUE_get() {
15286   void * jresult;
15287   Dali::Vector4 *result = 0 ;
15288
15289   result = (Dali::Vector4 *)&Dali::Color::MIDNIGHT_BLUE;
15290   jresult = (void *)result;
15291   return jresult;
15292 }
15293
15294
15295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MINT_CREAM_get() {
15296   void * jresult;
15297   Dali::Vector4 *result = 0 ;
15298
15299   result = (Dali::Vector4 *)&Dali::Color::MINT_CREAM;
15300   jresult = (void *)result;
15301   return jresult;
15302 }
15303
15304
15305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MISTY_ROSE_get() {
15306   void * jresult;
15307   Dali::Vector4 *result = 0 ;
15308
15309   result = (Dali::Vector4 *)&Dali::Color::MISTY_ROSE;
15310   jresult = (void *)result;
15311   return jresult;
15312 }
15313
15314
15315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MOCCASIN_get() {
15316   void * jresult;
15317   Dali::Vector4 *result = 0 ;
15318
15319   result = (Dali::Vector4 *)&Dali::Color::MOCCASIN;
15320   jresult = (void *)result;
15321   return jresult;
15322 }
15323
15324
15325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NAVAJO_WHITE_get() {
15326   void * jresult;
15327   Dali::Vector4 *result = 0 ;
15328
15329   result = (Dali::Vector4 *)&Dali::Color::NAVAJO_WHITE;
15330   jresult = (void *)result;
15331   return jresult;
15332 }
15333
15334
15335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NAVY_get() {
15336   void * jresult;
15337   Dali::Vector4 *result = 0 ;
15338
15339   result = (Dali::Vector4 *)&Dali::Color::NAVY;
15340   jresult = (void *)result;
15341   return jresult;
15342 }
15343
15344
15345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OLD_LACE_get() {
15346   void * jresult;
15347   Dali::Vector4 *result = 0 ;
15348
15349   result = (Dali::Vector4 *)&Dali::Color::OLD_LACE;
15350   jresult = (void *)result;
15351   return jresult;
15352 }
15353
15354
15355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OLIVE_get() {
15356   void * jresult;
15357   Dali::Vector4 *result = 0 ;
15358
15359   result = (Dali::Vector4 *)&Dali::Color::OLIVE;
15360   jresult = (void *)result;
15361   return jresult;
15362 }
15363
15364
15365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OLIVE_DRAB_get() {
15366   void * jresult;
15367   Dali::Vector4 *result = 0 ;
15368
15369   result = (Dali::Vector4 *)&Dali::Color::OLIVE_DRAB;
15370   jresult = (void *)result;
15371   return jresult;
15372 }
15373
15374
15375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ORANGE_get() {
15376   void * jresult;
15377   Dali::Vector4 *result = 0 ;
15378
15379   result = (Dali::Vector4 *)&Dali::Color::ORANGE;
15380   jresult = (void *)result;
15381   return jresult;
15382 }
15383
15384
15385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ORANGE_RED_get() {
15386   void * jresult;
15387   Dali::Vector4 *result = 0 ;
15388
15389   result = (Dali::Vector4 *)&Dali::Color::ORANGE_RED;
15390   jresult = (void *)result;
15391   return jresult;
15392 }
15393
15394
15395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ORCHID_get() {
15396   void * jresult;
15397   Dali::Vector4 *result = 0 ;
15398
15399   result = (Dali::Vector4 *)&Dali::Color::ORCHID;
15400   jresult = (void *)result;
15401   return jresult;
15402 }
15403
15404
15405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PALE_GOLDEN_ROD_get() {
15406   void * jresult;
15407   Dali::Vector4 *result = 0 ;
15408
15409   result = (Dali::Vector4 *)&Dali::Color::PALE_GOLDEN_ROD;
15410   jresult = (void *)result;
15411   return jresult;
15412 }
15413
15414
15415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PALE_GREEN_get() {
15416   void * jresult;
15417   Dali::Vector4 *result = 0 ;
15418
15419   result = (Dali::Vector4 *)&Dali::Color::PALE_GREEN;
15420   jresult = (void *)result;
15421   return jresult;
15422 }
15423
15424
15425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PALE_TURQUOISE_get() {
15426   void * jresult;
15427   Dali::Vector4 *result = 0 ;
15428
15429   result = (Dali::Vector4 *)&Dali::Color::PALE_TURQUOISE;
15430   jresult = (void *)result;
15431   return jresult;
15432 }
15433
15434
15435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PALE_VIOLET_RED_get() {
15436   void * jresult;
15437   Dali::Vector4 *result = 0 ;
15438
15439   result = (Dali::Vector4 *)&Dali::Color::PALE_VIOLET_RED;
15440   jresult = (void *)result;
15441   return jresult;
15442 }
15443
15444
15445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PAPAYA_WHIP_get() {
15446   void * jresult;
15447   Dali::Vector4 *result = 0 ;
15448
15449   result = (Dali::Vector4 *)&Dali::Color::PAPAYA_WHIP;
15450   jresult = (void *)result;
15451   return jresult;
15452 }
15453
15454
15455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PEACH_PUFF_get() {
15456   void * jresult;
15457   Dali::Vector4 *result = 0 ;
15458
15459   result = (Dali::Vector4 *)&Dali::Color::PEACH_PUFF;
15460   jresult = (void *)result;
15461   return jresult;
15462 }
15463
15464
15465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PERU_get() {
15466   void * jresult;
15467   Dali::Vector4 *result = 0 ;
15468
15469   result = (Dali::Vector4 *)&Dali::Color::PERU;
15470   jresult = (void *)result;
15471   return jresult;
15472 }
15473
15474
15475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PINK_get() {
15476   void * jresult;
15477   Dali::Vector4 *result = 0 ;
15478
15479   result = (Dali::Vector4 *)&Dali::Color::PINK;
15480   jresult = (void *)result;
15481   return jresult;
15482 }
15483
15484
15485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PLUM_get() {
15486   void * jresult;
15487   Dali::Vector4 *result = 0 ;
15488
15489   result = (Dali::Vector4 *)&Dali::Color::PLUM;
15490   jresult = (void *)result;
15491   return jresult;
15492 }
15493
15494
15495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_POWDER_BLUE_get() {
15496   void * jresult;
15497   Dali::Vector4 *result = 0 ;
15498
15499   result = (Dali::Vector4 *)&Dali::Color::POWDER_BLUE;
15500   jresult = (void *)result;
15501   return jresult;
15502 }
15503
15504
15505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PURPLE_get() {
15506   void * jresult;
15507   Dali::Vector4 *result = 0 ;
15508
15509   result = (Dali::Vector4 *)&Dali::Color::PURPLE;
15510   jresult = (void *)result;
15511   return jresult;
15512 }
15513
15514
15515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
15516   void * jresult;
15517   Dali::Vector4 *result = 0 ;
15518
15519   result = (Dali::Vector4 *)&Dali::Color::RED;
15520   jresult = (void *)result;
15521   return jresult;
15522 }
15523
15524
15525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ROSY_BROWN_get() {
15526   void * jresult;
15527   Dali::Vector4 *result = 0 ;
15528
15529   result = (Dali::Vector4 *)&Dali::Color::ROSY_BROWN;
15530   jresult = (void *)result;
15531   return jresult;
15532 }
15533
15534
15535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ROYAL_BLUE_get() {
15536   void * jresult;
15537   Dali::Vector4 *result = 0 ;
15538
15539   result = (Dali::Vector4 *)&Dali::Color::ROYAL_BLUE;
15540   jresult = (void *)result;
15541   return jresult;
15542 }
15543
15544
15545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SADDLE_BROWN_get() {
15546   void * jresult;
15547   Dali::Vector4 *result = 0 ;
15548
15549   result = (Dali::Vector4 *)&Dali::Color::SADDLE_BROWN;
15550   jresult = (void *)result;
15551   return jresult;
15552 }
15553
15554
15555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SALMON_get() {
15556   void * jresult;
15557   Dali::Vector4 *result = 0 ;
15558
15559   result = (Dali::Vector4 *)&Dali::Color::SALMON;
15560   jresult = (void *)result;
15561   return jresult;
15562 }
15563
15564
15565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SANDY_BROWN_get() {
15566   void * jresult;
15567   Dali::Vector4 *result = 0 ;
15568
15569   result = (Dali::Vector4 *)&Dali::Color::SANDY_BROWN;
15570   jresult = (void *)result;
15571   return jresult;
15572 }
15573
15574
15575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SEA_GREEN_get() {
15576   void * jresult;
15577   Dali::Vector4 *result = 0 ;
15578
15579   result = (Dali::Vector4 *)&Dali::Color::SEA_GREEN;
15580   jresult = (void *)result;
15581   return jresult;
15582 }
15583
15584
15585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SEA_SHELL_get() {
15586   void * jresult;
15587   Dali::Vector4 *result = 0 ;
15588
15589   result = (Dali::Vector4 *)&Dali::Color::SEA_SHELL;
15590   jresult = (void *)result;
15591   return jresult;
15592 }
15593
15594
15595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SIENNA_get() {
15596   void * jresult;
15597   Dali::Vector4 *result = 0 ;
15598
15599   result = (Dali::Vector4 *)&Dali::Color::SIENNA;
15600   jresult = (void *)result;
15601   return jresult;
15602 }
15603
15604
15605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SILVER_get() {
15606   void * jresult;
15607   Dali::Vector4 *result = 0 ;
15608
15609   result = (Dali::Vector4 *)&Dali::Color::SILVER;
15610   jresult = (void *)result;
15611   return jresult;
15612 }
15613
15614
15615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SKY_BLUE_get() {
15616   void * jresult;
15617   Dali::Vector4 *result = 0 ;
15618
15619   result = (Dali::Vector4 *)&Dali::Color::SKY_BLUE;
15620   jresult = (void *)result;
15621   return jresult;
15622 }
15623
15624
15625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SLATE_BLUE_get() {
15626   void * jresult;
15627   Dali::Vector4 *result = 0 ;
15628
15629   result = (Dali::Vector4 *)&Dali::Color::SLATE_BLUE;
15630   jresult = (void *)result;
15631   return jresult;
15632 }
15633
15634
15635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SLATE_GRAY_get() {
15636   void * jresult;
15637   Dali::Vector4 *result = 0 ;
15638
15639   result = (Dali::Vector4 *)&Dali::Color::SLATE_GRAY;
15640   jresult = (void *)result;
15641   return jresult;
15642 }
15643
15644
15645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SLATE_GREY_get() {
15646   void * jresult;
15647   Dali::Vector4 *result = 0 ;
15648
15649   result = (Dali::Vector4 *)&Dali::Color::SLATE_GREY;
15650   jresult = (void *)result;
15651   return jresult;
15652 }
15653
15654
15655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SNOW_get() {
15656   void * jresult;
15657   Dali::Vector4 *result = 0 ;
15658
15659   result = (Dali::Vector4 *)&Dali::Color::SNOW;
15660   jresult = (void *)result;
15661   return jresult;
15662 }
15663
15664
15665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SPRING_GREEN_get() {
15666   void * jresult;
15667   Dali::Vector4 *result = 0 ;
15668
15669   result = (Dali::Vector4 *)&Dali::Color::SPRING_GREEN;
15670   jresult = (void *)result;
15671   return jresult;
15672 }
15673
15674
15675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_STEEL_BLUE_get() {
15676   void * jresult;
15677   Dali::Vector4 *result = 0 ;
15678
15679   result = (Dali::Vector4 *)&Dali::Color::STEEL_BLUE;
15680   jresult = (void *)result;
15681   return jresult;
15682 }
15683
15684
15685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TAN_get() {
15686   void * jresult;
15687   Dali::Vector4 *result = 0 ;
15688
15689   result = (Dali::Vector4 *)&Dali::Color::TAN;
15690   jresult = (void *)result;
15691   return jresult;
15692 }
15693
15694
15695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TEAL_get() {
15696   void * jresult;
15697   Dali::Vector4 *result = 0 ;
15698
15699   result = (Dali::Vector4 *)&Dali::Color::TEAL;
15700   jresult = (void *)result;
15701   return jresult;
15702 }
15703
15704
15705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_THISTLE_get() {
15706   void * jresult;
15707   Dali::Vector4 *result = 0 ;
15708
15709   result = (Dali::Vector4 *)&Dali::Color::THISTLE;
15710   jresult = (void *)result;
15711   return jresult;
15712 }
15713
15714
15715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TOMATO_get() {
15716   void * jresult;
15717   Dali::Vector4 *result = 0 ;
15718
15719   result = (Dali::Vector4 *)&Dali::Color::TOMATO;
15720   jresult = (void *)result;
15721   return jresult;
15722 }
15723
15724
15725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
15726   void * jresult;
15727   Dali::Vector4 *result = 0 ;
15728
15729   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
15730   jresult = (void *)result;
15731   return jresult;
15732 }
15733
15734
15735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TURQUOISE_get() {
15736   void * jresult;
15737   Dali::Vector4 *result = 0 ;
15738
15739   result = (Dali::Vector4 *)&Dali::Color::TURQUOISE;
15740   jresult = (void *)result;
15741   return jresult;
15742 }
15743
15744
15745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VIOLET_get() {
15746   void * jresult;
15747   Dali::Vector4 *result = 0 ;
15748
15749   result = (Dali::Vector4 *)&Dali::Color::VIOLET;
15750   jresult = (void *)result;
15751   return jresult;
15752 }
15753
15754
15755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHEAT_get() {
15756   void * jresult;
15757   Dali::Vector4 *result = 0 ;
15758
15759   result = (Dali::Vector4 *)&Dali::Color::WHEAT;
15760   jresult = (void *)result;
15761   return jresult;
15762 }
15763
15764
15765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
15766   void * jresult;
15767   Dali::Vector4 *result = 0 ;
15768
15769   result = (Dali::Vector4 *)&Dali::Color::WHITE;
15770   jresult = (void *)result;
15771   return jresult;
15772 }
15773
15774
15775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_SMOKE_get() {
15776   void * jresult;
15777   Dali::Vector4 *result = 0 ;
15778
15779   result = (Dali::Vector4 *)&Dali::Color::WHITE_SMOKE;
15780   jresult = (void *)result;
15781   return jresult;
15782 }
15783
15784
15785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
15786   void * jresult;
15787   Dali::Vector4 *result = 0 ;
15788
15789   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
15790   jresult = (void *)result;
15791   return jresult;
15792 }
15793
15794
15795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_GREEN_get() {
15796   void * jresult;
15797   Dali::Vector4 *result = 0 ;
15798
15799   result = (Dali::Vector4 *)&Dali::Color::YELLOW_GREEN;
15800   jresult = (void *)result;
15801   return jresult;
15802 }
15803
15804
15805 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
15806   float jresult ;
15807   float result;
15808
15809   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
15810   jresult = result;
15811   return jresult;
15812 }
15813
15814
15815 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
15816   float jresult ;
15817   float result;
15818
15819   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
15820   jresult = result;
15821   return jresult;
15822 }
15823
15824
15825 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
15826   float jresult ;
15827   float result;
15828
15829   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
15830   jresult = result;
15831   return jresult;
15832 }
15833
15834
15835 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
15836   float jresult ;
15837   float result;
15838
15839   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
15840   jresult = result;
15841   return jresult;
15842 }
15843
15844
15845 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
15846   float jresult ;
15847   float result;
15848
15849   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
15850   jresult = result;
15851   return jresult;
15852 }
15853
15854
15855 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
15856   float jresult ;
15857   float result;
15858
15859   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
15860   jresult = result;
15861   return jresult;
15862 }
15863
15864
15865 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
15866   float jresult ;
15867   float result;
15868
15869   result = (float)(float)Dali::Math::PI;
15870   jresult = result;
15871   return jresult;
15872 }
15873
15874
15875 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
15876   float jresult ;
15877   float result;
15878
15879   result = (float)(float)Dali::Math::PI_2;
15880   jresult = result;
15881   return jresult;
15882 }
15883
15884
15885 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
15886   float jresult ;
15887   float result;
15888
15889   result = (float)(float)Dali::Math::PI_4;
15890   jresult = result;
15891   return jresult;
15892 }
15893
15894
15895 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
15896   float jresult ;
15897   float result;
15898
15899   result = (float)(float)Dali::Math::PI_OVER_180;
15900   jresult = result;
15901   return jresult;
15902 }
15903
15904
15905 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
15906   float jresult ;
15907   float result;
15908
15909   result = (float)(float)Dali::Math::ONE80_OVER_PI;
15910   jresult = result;
15911   return jresult;
15912 }
15913
15914
15915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
15916   int jresult ;
15917   Dali::ResizePolicy::Type result;
15918
15919   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
15920   jresult = (int)result;
15921   return jresult;
15922 }
15923
15924
15925 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
15926   unsigned long jresult ;
15927   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
15928   Dali::VectorBase::SizeType result;
15929
15930   arg1 = (Dali::VectorBase *)jarg1;
15931   {
15932     try {
15933       result = ((Dali::VectorBase const *)arg1)->Count();
15934     } CALL_CATCH_EXCEPTION(0);
15935   }
15936
15937   jresult = (unsigned long)result;
15938   return jresult;
15939 }
15940
15941
15942 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
15943   unsigned long jresult ;
15944   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
15945   Dali::VectorBase::SizeType result;
15946
15947   arg1 = (Dali::VectorBase *)jarg1;
15948   {
15949     try {
15950       result = ((Dali::VectorBase const *)arg1)->Size();
15951     } CALL_CATCH_EXCEPTION(0);
15952   }
15953
15954   jresult = (unsigned long)result;
15955   return jresult;
15956 }
15957
15958
15959 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
15960   bool jresult ;
15961   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
15962   bool result;
15963
15964   arg1 = (Dali::VectorBase *)jarg1;
15965   {
15966     try {
15967       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
15968     } CALL_CATCH_EXCEPTION(0);
15969   }
15970
15971   jresult = result;
15972   return jresult;
15973 }
15974
15975
15976 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
15977   unsigned long jresult ;
15978   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
15979   Dali::VectorBase::SizeType result;
15980
15981   arg1 = (Dali::VectorBase *)jarg1;
15982   {
15983     try {
15984       result = ((Dali::VectorBase const *)arg1)->Capacity();
15985     } CALL_CATCH_EXCEPTION(0);
15986   }
15987
15988   jresult = (unsigned long)result;
15989   return jresult;
15990 }
15991
15992
15993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
15994   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
15995
15996   arg1 = (Dali::VectorBase *)jarg1;
15997   {
15998     try {
15999       (arg1)->Release();
16000     } CALL_CATCH_EXCEPTION();
16001   }
16002
16003 }
16004
16005
16006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
16007   int jresult ;
16008   Dali::Pixel::Format result;
16009
16010   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
16011   jresult = (int)result;
16012   return jresult;
16013 }
16014
16015
16016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
16017   int jresult ;
16018   Dali::Pixel::Format result;
16019
16020   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
16021   jresult = (int)result;
16022   return jresult;
16023 }
16024
16025
16026 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
16027   bool jresult ;
16028   Dali::Pixel::Format arg1 ;
16029   bool result;
16030
16031   arg1 = (Dali::Pixel::Format)jarg1;
16032   {
16033     try {
16034       result = (bool)Dali::Pixel::HasAlpha(arg1);
16035     } CALL_CATCH_EXCEPTION(0);
16036   }
16037
16038   jresult = result;
16039   return jresult;
16040 }
16041
16042
16043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
16044   unsigned int jresult ;
16045   Dali::Pixel::Format arg1 ;
16046   unsigned int result;
16047
16048   arg1 = (Dali::Pixel::Format)jarg1;
16049   {
16050     try {
16051       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
16052     } CALL_CATCH_EXCEPTION(0);
16053   }
16054
16055   jresult = result;
16056   return jresult;
16057 }
16058
16059
16060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
16061   Dali::Pixel::Format arg1 ;
16062   int *arg2 = 0 ;
16063   int *arg3 = 0 ;
16064
16065   arg1 = (Dali::Pixel::Format)jarg1;
16066   arg2 = (int *)jarg2;
16067   if (!arg2) {
16068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
16069     return ;
16070   }
16071   arg3 = (int *)jarg3;
16072   if (!arg3) {
16073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
16074     return ;
16075   }
16076   {
16077     try {
16078       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
16079     } CALL_CATCH_EXCEPTION();
16080   }
16081
16082 }
16083
16084
16085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* nuiBuffer, unsigned int nuiBufferSize, unsigned int nuiWidth, unsigned int nuiHeight, int nuiPixelFormat) {
16086   void * jresult ;
16087   Dali::PixelData result;
16088
16089   {
16090     unsigned char* copiedBuffer;
16091     try
16092     {
16093       copiedBuffer = new unsigned char[nuiBufferSize];
16094     } CALL_CATCH_EXCEPTION(0);
16095
16096     try
16097     {
16098       // Note : copiedBuffer created by 'new' method. So ReleaseFunction always be DELETE_ARRAY.
16099       memcpy(copiedBuffer, nuiBuffer, nuiBufferSize);
16100       result = Dali::PixelData::New(copiedBuffer, nuiBufferSize, nuiWidth, nuiHeight, (Dali::Pixel::Format)nuiPixelFormat, Dali::PixelData::ReleaseFunction::DELETE_ARRAY);
16101     } CALL_CATCH_EXCEPTION_WITH_FUNCTION(0, [](unsigned char* buffer){delete[] buffer;}, copiedBuffer);
16102   }
16103
16104   jresult = new Dali::PixelData((const Dali::PixelData &)result);
16105
16106   return jresult;
16107 }
16108
16109
16110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
16111   void * jresult ;
16112   Dali::PixelData *result = 0 ;
16113
16114   {
16115     try {
16116       result = (Dali::PixelData *)new Dali::PixelData();
16117     } CALL_CATCH_EXCEPTION(0);
16118   }
16119
16120   jresult = (void *)result;
16121   return jresult;
16122 }
16123
16124
16125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * nuiHandle) {
16126   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
16127
16128   pixelData = (Dali::PixelData *)nuiHandle;
16129   {
16130     try {
16131       delete pixelData;
16132     } CALL_CATCH_EXCEPTION();
16133   }
16134
16135 }
16136
16137
16138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * nuiHandle) {
16139   void * jresult ;
16140   Dali::PixelData *pixelData = 0 ;
16141   Dali::PixelData *result = 0 ;
16142
16143   pixelData = (Dali::PixelData *)nuiHandle;
16144   if (!pixelData) {
16145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
16146     return 0;
16147   }
16148   {
16149     try {
16150       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*pixelData);
16151     } CALL_CATCH_EXCEPTION(0);
16152   }
16153
16154   jresult = (void *)result;
16155   return jresult;
16156 }
16157
16158
16159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * nuiHandle, void * nuiHandleSource) {
16160   void * jresult ;
16161   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
16162   Dali::PixelData *pixelDataSource = 0 ;
16163   Dali::PixelData *result = 0 ;
16164
16165   pixelData = (Dali::PixelData *)nuiHandle;
16166   pixelDataSource = (Dali::PixelData *)nuiHandleSource;
16167   if (!pixelDataSource) {
16168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
16169     return 0;
16170   }
16171   {
16172     try {
16173       result = (Dali::PixelData *) &(pixelData)->operator =((Dali::PixelData const &)*pixelDataSource);
16174     } CALL_CATCH_EXCEPTION(0);
16175   }
16176
16177   jresult = (void *)result;
16178   return jresult;
16179 }
16180
16181
16182 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * nuiHandle) {
16183   unsigned int jresult ;
16184   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
16185   unsigned int result;
16186
16187   pixelData = (Dali::PixelData *)nuiHandle;
16188   {
16189     try {
16190       result = (unsigned int)((Dali::PixelData const *)pixelData)->GetWidth();
16191     } CALL_CATCH_EXCEPTION(0);
16192   }
16193
16194   jresult = result;
16195   return jresult;
16196 }
16197
16198
16199 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * nuiHandle) {
16200   unsigned int jresult ;
16201   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
16202   unsigned int result;
16203
16204   pixelData = (Dali::PixelData *)nuiHandle;
16205   {
16206     try {
16207       result = (unsigned int)((Dali::PixelData const *)pixelData)->GetHeight();
16208     } CALL_CATCH_EXCEPTION(0);
16209   }
16210
16211   jresult = result;
16212   return jresult;
16213 }
16214
16215
16216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * nuiHandle) {
16217   int jresult ;
16218   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
16219   Dali::Pixel::Format result;
16220
16221   pixelData = (Dali::PixelData *)nuiHandle;
16222   {
16223     try {
16224       result = (Dali::Pixel::Format)((Dali::PixelData const *)pixelData)->GetPixelFormat();
16225     } CALL_CATCH_EXCEPTION(0);
16226   }
16227
16228   jresult = (int)result;
16229   return jresult;
16230 }
16231
16232 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_PixelData_GenerateUrl(void* nuiHandle)
16233 {
16234   Dali::PixelData *pixelData = (Dali::PixelData*)nuiHandle;
16235   Dali::Toolkit::ImageUrl result;
16236   void *jresult;
16237
16238   if (!pixelData)
16239   {
16240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0);
16241     return 0;
16242   }
16243   {
16244     try
16245     {
16246       result = Dali::Toolkit::Image::GenerateUrl(*pixelData);
16247     } CALL_CATCH_EXCEPTION(0);
16248   }
16249
16250   jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl&)result);
16251   return jresult;
16252 }
16253
16254
16255 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
16256   unsigned int jresult ;
16257   unsigned int result;
16258
16259   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
16260   jresult = result;
16261   return jresult;
16262 }
16263
16264
16265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
16266   unsigned int jresult ;
16267   unsigned int result;
16268
16269   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
16270   jresult = result;
16271   return jresult;
16272 }
16273
16274
16275 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
16276   unsigned int jresult ;
16277   unsigned int result;
16278
16279   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
16280   jresult = result;
16281   return jresult;
16282 }
16283
16284
16285 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
16286   unsigned int jresult ;
16287   unsigned int result;
16288
16289   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
16290   jresult = result;
16291   return jresult;
16292 }
16293
16294
16295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
16296   unsigned int jresult ;
16297   unsigned int result;
16298
16299   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
16300   jresult = result;
16301   return jresult;
16302 }
16303
16304
16305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
16306   unsigned int jresult ;
16307   unsigned int result;
16308
16309   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
16310   jresult = result;
16311   return jresult;
16312 }
16313
16314
16315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
16316   void * jresult ;
16317   Dali::TextureType::Type arg1 ;
16318   Dali::Pixel::Format arg2 ;
16319   unsigned int arg3 ;
16320   unsigned int arg4 ;
16321   Dali::Texture result;
16322
16323   arg1 = (Dali::TextureType::Type)jarg1;
16324   arg2 = (Dali::Pixel::Format)jarg2;
16325   arg3 = (unsigned int)jarg3;
16326   arg4 = (unsigned int)jarg4;
16327   {
16328     try {
16329       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
16330     } CALL_CATCH_EXCEPTION(0);
16331   }
16332
16333   jresult = new Dali::Texture((const Dali::Texture &)result);
16334   return jresult;
16335 }
16336
16337
16338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
16339   void * jresult ;
16340   NativeImageInterface *arg1 = 0 ;
16341   Dali::Texture result;
16342
16343   arg1 = (NativeImageInterface *)jarg1;
16344   if (!arg1) {
16345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
16346     return 0;
16347   }
16348   {
16349     try {
16350       result = Dali::Texture::New(*arg1);
16351     } CALL_CATCH_EXCEPTION(0);
16352   }
16353
16354   jresult = new Dali::Texture((const Dali::Texture &)result);
16355   return jresult;
16356 }
16357
16358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
16359   void * jresult ;
16360   Dali::Texture *result = 0 ;
16361
16362   {
16363     try {
16364       result = (Dali::Texture *)new Dali::Texture();
16365     } CALL_CATCH_EXCEPTION(0);
16366   }
16367
16368   jresult = (void *)result;
16369   return jresult;
16370 }
16371
16372
16373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
16374   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16375
16376   arg1 = (Dali::Texture *)jarg1;
16377   {
16378     try {
16379       delete arg1;
16380     } CALL_CATCH_EXCEPTION();
16381   }
16382
16383 }
16384
16385
16386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
16387   void * jresult ;
16388   Dali::Texture *arg1 = 0 ;
16389   Dali::Texture *result = 0 ;
16390
16391   arg1 = (Dali::Texture *)jarg1;
16392   if (!arg1) {
16393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
16394     return 0;
16395   }
16396   {
16397     try {
16398       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
16399     } CALL_CATCH_EXCEPTION(0);
16400   }
16401
16402   jresult = (void *)result;
16403   return jresult;
16404 }
16405
16406
16407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
16408   void * jresult ;
16409   Dali::BaseHandle arg1 ;
16410   Dali::BaseHandle *argp1 ;
16411   Dali::Texture result;
16412
16413   argp1 = (Dali::BaseHandle *)jarg1;
16414   if (!argp1) {
16415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16416     return 0;
16417   }
16418   arg1 = *argp1;
16419   {
16420     try {
16421       result = Dali::Texture::DownCast(arg1);
16422     } CALL_CATCH_EXCEPTION(0);
16423   }
16424
16425   jresult = new Dali::Texture((const Dali::Texture &)result);
16426   return jresult;
16427 }
16428
16429
16430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
16431   void * jresult ;
16432   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16433   Dali::Texture *arg2 = 0 ;
16434   Dali::Texture *result = 0 ;
16435
16436   arg1 = (Dali::Texture *)jarg1;
16437   arg2 = (Dali::Texture *)jarg2;
16438   if (!arg2) {
16439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
16440     return 0;
16441   }
16442   {
16443     try {
16444       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
16445     } CALL_CATCH_EXCEPTION(0);
16446   }
16447
16448   jresult = (void *)result;
16449   return jresult;
16450 }
16451
16452
16453 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
16454   bool jresult ;
16455   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16456   Dali::PixelData arg2 ;
16457   Dali::PixelData *argp2 ;
16458   bool result;
16459
16460   arg1 = (Dali::Texture *)jarg1;
16461   argp2 = (Dali::PixelData *)jarg2;
16462   if (!argp2) {
16463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
16464     return 0;
16465   }
16466   arg2 = *argp2;
16467   {
16468     try {
16469       result = (bool)(arg1)->Upload(arg2);
16470     } CALL_CATCH_EXCEPTION(0);
16471   }
16472
16473   jresult = result;
16474   return jresult;
16475 }
16476
16477
16478 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) {
16479   bool jresult ;
16480   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16481   Dali::PixelData arg2 ;
16482   unsigned int arg3 ;
16483   unsigned int arg4 ;
16484   unsigned int arg5 ;
16485   unsigned int arg6 ;
16486   unsigned int arg7 ;
16487   unsigned int arg8 ;
16488   Dali::PixelData *argp2 ;
16489   bool result;
16490
16491   arg1 = (Dali::Texture *)jarg1;
16492   argp2 = (Dali::PixelData *)jarg2;
16493   if (!argp2) {
16494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
16495     return 0;
16496   }
16497   arg2 = *argp2;
16498   arg3 = (unsigned int)jarg3;
16499   arg4 = (unsigned int)jarg4;
16500   arg5 = (unsigned int)jarg5;
16501   arg6 = (unsigned int)jarg6;
16502   arg7 = (unsigned int)jarg7;
16503   arg8 = (unsigned int)jarg8;
16504   {
16505     try {
16506       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
16507     } CALL_CATCH_EXCEPTION(0);
16508   }
16509
16510   jresult = result;
16511   return jresult;
16512 }
16513
16514
16515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
16516   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16517
16518   arg1 = (Dali::Texture *)jarg1;
16519   {
16520     try {
16521       (arg1)->GenerateMipmaps();
16522     } CALL_CATCH_EXCEPTION();
16523   }
16524
16525 }
16526
16527
16528 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
16529   unsigned int jresult ;
16530   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16531   unsigned int result;
16532
16533   arg1 = (Dali::Texture *)jarg1;
16534   {
16535     try {
16536       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
16537     } CALL_CATCH_EXCEPTION(0);
16538   }
16539
16540   jresult = result;
16541   return jresult;
16542 }
16543
16544
16545 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
16546   unsigned int jresult ;
16547   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16548   unsigned int result;
16549
16550   arg1 = (Dali::Texture *)jarg1;
16551   {
16552     try {
16553       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
16554     } CALL_CATCH_EXCEPTION(0);
16555   }
16556
16557   jresult = result;
16558   return jresult;
16559 }
16560
16561
16562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
16563   void * jresult ;
16564   Dali::Sampler result;
16565
16566   {
16567     try {
16568       result = Dali::Sampler::New();
16569     } CALL_CATCH_EXCEPTION(0);
16570   }
16571
16572   jresult = new Dali::Sampler((const Dali::Sampler &)result);
16573   return jresult;
16574 }
16575
16576
16577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
16578   void * jresult ;
16579   Dali::Sampler *result = 0 ;
16580
16581   {
16582     try {
16583       result = (Dali::Sampler *)new Dali::Sampler();
16584     } CALL_CATCH_EXCEPTION(0);
16585   }
16586
16587   jresult = (void *)result;
16588   return jresult;
16589 }
16590
16591
16592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
16593   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
16594
16595   arg1 = (Dali::Sampler *)jarg1;
16596   {
16597     try {
16598       delete arg1;
16599     } CALL_CATCH_EXCEPTION();
16600   }
16601
16602 }
16603
16604
16605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
16606   void * jresult ;
16607   Dali::Sampler *arg1 = 0 ;
16608   Dali::Sampler *result = 0 ;
16609
16610   arg1 = (Dali::Sampler *)jarg1;
16611   if (!arg1) {
16612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
16613     return 0;
16614   }
16615   {
16616     try {
16617       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
16618     } CALL_CATCH_EXCEPTION(0);
16619   }
16620
16621   jresult = (void *)result;
16622   return jresult;
16623 }
16624
16625
16626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
16627   void * jresult ;
16628   Dali::BaseHandle arg1 ;
16629   Dali::BaseHandle *argp1 ;
16630   Dali::Sampler result;
16631
16632   argp1 = (Dali::BaseHandle *)jarg1;
16633   if (!argp1) {
16634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16635     return 0;
16636   }
16637   arg1 = *argp1;
16638   {
16639     try {
16640       result = Dali::Sampler::DownCast(arg1);
16641     } CALL_CATCH_EXCEPTION(0);
16642   }
16643
16644   jresult = new Dali::Sampler((const Dali::Sampler &)result);
16645   return jresult;
16646 }
16647
16648
16649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
16650   void * jresult ;
16651   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
16652   Dali::Sampler *arg2 = 0 ;
16653   Dali::Sampler *result = 0 ;
16654
16655   arg1 = (Dali::Sampler *)jarg1;
16656   arg2 = (Dali::Sampler *)jarg2;
16657   if (!arg2) {
16658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
16659     return 0;
16660   }
16661   {
16662     try {
16663       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
16664     } CALL_CATCH_EXCEPTION(0);
16665   }
16666
16667   jresult = (void *)result;
16668   return jresult;
16669 }
16670
16671
16672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
16673   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
16674   Dali::FilterMode::Type arg2 ;
16675   Dali::FilterMode::Type arg3 ;
16676
16677   arg1 = (Dali::Sampler *)jarg1;
16678   arg2 = (Dali::FilterMode::Type)jarg2;
16679   arg3 = (Dali::FilterMode::Type)jarg3;
16680   {
16681     try {
16682       (arg1)->SetFilterMode(arg2,arg3);
16683     } CALL_CATCH_EXCEPTION();
16684   }
16685
16686 }
16687
16688
16689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
16690   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
16691   Dali::WrapMode::Type arg2 ;
16692   Dali::WrapMode::Type arg3 ;
16693
16694   arg1 = (Dali::Sampler *)jarg1;
16695   arg2 = (Dali::WrapMode::Type)jarg2;
16696   arg3 = (Dali::WrapMode::Type)jarg3;
16697   {
16698     try {
16699       (arg1)->SetWrapMode(arg2,arg3);
16700     } CALL_CATCH_EXCEPTION();
16701   }
16702
16703 }
16704
16705
16706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
16707   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
16708   Dali::WrapMode::Type arg2 ;
16709   Dali::WrapMode::Type arg3 ;
16710   Dali::WrapMode::Type arg4 ;
16711
16712   arg1 = (Dali::Sampler *)jarg1;
16713   arg2 = (Dali::WrapMode::Type)jarg2;
16714   arg3 = (Dali::WrapMode::Type)jarg3;
16715   arg4 = (Dali::WrapMode::Type)jarg4;
16716   {
16717     try {
16718       (arg1)->SetWrapMode(arg2,arg3,arg4);
16719     } CALL_CATCH_EXCEPTION();
16720   }
16721
16722 }
16723
16724
16725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
16726   void * jresult ;
16727   Dali::TextureSet result;
16728
16729   {
16730     try {
16731       result = Dali::TextureSet::New();
16732     } CALL_CATCH_EXCEPTION(0);
16733   }
16734
16735   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
16736   return jresult;
16737 }
16738
16739
16740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
16741   void * jresult ;
16742   Dali::TextureSet *result = 0 ;
16743
16744   {
16745     try {
16746       result = (Dali::TextureSet *)new Dali::TextureSet();
16747     } CALL_CATCH_EXCEPTION(0);
16748   }
16749
16750   jresult = (void *)result;
16751   return jresult;
16752 }
16753
16754
16755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
16756   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
16757
16758   arg1 = (Dali::TextureSet *)jarg1;
16759   {
16760     try {
16761       delete arg1;
16762     } CALL_CATCH_EXCEPTION();
16763   }
16764
16765 }
16766
16767
16768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
16769   void * jresult ;
16770   Dali::TextureSet *arg1 = 0 ;
16771   Dali::TextureSet *result = 0 ;
16772
16773   arg1 = (Dali::TextureSet *)jarg1;
16774   if (!arg1) {
16775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
16776     return 0;
16777   }
16778   {
16779     try {
16780       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
16781     } CALL_CATCH_EXCEPTION(0);
16782   }
16783
16784   jresult = (void *)result;
16785   return jresult;
16786 }
16787
16788
16789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
16790   void * jresult ;
16791   Dali::BaseHandle arg1 ;
16792   Dali::BaseHandle *argp1 ;
16793   Dali::TextureSet result;
16794
16795   argp1 = (Dali::BaseHandle *)jarg1;
16796   if (!argp1) {
16797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16798     return 0;
16799   }
16800   arg1 = *argp1;
16801   {
16802     try {
16803       result = Dali::TextureSet::DownCast(arg1);
16804     } CALL_CATCH_EXCEPTION(0);
16805   }
16806
16807   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
16808   return jresult;
16809 }
16810
16811
16812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
16813   void * jresult ;
16814   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
16815   Dali::TextureSet *arg2 = 0 ;
16816   Dali::TextureSet *result = 0 ;
16817
16818   arg1 = (Dali::TextureSet *)jarg1;
16819   arg2 = (Dali::TextureSet *)jarg2;
16820   if (!arg2) {
16821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
16822     return 0;
16823   }
16824   {
16825     try {
16826       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
16827     } CALL_CATCH_EXCEPTION(0);
16828   }
16829
16830   jresult = (void *)result;
16831   return jresult;
16832 }
16833
16834
16835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
16836   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
16837   size_t arg2 ;
16838   Dali::Texture arg3 ;
16839   Dali::Texture *argp3 ;
16840
16841   arg1 = (Dali::TextureSet *)jarg1;
16842   arg2 = (size_t)jarg2;
16843   argp3 = (Dali::Texture *)jarg3;
16844   if (!argp3) {
16845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
16846     return ;
16847   }
16848   arg3 = *argp3;
16849   {
16850     try {
16851       (arg1)->SetTexture(arg2,arg3);
16852     } CALL_CATCH_EXCEPTION();
16853   }
16854
16855 }
16856
16857
16858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
16859   void * jresult ;
16860   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
16861   size_t arg2 ;
16862   Dali::Texture result;
16863
16864   arg1 = (Dali::TextureSet *)jarg1;
16865   arg2 = (size_t)jarg2;
16866   {
16867     try {
16868       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
16869     } CALL_CATCH_EXCEPTION(0);
16870   }
16871
16872   jresult = new Dali::Texture((const Dali::Texture &)result);
16873   return jresult;
16874 }
16875
16876
16877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
16878   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
16879   size_t arg2 ;
16880   Dali::Sampler arg3 ;
16881   Dali::Sampler *argp3 ;
16882
16883   arg1 = (Dali::TextureSet *)jarg1;
16884   arg2 = (size_t)jarg2;
16885   argp3 = (Dali::Sampler *)jarg3;
16886   if (!argp3) {
16887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
16888     return ;
16889   }
16890   arg3 = *argp3;
16891   {
16892     try {
16893       (arg1)->SetSampler(arg2,arg3);
16894     } CALL_CATCH_EXCEPTION();
16895   }
16896
16897 }
16898
16899
16900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
16901   void * jresult ;
16902   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
16903   size_t arg2 ;
16904   Dali::Sampler result;
16905
16906   arg1 = (Dali::TextureSet *)jarg1;
16907   arg2 = (size_t)jarg2;
16908   {
16909     try {
16910       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
16911     } CALL_CATCH_EXCEPTION(0);
16912   }
16913
16914   jresult = new Dali::Sampler((const Dali::Sampler &)result);
16915   return jresult;
16916 }
16917
16918
16919 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
16920   unsigned long jresult ;
16921   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
16922   size_t result;
16923
16924   arg1 = (Dali::TextureSet *)jarg1;
16925   {
16926     try {
16927       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
16928     } CALL_CATCH_EXCEPTION(0);
16929   }
16930
16931   jresult = (unsigned long)result;
16932   return jresult;
16933 }
16934
16935
16936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_New(void * jarg1) {
16937   void * jresult ;
16938   Dali::Property::Map *arg1 = 0 ;
16939   Dali::VertexBuffer result;
16940
16941   arg1 = (Dali::Property::Map *)jarg1;
16942   if (!arg1) {
16943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
16944     return 0;
16945   }
16946   {
16947     try {
16948       result = Dali::VertexBuffer::New(*arg1);
16949     } CALL_CATCH_EXCEPTION(0);
16950   }
16951
16952   jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result);
16953   return jresult;
16954 }
16955
16956
16957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_0() {
16958   void * jresult ;
16959   Dali::VertexBuffer *result = 0 ;
16960
16961   {
16962     try {
16963       result = (Dali::VertexBuffer *)new Dali::VertexBuffer();
16964     } CALL_CATCH_EXCEPTION(0);
16965   }
16966
16967   jresult = (void *)result;
16968   return jresult;
16969 }
16970
16971
16972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VertexBuffer(void * jarg1) {
16973   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
16974
16975   arg1 = (Dali::VertexBuffer *)jarg1;
16976   {
16977     try {
16978       delete arg1;
16979     } CALL_CATCH_EXCEPTION();
16980   }
16981
16982 }
16983
16984
16985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_1(void * jarg1) {
16986   void * jresult ;
16987   Dali::VertexBuffer *arg1 = 0 ;
16988   Dali::VertexBuffer *result = 0 ;
16989
16990   arg1 = (Dali::VertexBuffer *)jarg1;
16991   if (!arg1) {
16992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0);
16993     return 0;
16994   }
16995   {
16996     try {
16997       result = (Dali::VertexBuffer *)new Dali::VertexBuffer((Dali::VertexBuffer const &)*arg1);
16998     } CALL_CATCH_EXCEPTION(0);
16999   }
17000
17001   jresult = (void *)result;
17002   return jresult;
17003 }
17004
17005
17006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_DownCast(void * jarg1) {
17007   void * jresult ;
17008   Dali::BaseHandle arg1 ;
17009   Dali::BaseHandle *argp1 ;
17010   Dali::VertexBuffer result;
17011
17012   argp1 = (Dali::BaseHandle *)jarg1;
17013   if (!argp1) {
17014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17015     return 0;
17016   }
17017   arg1 = *argp1;
17018   {
17019     try {
17020       result = Dali::VertexBuffer::DownCast(arg1);
17021     } CALL_CATCH_EXCEPTION(0);
17022   }
17023
17024   jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result);
17025   return jresult;
17026 }
17027
17028
17029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_Assign(void * jarg1, void * jarg2) {
17030   void * jresult ;
17031   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
17032   Dali::VertexBuffer *arg2 = 0 ;
17033   Dali::VertexBuffer *result = 0 ;
17034
17035   arg1 = (Dali::VertexBuffer *)jarg1;
17036   arg2 = (Dali::VertexBuffer *)jarg2;
17037   if (!arg2) {
17038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0);
17039     return 0;
17040   }
17041   {
17042     try {
17043       result = (Dali::VertexBuffer *) &(arg1)->operator =((Dali::VertexBuffer const &)*arg2);
17044     } CALL_CATCH_EXCEPTION(0);
17045   }
17046
17047   jresult = (void *)result;
17048   return jresult;
17049 }
17050
17051
17052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VertexBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
17053   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
17054   void *arg2 = (void *) 0 ;
17055   std::size_t arg3 ;
17056
17057   arg1 = (Dali::VertexBuffer *)jarg1;
17058   arg2 = jarg2;
17059   arg3 = (std::size_t)jarg3;
17060   {
17061     try {
17062       (arg1)->SetData((void const *)arg2,arg3);
17063     } CALL_CATCH_EXCEPTION();
17064   }
17065
17066 }
17067
17068
17069 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VertexBuffer_GetSize(void * jarg1) {
17070   unsigned long jresult ;
17071   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
17072   std::size_t result;
17073
17074   arg1 = (Dali::VertexBuffer *)jarg1;
17075   {
17076     try {
17077       result = ((Dali::VertexBuffer const *)arg1)->GetSize();
17078     } CALL_CATCH_EXCEPTION(0);
17079   }
17080
17081   jresult = (unsigned long)result;
17082   return jresult;
17083 }
17084
17085
17086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
17087   void * jresult ;
17088   Dali::Geometry result;
17089
17090   {
17091     try {
17092       result = Dali::Geometry::New();
17093     } CALL_CATCH_EXCEPTION(0);
17094   }
17095
17096   jresult = new Dali::Geometry((const Dali::Geometry &)result);
17097   return jresult;
17098 }
17099
17100
17101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
17102   void * jresult ;
17103   Dali::Geometry *result = 0 ;
17104
17105   {
17106     try {
17107       result = (Dali::Geometry *)new Dali::Geometry();
17108     } CALL_CATCH_EXCEPTION(0);
17109   }
17110
17111   jresult = (void *)result;
17112   return jresult;
17113 }
17114
17115
17116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
17117   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17118
17119   arg1 = (Dali::Geometry *)jarg1;
17120   {
17121     try {
17122       delete arg1;
17123     } CALL_CATCH_EXCEPTION();
17124   }
17125
17126 }
17127
17128
17129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
17130   void * jresult ;
17131   Dali::Geometry *arg1 = 0 ;
17132   Dali::Geometry *result = 0 ;
17133
17134   arg1 = (Dali::Geometry *)jarg1;
17135   if (!arg1) {
17136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
17137     return 0;
17138   }
17139   {
17140     try {
17141       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
17142     } CALL_CATCH_EXCEPTION(0);
17143   }
17144
17145   jresult = (void *)result;
17146   return jresult;
17147 }
17148
17149
17150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
17151   void * jresult ;
17152   Dali::BaseHandle arg1 ;
17153   Dali::BaseHandle *argp1 ;
17154   Dali::Geometry result;
17155
17156   argp1 = (Dali::BaseHandle *)jarg1;
17157   if (!argp1) {
17158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17159     return 0;
17160   }
17161   arg1 = *argp1;
17162   {
17163     try {
17164       result = Dali::Geometry::DownCast(arg1);
17165     } CALL_CATCH_EXCEPTION(0);
17166   }
17167
17168   jresult = new Dali::Geometry((const Dali::Geometry &)result);
17169   return jresult;
17170 }
17171
17172
17173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
17174   void * jresult ;
17175   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17176   Dali::Geometry *arg2 = 0 ;
17177   Dali::Geometry *result = 0 ;
17178
17179   arg1 = (Dali::Geometry *)jarg1;
17180   arg2 = (Dali::Geometry *)jarg2;
17181   if (!arg2) {
17182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
17183     return 0;
17184   }
17185   {
17186     try {
17187       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
17188     } CALL_CATCH_EXCEPTION(0);
17189   }
17190
17191   jresult = (void *)result;
17192   return jresult;
17193 }
17194
17195
17196 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
17197   unsigned long jresult ;
17198   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17199   Dali::VertexBuffer *arg2 = 0 ;
17200   std::size_t result;
17201
17202   arg1 = (Dali::Geometry *)jarg1;
17203   arg2 = (Dali::VertexBuffer *)jarg2;
17204   if (!arg2) {
17205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer & type is null", 0);
17206     return 0;
17207   }
17208   {
17209     try {
17210       result = (arg1)->AddVertexBuffer(*arg2);
17211     } CALL_CATCH_EXCEPTION(0);
17212   }
17213
17214   jresult = (unsigned long)result;
17215   return jresult;
17216 }
17217
17218
17219 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
17220   unsigned long jresult ;
17221   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17222   std::size_t result;
17223
17224   arg1 = (Dali::Geometry *)jarg1;
17225   {
17226     try {
17227       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
17228     } CALL_CATCH_EXCEPTION(0);
17229   }
17230
17231   jresult = (unsigned long)result;
17232   return jresult;
17233 }
17234
17235
17236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
17237   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17238   std::size_t arg2 ;
17239
17240   arg1 = (Dali::Geometry *)jarg1;
17241   arg2 = (std::size_t)jarg2;
17242   {
17243     try {
17244       (arg1)->RemoveVertexBuffer(arg2);
17245     } CALL_CATCH_EXCEPTION();
17246   }
17247
17248 }
17249
17250
17251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
17252   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17253   unsigned short *arg2 = (unsigned short *) 0 ;
17254   size_t arg3 ;
17255
17256   arg1 = (Dali::Geometry *)jarg1;
17257   arg2 = jarg2;
17258   arg3 = (size_t)jarg3;
17259   {
17260     try {
17261       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
17262     } CALL_CATCH_EXCEPTION();
17263   }
17264
17265
17266
17267 }
17268
17269
17270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
17271   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17272   Dali::Geometry::Type arg2 ;
17273
17274   arg1 = (Dali::Geometry *)jarg1;
17275   arg2 = (Dali::Geometry::Type)jarg2;
17276   {
17277     try {
17278       (arg1)->SetType(arg2);
17279     } CALL_CATCH_EXCEPTION();
17280   }
17281
17282 }
17283
17284
17285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
17286   int jresult ;
17287   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17288   Dali::Geometry::Type result;
17289
17290   arg1 = (Dali::Geometry *)jarg1;
17291   {
17292     try {
17293       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
17294     } CALL_CATCH_EXCEPTION(0);
17295   }
17296
17297   jresult = (int)result;
17298   return jresult;
17299 }
17300
17301
17302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
17303   void * jresult ;
17304   Dali::Shader::Hint *result = 0 ;
17305
17306   {
17307     try {
17308       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
17309     } CALL_CATCH_EXCEPTION(0);
17310   }
17311
17312   jresult = (void *)result;
17313   return jresult;
17314 }
17315
17316
17317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
17318   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
17319
17320   arg1 = (Dali::Shader::Hint *)jarg1;
17321   {
17322     try {
17323       delete arg1;
17324     } CALL_CATCH_EXCEPTION();
17325   }
17326
17327 }
17328
17329
17330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
17331   int jresult ;
17332   int result;
17333
17334   result = (int)Dali::Shader::Property::PROGRAM;
17335   jresult = (int)result;
17336   return jresult;
17337 }
17338
17339
17340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
17341   void * jresult ;
17342   Dali::Shader::Property *result = 0 ;
17343
17344   {
17345     try {
17346       result = (Dali::Shader::Property *)new Dali::Shader::Property();
17347     } CALL_CATCH_EXCEPTION(0);
17348   }
17349
17350   jresult = (void *)result;
17351   return jresult;
17352 }
17353
17354
17355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
17356   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
17357
17358   arg1 = (Dali::Shader::Property *)jarg1;
17359   {
17360     try {
17361       delete arg1;
17362     } CALL_CATCH_EXCEPTION();
17363   }
17364
17365 }
17366
17367
17368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
17369   void * jresult ;
17370   std::string *arg1 = 0 ;
17371   std::string *arg2 = 0 ;
17372   Dali::Shader::Hint::Value arg3 ;
17373   Dali::Shader result;
17374
17375   if (!jarg1) {
17376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17377     return 0;
17378   }
17379   std::string arg1_str(jarg1);
17380   arg1 = &arg1_str;
17381   if (!jarg2) {
17382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17383     return 0;
17384   }
17385   std::string arg2_str(jarg2);
17386   arg2 = &arg2_str;
17387   arg3 = (Dali::Shader::Hint::Value)jarg3;
17388   {
17389     try {
17390       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
17391     } CALL_CATCH_EXCEPTION(0);
17392   }
17393
17394   jresult = new Dali::Shader((const Dali::Shader &)result);
17395
17396   //argout typemap for const std::string&
17397
17398
17399   //argout typemap for const std::string&
17400
17401   return jresult;
17402 }
17403
17404
17405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
17406   void * jresult ;
17407   std::string *arg1 = 0 ;
17408   std::string *arg2 = 0 ;
17409   Dali::Shader result;
17410
17411   if (!jarg1) {
17412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17413     return 0;
17414   }
17415   std::string arg1_str(jarg1);
17416   arg1 = &arg1_str;
17417   if (!jarg2) {
17418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17419     return 0;
17420   }
17421   std::string arg2_str(jarg2);
17422   arg2 = &arg2_str;
17423   {
17424     try {
17425       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
17426     } CALL_CATCH_EXCEPTION(0);
17427   }
17428
17429   jresult = new Dali::Shader((const Dali::Shader &)result);
17430
17431   //argout typemap for const std::string&
17432
17433
17434   //argout typemap for const std::string&
17435
17436   return jresult;
17437 }
17438
17439
17440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
17441   void * jresult ;
17442   Dali::Shader *result = 0 ;
17443
17444   {
17445     try {
17446       result = (Dali::Shader *)new Dali::Shader();
17447     } CALL_CATCH_EXCEPTION(0);
17448   }
17449
17450   jresult = (void *)result;
17451   return jresult;
17452 }
17453
17454
17455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
17456   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
17457
17458   arg1 = (Dali::Shader *)jarg1;
17459   {
17460     try {
17461       delete arg1;
17462     } CALL_CATCH_EXCEPTION();
17463   }
17464
17465 }
17466
17467
17468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
17469   void * jresult ;
17470   Dali::Shader *arg1 = 0 ;
17471   Dali::Shader *result = 0 ;
17472
17473   arg1 = (Dali::Shader *)jarg1;
17474   if (!arg1) {
17475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
17476     return 0;
17477   }
17478   {
17479     try {
17480       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
17481     } CALL_CATCH_EXCEPTION(0);
17482   }
17483
17484   jresult = (void *)result;
17485   return jresult;
17486 }
17487
17488
17489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
17490   void * jresult ;
17491   Dali::BaseHandle arg1 ;
17492   Dali::BaseHandle *argp1 ;
17493   Dali::Shader result;
17494
17495   argp1 = (Dali::BaseHandle *)jarg1;
17496   if (!argp1) {
17497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17498     return 0;
17499   }
17500   arg1 = *argp1;
17501   {
17502     try {
17503       result = Dali::Shader::DownCast(arg1);
17504     } CALL_CATCH_EXCEPTION(0);
17505   }
17506
17507   jresult = new Dali::Shader((const Dali::Shader &)result);
17508   return jresult;
17509 }
17510
17511
17512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
17513   void * jresult ;
17514   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
17515   Dali::Shader *arg2 = 0 ;
17516   Dali::Shader *result = 0 ;
17517
17518   arg1 = (Dali::Shader *)jarg1;
17519   arg2 = (Dali::Shader *)jarg2;
17520   if (!arg2) {
17521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
17522     return 0;
17523   }
17524   {
17525     try {
17526       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
17527     } CALL_CATCH_EXCEPTION(0);
17528   }
17529
17530   jresult = (void *)result;
17531   return jresult;
17532 }
17533
17534
17535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
17536   int jresult ;
17537   int result;
17538
17539   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
17540   jresult = (int)result;
17541   return jresult;
17542 }
17543
17544
17545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
17546   int jresult ;
17547   int result;
17548
17549   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
17550   jresult = (int)result;
17551   return jresult;
17552 }
17553
17554
17555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
17556   int jresult ;
17557   int result;
17558
17559   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
17560   jresult = (int)result;
17561   return jresult;
17562 }
17563
17564
17565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
17566   int jresult ;
17567   int result;
17568
17569   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
17570   jresult = (int)result;
17571   return jresult;
17572 }
17573
17574
17575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
17576   int jresult ;
17577   int result;
17578
17579   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
17580   jresult = (int)result;
17581   return jresult;
17582 }
17583
17584
17585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
17586   int jresult ;
17587   int result;
17588
17589   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
17590   jresult = (int)result;
17591   return jresult;
17592 }
17593
17594
17595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
17596   int jresult ;
17597   int result;
17598
17599   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
17600   jresult = (int)result;
17601   return jresult;
17602 }
17603
17604
17605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
17606   int jresult ;
17607   int result;
17608
17609   result = (int)Dali::Renderer::Property::BLEND_MODE;
17610   jresult = (int)result;
17611   return jresult;
17612 }
17613
17614
17615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
17616   int jresult ;
17617   int result;
17618
17619   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
17620   jresult = (int)result;
17621   return jresult;
17622 }
17623
17624
17625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
17626   int jresult ;
17627   int result;
17628
17629   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
17630   jresult = (int)result;
17631   return jresult;
17632 }
17633
17634
17635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
17636   int jresult ;
17637   int result;
17638
17639   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
17640   jresult = (int)result;
17641   return jresult;
17642 }
17643
17644
17645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
17646   int jresult ;
17647   int result;
17648
17649   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
17650   jresult = (int)result;
17651   return jresult;
17652 }
17653
17654
17655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
17656   int jresult ;
17657   int result;
17658
17659   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
17660   jresult = (int)result;
17661   return jresult;
17662 }
17663
17664
17665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
17666   int jresult ;
17667   int result;
17668
17669   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
17670   jresult = (int)result;
17671   return jresult;
17672 }
17673
17674
17675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
17676   int jresult ;
17677   int result;
17678
17679   result = (int)Dali::Renderer::Property::BLEND_COLOR;
17680   jresult = (int)result;
17681   return jresult;
17682 }
17683
17684
17685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
17686   int jresult ;
17687   int result;
17688
17689   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
17690   jresult = (int)result;
17691   return jresult;
17692 }
17693
17694
17695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
17696   int jresult ;
17697   int result;
17698
17699   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
17700   jresult = (int)result;
17701   return jresult;
17702 }
17703
17704
17705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
17706   int jresult ;
17707   int result;
17708
17709   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
17710   jresult = (int)result;
17711   return jresult;
17712 }
17713
17714
17715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
17716   int jresult ;
17717   int result;
17718
17719   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
17720   jresult = (int)result;
17721   return jresult;
17722 }
17723
17724
17725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
17726   int jresult ;
17727   int result;
17728
17729   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
17730   jresult = (int)result;
17731   return jresult;
17732 }
17733
17734
17735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
17736   int jresult ;
17737   int result;
17738
17739   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
17740   jresult = (int)result;
17741   return jresult;
17742 }
17743
17744
17745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
17746   int jresult ;
17747   int result;
17748
17749   result = (int)Dali::Renderer::Property::RENDER_MODE;
17750   jresult = (int)result;
17751   return jresult;
17752 }
17753
17754
17755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
17756   int jresult ;
17757   int result;
17758
17759   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
17760   jresult = (int)result;
17761   return jresult;
17762 }
17763
17764
17765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
17766   int jresult ;
17767   int result;
17768
17769   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
17770   jresult = (int)result;
17771   return jresult;
17772 }
17773
17774
17775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
17776   int jresult ;
17777   int result;
17778
17779   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
17780   jresult = (int)result;
17781   return jresult;
17782 }
17783
17784
17785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
17786   int jresult ;
17787   int result;
17788
17789   result = (int)Dali::Renderer::Property::STENCIL_MASK;
17790   jresult = (int)result;
17791   return jresult;
17792 }
17793
17794
17795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
17796   int jresult ;
17797   int result;
17798
17799   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
17800   jresult = (int)result;
17801   return jresult;
17802 }
17803
17804
17805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
17806   int jresult ;
17807   int result;
17808
17809   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
17810   jresult = (int)result;
17811   return jresult;
17812 }
17813
17814
17815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
17816   int jresult ;
17817   int result;
17818
17819   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
17820   jresult = (int)result;
17821   return jresult;
17822 }
17823
17824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CULLED_get() {
17825   return Dali::Actor::Property::CULLED;
17826 }
17827
17828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
17829   void * jresult ;
17830   Dali::Renderer::Property *result = 0 ;
17831
17832   {
17833     try {
17834       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
17835     } CALL_CATCH_EXCEPTION(0);
17836   }
17837
17838   jresult = (void *)result;
17839   return jresult;
17840 }
17841
17842
17843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
17844   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
17845
17846   arg1 = (Dali::Renderer::Property *)jarg1;
17847   {
17848     try {
17849       delete arg1;
17850     } CALL_CATCH_EXCEPTION();
17851   }
17852
17853 }
17854
17855
17856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
17857   void * jresult ;
17858   Dali::Geometry *arg1 = 0 ;
17859   Dali::Shader *arg2 = 0 ;
17860   Dali::Renderer result;
17861
17862   arg1 = (Dali::Geometry *)jarg1;
17863   if (!arg1) {
17864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
17865     return 0;
17866   }
17867   arg2 = (Dali::Shader *)jarg2;
17868   if (!arg2) {
17869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
17870     return 0;
17871   }
17872   {
17873     try {
17874       result = Dali::Renderer::New(*arg1,*arg2);
17875     } CALL_CATCH_EXCEPTION(0);
17876   }
17877
17878   jresult = new Dali::Renderer((const Dali::Renderer &)result);
17879   return jresult;
17880 }
17881
17882
17883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
17884   void * jresult ;
17885   Dali::Renderer *result = 0 ;
17886
17887   {
17888     try {
17889       result = (Dali::Renderer *)new Dali::Renderer();
17890     } CALL_CATCH_EXCEPTION(0);
17891   }
17892
17893   jresult = (void *)result;
17894   return jresult;
17895 }
17896
17897
17898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
17899   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17900
17901   arg1 = (Dali::Renderer *)jarg1;
17902   {
17903     try {
17904       delete arg1;
17905     } CALL_CATCH_EXCEPTION();
17906   }
17907
17908 }
17909
17910
17911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
17912   void * jresult ;
17913   Dali::Renderer *arg1 = 0 ;
17914   Dali::Renderer *result = 0 ;
17915
17916   arg1 = (Dali::Renderer *)jarg1;
17917   if (!arg1) {
17918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
17919     return 0;
17920   }
17921   {
17922     try {
17923       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
17924     } CALL_CATCH_EXCEPTION(0);
17925   }
17926
17927   jresult = (void *)result;
17928   return jresult;
17929 }
17930
17931
17932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
17933   void * jresult ;
17934   Dali::BaseHandle arg1 ;
17935   Dali::BaseHandle *argp1 ;
17936   Dali::Renderer result;
17937
17938   argp1 = (Dali::BaseHandle *)jarg1;
17939   if (!argp1) {
17940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17941     return 0;
17942   }
17943   arg1 = *argp1;
17944   {
17945     try {
17946       result = Dali::Renderer::DownCast(arg1);
17947     } CALL_CATCH_EXCEPTION(0);
17948   }
17949
17950   jresult = new Dali::Renderer((const Dali::Renderer &)result);
17951   return jresult;
17952 }
17953
17954
17955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
17956   void * jresult ;
17957   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17958   Dali::Renderer *arg2 = 0 ;
17959   Dali::Renderer *result = 0 ;
17960
17961   arg1 = (Dali::Renderer *)jarg1;
17962   arg2 = (Dali::Renderer *)jarg2;
17963   if (!arg2) {
17964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
17965     return 0;
17966   }
17967   {
17968     try {
17969       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
17970     } CALL_CATCH_EXCEPTION(0);
17971   }
17972
17973   jresult = (void *)result;
17974   return jresult;
17975 }
17976
17977
17978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
17979   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17980   Dali::Geometry *arg2 = 0 ;
17981
17982   arg1 = (Dali::Renderer *)jarg1;
17983   arg2 = (Dali::Geometry *)jarg2;
17984   if (!arg2) {
17985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
17986     return ;
17987   }
17988   {
17989     try {
17990       (arg1)->SetGeometry(*arg2);
17991     } CALL_CATCH_EXCEPTION();
17992   }
17993
17994 }
17995
17996
17997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
17998   void * jresult ;
17999   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
18000   Dali::Geometry result;
18001
18002   arg1 = (Dali::Renderer *)jarg1;
18003   {
18004     try {
18005       result = ((Dali::Renderer const *)arg1)->GetGeometry();
18006     } CALL_CATCH_EXCEPTION(0);
18007   }
18008
18009   jresult = new Dali::Geometry((const Dali::Geometry &)result);
18010   return jresult;
18011 }
18012
18013
18014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
18015   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
18016   int arg2 ;
18017   int arg3 ;
18018
18019   arg1 = (Dali::Renderer *)jarg1;
18020   arg2 = (int)jarg2;
18021   arg3 = (int)jarg3;
18022   {
18023     try {
18024       (arg1)->SetIndexRange(arg2,arg3);
18025     } CALL_CATCH_EXCEPTION();
18026   }
18027
18028 }
18029
18030
18031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
18032   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
18033   Dali::TextureSet *arg2 = 0 ;
18034
18035   arg1 = (Dali::Renderer *)jarg1;
18036   arg2 = (Dali::TextureSet *)jarg2;
18037   if (!arg2) {
18038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
18039     return ;
18040   }
18041   {
18042     try {
18043       (arg1)->SetTextures(*arg2);
18044     } CALL_CATCH_EXCEPTION();
18045   }
18046
18047 }
18048
18049
18050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
18051   void * jresult ;
18052   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
18053   Dali::TextureSet result;
18054
18055   arg1 = (Dali::Renderer *)jarg1;
18056   {
18057     try {
18058       result = ((Dali::Renderer const *)arg1)->GetTextures();
18059     } CALL_CATCH_EXCEPTION(0);
18060   }
18061
18062   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
18063   return jresult;
18064 }
18065
18066
18067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
18068   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
18069   Dali::Shader *arg2 = 0 ;
18070
18071   arg1 = (Dali::Renderer *)jarg1;
18072   arg2 = (Dali::Shader *)jarg2;
18073   if (!arg2) {
18074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
18075     return ;
18076   }
18077   {
18078     try {
18079       (arg1)->SetShader(*arg2);
18080     } CALL_CATCH_EXCEPTION();
18081   }
18082
18083 }
18084
18085
18086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
18087   void * jresult ;
18088   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
18089   Dali::Shader result;
18090
18091   arg1 = (Dali::Renderer *)jarg1;
18092   {
18093     try {
18094       result = ((Dali::Renderer const *)arg1)->GetShader();
18095     } CALL_CATCH_EXCEPTION(0);
18096   }
18097
18098   jresult = new Dali::Shader((const Dali::Shader &)result);
18099   return jresult;
18100 }
18101
18102
18103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
18104   void * jresult ;
18105   Dali::FrameBuffer::Attachment *result = 0 ;
18106
18107   {
18108     try {
18109       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
18110     } CALL_CATCH_EXCEPTION(0);
18111   }
18112
18113   jresult = (void *)result;
18114   return jresult;
18115 }
18116
18117
18118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
18119   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
18120
18121   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
18122   {
18123     try {
18124       delete arg1;
18125     } CALL_CATCH_EXCEPTION();
18126   }
18127
18128 }
18129
18130
18131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
18132   void * jresult ;
18133   unsigned int arg1 ;
18134   unsigned int arg2 ;
18135   unsigned int arg3 ;
18136   Dali::FrameBuffer result;
18137
18138   arg1 = (unsigned int)jarg1;
18139   arg2 = (unsigned int)jarg2;
18140   arg3 = (unsigned int)jarg3;
18141   {
18142     try {
18143       result = Dali::FrameBuffer::New(arg1,arg2,static_cast<Dali::FrameBuffer::Attachment::Mask>(arg3));
18144     } CALL_CATCH_EXCEPTION(0);
18145   }
18146
18147   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
18148   return jresult;
18149 }
18150
18151
18152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
18153   void * jresult ;
18154   Dali::FrameBuffer *result = 0 ;
18155
18156   {
18157     try {
18158       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
18159     } CALL_CATCH_EXCEPTION(0);
18160   }
18161
18162   jresult = (void *)result;
18163   return jresult;
18164 }
18165
18166
18167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
18168   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
18169
18170   arg1 = (Dali::FrameBuffer *)jarg1;
18171   {
18172     try {
18173       delete arg1;
18174     } CALL_CATCH_EXCEPTION();
18175   }
18176
18177 }
18178
18179
18180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
18181   void * jresult ;
18182   Dali::FrameBuffer *arg1 = 0 ;
18183   Dali::FrameBuffer *result = 0 ;
18184
18185   arg1 = (Dali::FrameBuffer *)jarg1;
18186   if (!arg1) {
18187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
18188     return 0;
18189   }
18190   {
18191     try {
18192       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
18193     } CALL_CATCH_EXCEPTION(0);
18194   }
18195
18196   jresult = (void *)result;
18197   return jresult;
18198 }
18199
18200
18201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
18202   void * jresult ;
18203   Dali::BaseHandle arg1 ;
18204   Dali::BaseHandle *argp1 ;
18205   Dali::FrameBuffer result;
18206
18207   argp1 = (Dali::BaseHandle *)jarg1;
18208   if (!argp1) {
18209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
18210     return 0;
18211   }
18212   arg1 = *argp1;
18213   {
18214     try {
18215       result = Dali::FrameBuffer::DownCast(arg1);
18216     } CALL_CATCH_EXCEPTION(0);
18217   }
18218
18219   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
18220   return jresult;
18221 }
18222
18223
18224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
18225   void * jresult ;
18226   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
18227   Dali::FrameBuffer *arg2 = 0 ;
18228   Dali::FrameBuffer *result = 0 ;
18229
18230   arg1 = (Dali::FrameBuffer *)jarg1;
18231   arg2 = (Dali::FrameBuffer *)jarg2;
18232   if (!arg2) {
18233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
18234     return 0;
18235   }
18236   {
18237     try {
18238       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
18239     } CALL_CATCH_EXCEPTION(0);
18240   }
18241
18242   jresult = (void *)result;
18243   return jresult;
18244 }
18245
18246
18247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
18248   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
18249   Dali::Texture *arg2 = 0 ;
18250
18251   arg1 = (Dali::FrameBuffer *)jarg1;
18252   arg2 = (Dali::Texture *)jarg2;
18253   if (!arg2) {
18254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
18255     return ;
18256   }
18257   {
18258     try {
18259       (arg1)->AttachColorTexture(*arg2);
18260     } CALL_CATCH_EXCEPTION();
18261   }
18262
18263 }
18264
18265
18266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
18267   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
18268   Dali::Texture *arg2 = 0 ;
18269   unsigned int arg3 ;
18270   unsigned int arg4 ;
18271
18272   arg1 = (Dali::FrameBuffer *)jarg1;
18273   arg2 = (Dali::Texture *)jarg2;
18274   if (!arg2) {
18275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
18276     return ;
18277   }
18278   arg3 = (unsigned int)jarg3;
18279   arg4 = (unsigned int)jarg4;
18280   {
18281     try {
18282       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
18283     } CALL_CATCH_EXCEPTION();
18284   }
18285
18286 }
18287
18288
18289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
18290   void * jresult ;
18291   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
18292   Dali::Texture result;
18293
18294   arg1 = (Dali::FrameBuffer *)jarg1;
18295   {
18296     try {
18297       result = (arg1)->GetColorTexture();
18298     } CALL_CATCH_EXCEPTION(0);
18299   }
18300
18301   jresult = new Dali::Texture((const Dali::Texture &)result);
18302   return jresult;
18303 }
18304
18305
18306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
18307   void * jresult ;
18308   Dali::RenderTaskList *result = 0 ;
18309
18310   {
18311     try {
18312       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
18313     } CALL_CATCH_EXCEPTION(0);
18314   }
18315
18316   jresult = (void *)result;
18317   return jresult;
18318 }
18319
18320
18321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
18322   void * jresult ;
18323   Dali::BaseHandle arg1 ;
18324   Dali::BaseHandle *argp1 ;
18325   Dali::RenderTaskList result;
18326
18327   argp1 = (Dali::BaseHandle *)jarg1;
18328   if (!argp1) {
18329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
18330     return 0;
18331   }
18332   arg1 = *argp1;
18333   {
18334     try {
18335       result = Dali::RenderTaskList::DownCast(arg1);
18336     } CALL_CATCH_EXCEPTION(0);
18337   }
18338
18339   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
18340   return jresult;
18341 }
18342
18343
18344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
18345   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
18346
18347   arg1 = (Dali::RenderTaskList *)jarg1;
18348   {
18349     try {
18350       delete arg1;
18351     } CALL_CATCH_EXCEPTION();
18352   }
18353
18354 }
18355
18356
18357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
18358   void * jresult ;
18359   Dali::RenderTaskList *arg1 = 0 ;
18360   Dali::RenderTaskList *result = 0 ;
18361
18362   arg1 = (Dali::RenderTaskList *)jarg1;
18363   if (!arg1) {
18364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
18365     return 0;
18366   }
18367   {
18368     try {
18369       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
18370     } CALL_CATCH_EXCEPTION(0);
18371   }
18372
18373   jresult = (void *)result;
18374   return jresult;
18375 }
18376
18377
18378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
18379   void * jresult ;
18380   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
18381   Dali::RenderTaskList *arg2 = 0 ;
18382   Dali::RenderTaskList *result = 0 ;
18383
18384   arg1 = (Dali::RenderTaskList *)jarg1;
18385   arg2 = (Dali::RenderTaskList *)jarg2;
18386   if (!arg2) {
18387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
18388     return 0;
18389   }
18390   {
18391     try {
18392       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
18393     } CALL_CATCH_EXCEPTION(0);
18394   }
18395
18396   jresult = (void *)result;
18397   return jresult;
18398 }
18399
18400
18401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
18402   void * jresult ;
18403   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
18404   Dali::RenderTask result;
18405
18406   arg1 = (Dali::RenderTaskList *)jarg1;
18407   {
18408     try {
18409       result = (arg1)->CreateTask();
18410     } CALL_CATCH_EXCEPTION(0);
18411   }
18412
18413   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
18414   return jresult;
18415 }
18416
18417
18418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
18419   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
18420   Dali::RenderTask arg2 ;
18421   Dali::RenderTask *argp2 ;
18422
18423   arg1 = (Dali::RenderTaskList *)jarg1;
18424   argp2 = (Dali::RenderTask *)jarg2;
18425   if (!argp2) {
18426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
18427     return ;
18428   }
18429   arg2 = *argp2;
18430   {
18431     try {
18432       (arg1)->RemoveTask(arg2);
18433     } CALL_CATCH_EXCEPTION();
18434   }
18435
18436 }
18437
18438
18439 //// ===============================================end part 1 =================
18440
18441 //// ========================= part 2 ===============================
18442
18443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
18444   unsigned int jresult ;
18445   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
18446   unsigned int result;
18447
18448   arg1 = (Dali::RenderTaskList *)jarg1;
18449   {
18450     try {
18451       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
18452     } CALL_CATCH_EXCEPTION(0);
18453   }
18454
18455   jresult = result;
18456   return jresult;
18457 }
18458
18459
18460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
18461   void * jresult ;
18462   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
18463   unsigned int arg2 ;
18464   Dali::RenderTask result;
18465
18466   arg1 = (Dali::RenderTaskList *)jarg1;
18467   arg2 = (unsigned int)jarg2;
18468   {
18469     try {
18470       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
18471     } CALL_CATCH_EXCEPTION(0);
18472   }
18473
18474   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
18475   return jresult;
18476 }
18477
18478
18479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
18480   int jresult ;
18481   int result;
18482
18483   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
18484   jresult = (int)result;
18485   return jresult;
18486 }
18487
18488
18489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
18490   int jresult ;
18491   int result;
18492
18493   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
18494   jresult = (int)result;
18495   return jresult;
18496 }
18497
18498
18499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
18500   int jresult ;
18501   int result;
18502
18503   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
18504   jresult = (int)result;
18505   return jresult;
18506 }
18507
18508
18509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
18510   int jresult ;
18511   int result;
18512
18513   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
18514   jresult = (int)result;
18515   return jresult;
18516 }
18517
18518
18519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
18520   void * jresult ;
18521   Dali::RenderTask::Property *result = 0 ;
18522
18523   {
18524     try {
18525       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
18526     } CALL_CATCH_EXCEPTION(0);
18527   }
18528
18529   jresult = (void *)result;
18530   return jresult;
18531 }
18532
18533
18534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
18535   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
18536
18537   arg1 = (Dali::RenderTask::Property *)jarg1;
18538   {
18539     try {
18540       delete arg1;
18541     } CALL_CATCH_EXCEPTION();
18542   }
18543
18544 }
18545
18546
18547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
18548   void * jresult ;
18549   bool (*result)(Dali::Vector2 &) = 0 ;
18550
18551   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
18552   jresult = (void *)result;
18553   return jresult;
18554 }
18555
18556
18557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
18558   void * jresult ;
18559   bool (*result)(Dali::Vector2 &) = 0 ;
18560
18561   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
18562   jresult = (void *)result;
18563   return jresult;
18564 }
18565
18566
18567 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
18568   bool jresult ;
18569   bool result;
18570
18571   result = (bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
18572   jresult = result;
18573   return jresult;
18574 }
18575
18576
18577 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
18578   bool jresult ;
18579   bool result;
18580
18581   result = (bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
18582   jresult = result;
18583   return jresult;
18584 }
18585
18586
18587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
18588   void * jresult ;
18589   Dali::Vector4 *result = 0 ;
18590
18591   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
18592   jresult = (void *)result;
18593   return jresult;
18594 }
18595
18596
18597 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
18598   bool jresult ;
18599   bool result;
18600
18601   result = (bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
18602   jresult = result;
18603   return jresult;
18604 }
18605
18606
18607 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
18608   bool jresult ;
18609   bool result;
18610
18611   result = (bool)Dali::RenderTask::DEFAULT_CULL_MODE;
18612   jresult = result;
18613   return jresult;
18614 }
18615
18616
18617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
18618   unsigned int jresult ;
18619   unsigned int result;
18620
18621   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
18622   jresult = result;
18623   return jresult;
18624 }
18625
18626
18627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
18628   void * jresult ;
18629   Dali::RenderTask *result = 0 ;
18630
18631   {
18632     try {
18633       result = (Dali::RenderTask *)new Dali::RenderTask();
18634     } CALL_CATCH_EXCEPTION(0);
18635   }
18636
18637   jresult = (void *)result;
18638   return jresult;
18639 }
18640
18641
18642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
18643   void * jresult ;
18644   Dali::BaseHandle arg1 ;
18645   Dali::BaseHandle *argp1 ;
18646   Dali::RenderTask result;
18647
18648   argp1 = (Dali::BaseHandle *)jarg1;
18649   if (!argp1) {
18650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
18651     return 0;
18652   }
18653   arg1 = *argp1;
18654   {
18655     try {
18656       result = Dali::RenderTask::DownCast(arg1);
18657     } CALL_CATCH_EXCEPTION(0);
18658   }
18659
18660   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
18661   return jresult;
18662 }
18663
18664
18665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
18666   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18667
18668   arg1 = (Dali::RenderTask *)jarg1;
18669   {
18670     try {
18671       delete arg1;
18672     } CALL_CATCH_EXCEPTION();
18673   }
18674
18675 }
18676
18677
18678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
18679   void * jresult ;
18680   Dali::RenderTask *arg1 = 0 ;
18681   Dali::RenderTask *result = 0 ;
18682
18683   arg1 = (Dali::RenderTask *)jarg1;
18684   if (!arg1) {
18685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
18686     return 0;
18687   }
18688   {
18689     try {
18690       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
18691     } CALL_CATCH_EXCEPTION(0);
18692   }
18693
18694   jresult = (void *)result;
18695   return jresult;
18696 }
18697
18698
18699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
18700   void * jresult ;
18701   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18702   Dali::RenderTask *arg2 = 0 ;
18703   Dali::RenderTask *result = 0 ;
18704
18705   arg1 = (Dali::RenderTask *)jarg1;
18706   arg2 = (Dali::RenderTask *)jarg2;
18707   if (!arg2) {
18708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
18709     return 0;
18710   }
18711   {
18712     try {
18713       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
18714     } CALL_CATCH_EXCEPTION(0);
18715   }
18716
18717   jresult = (void *)result;
18718   return jresult;
18719 }
18720
18721
18722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
18723   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18724   Dali::Actor arg2 ;
18725   Dali::Actor *argp2 ;
18726
18727   arg1 = (Dali::RenderTask *)jarg1;
18728   argp2 = (Dali::Actor *)jarg2;
18729   if (!argp2) {
18730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
18731     return ;
18732   }
18733   arg2 = *argp2;
18734   {
18735     try {
18736       (arg1)->SetSourceActor(arg2);
18737     } CALL_CATCH_EXCEPTION();
18738   }
18739
18740 }
18741
18742
18743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
18744   void * jresult ;
18745   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18746   Dali::Actor result;
18747
18748   arg1 = (Dali::RenderTask *)jarg1;
18749   {
18750     try {
18751       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
18752     } CALL_CATCH_EXCEPTION(0);
18753   }
18754
18755   jresult = new Dali::Actor((const Dali::Actor &)result);
18756   return jresult;
18757 }
18758
18759
18760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, bool jarg2) {
18761   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18762   bool arg2 ;
18763
18764   arg1 = (Dali::RenderTask *)jarg1;
18765   arg2 = jarg2 ? true : false;
18766   {
18767     try {
18768       (arg1)->SetExclusive(arg2);
18769     } CALL_CATCH_EXCEPTION();
18770   }
18771
18772 }
18773
18774
18775 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
18776   bool jresult ;
18777   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18778   bool result;
18779
18780   arg1 = (Dali::RenderTask *)jarg1;
18781   {
18782     try {
18783       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
18784     } CALL_CATCH_EXCEPTION(0);
18785   }
18786
18787   jresult = result;
18788   return jresult;
18789 }
18790
18791
18792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, bool jarg2) {
18793   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18794   bool arg2 ;
18795
18796   arg1 = (Dali::RenderTask *)jarg1;
18797   arg2 = jarg2 ? true : false;
18798   {
18799     try {
18800       (arg1)->SetInputEnabled(arg2);
18801     } CALL_CATCH_EXCEPTION();
18802   }
18803
18804 }
18805
18806
18807 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
18808   bool jresult ;
18809   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18810   bool result;
18811
18812   arg1 = (Dali::RenderTask *)jarg1;
18813   {
18814     try {
18815       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
18816     } CALL_CATCH_EXCEPTION(0);
18817   }
18818
18819   jresult = result;
18820   return jresult;
18821 }
18822
18823
18824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
18825   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18826   Dali::CameraActor arg2 ;
18827   Dali::CameraActor *argp2 ;
18828
18829   arg1 = (Dali::RenderTask *)jarg1;
18830   argp2 = (Dali::CameraActor *)jarg2;
18831   if (!argp2) {
18832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
18833     return ;
18834   }
18835   arg2 = *argp2;
18836   {
18837     try {
18838       (arg1)->SetCameraActor(arg2);
18839     } CALL_CATCH_EXCEPTION();
18840   }
18841
18842 }
18843
18844
18845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
18846   void * jresult ;
18847   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18848   Dali::CameraActor result;
18849
18850   arg1 = (Dali::RenderTask *)jarg1;
18851   {
18852     try {
18853       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
18854     } CALL_CATCH_EXCEPTION(0);
18855   }
18856
18857   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
18858   return jresult;
18859 }
18860
18861
18862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
18863   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18864   Dali::FrameBuffer arg2 ;
18865   Dali::FrameBuffer *argp2 ;
18866
18867   arg1 = (Dali::RenderTask *)jarg1;
18868   argp2 = (Dali::FrameBuffer *)jarg2;
18869   if (!argp2) {
18870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
18871     return ;
18872   }
18873   arg2 = *argp2;
18874   {
18875     try {
18876       (arg1)->SetFrameBuffer(arg2);
18877     } CALL_CATCH_EXCEPTION();
18878   }
18879
18880 }
18881
18882
18883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
18884   void * jresult ;
18885   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18886   Dali::FrameBuffer result;
18887
18888   arg1 = (Dali::RenderTask *)jarg1;
18889   {
18890     try {
18891       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
18892     } CALL_CATCH_EXCEPTION(0);
18893   }
18894
18895   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
18896   return jresult;
18897 }
18898
18899
18900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
18901   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18902   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
18903
18904   arg1 = (Dali::RenderTask *)jarg1;
18905   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
18906   {
18907     try {
18908       (arg1)->SetScreenToFrameBufferFunction(arg2);
18909     } CALL_CATCH_EXCEPTION();
18910   }
18911
18912 }
18913
18914
18915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
18916   void * jresult ;
18917   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18918   Dali::RenderTask::ScreenToFrameBufferFunction result;
18919
18920   arg1 = (Dali::RenderTask *)jarg1;
18921   {
18922     try {
18923       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
18924     } CALL_CATCH_EXCEPTION(0);
18925   }
18926
18927   jresult = (void *)result;
18928   return jresult;
18929 }
18930
18931
18932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
18933   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18934   Dali::Actor arg2 ;
18935   Dali::Actor *argp2 ;
18936
18937   arg1 = (Dali::RenderTask *)jarg1;
18938   argp2 = (Dali::Actor *)jarg2;
18939   if (!argp2) {
18940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
18941     return ;
18942   }
18943   arg2 = *argp2;
18944   {
18945     try {
18946       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
18947     } CALL_CATCH_EXCEPTION();
18948   }
18949
18950 }
18951
18952
18953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
18954   void * jresult ;
18955   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18956   Dali::Actor result;
18957
18958   arg1 = (Dali::RenderTask *)jarg1;
18959   {
18960     try {
18961       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
18962     } CALL_CATCH_EXCEPTION(0);
18963   }
18964
18965   jresult = new Dali::Actor((const Dali::Actor &)result);
18966   return jresult;
18967 }
18968
18969
18970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
18971   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18972   Dali::Vector2 arg2 ;
18973   Dali::Vector2 *argp2 ;
18974
18975   arg1 = (Dali::RenderTask *)jarg1;
18976   argp2 = (Dali::Vector2 *)jarg2;
18977   if (!argp2) {
18978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
18979     return ;
18980   }
18981   arg2 = *argp2;
18982   {
18983     try {
18984       (arg1)->SetViewportPosition(arg2);
18985     } CALL_CATCH_EXCEPTION();
18986   }
18987
18988 }
18989
18990
18991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
18992   void * jresult ;
18993   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18994   Dali::Vector2 result;
18995
18996   arg1 = (Dali::RenderTask *)jarg1;
18997   {
18998     try {
18999       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
19000     } CALL_CATCH_EXCEPTION(0);
19001   }
19002
19003   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
19004   return jresult;
19005 }
19006
19007
19008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
19009   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19010   Dali::Vector2 arg2 ;
19011   Dali::Vector2 *argp2 ;
19012
19013   arg1 = (Dali::RenderTask *)jarg1;
19014   argp2 = (Dali::Vector2 *)jarg2;
19015   if (!argp2) {
19016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
19017     return ;
19018   }
19019   arg2 = *argp2;
19020   {
19021     try {
19022       (arg1)->SetViewportSize(arg2);
19023     } CALL_CATCH_EXCEPTION();
19024   }
19025
19026 }
19027
19028
19029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
19030   void * jresult ;
19031   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19032   Dali::Vector2 result;
19033
19034   arg1 = (Dali::RenderTask *)jarg1;
19035   {
19036     try {
19037       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
19038     } CALL_CATCH_EXCEPTION(0);
19039   }
19040
19041   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
19042   return jresult;
19043 }
19044
19045
19046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
19047   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19048   Dali::Viewport arg2 ;
19049   Dali::Viewport *argp2 ;
19050
19051   arg1 = (Dali::RenderTask *)jarg1;
19052   argp2 = (Dali::Viewport *)jarg2;
19053   if (!argp2) {
19054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
19055     return ;
19056   }
19057   arg2 = *argp2;
19058   {
19059     try {
19060       (arg1)->SetViewport(arg2);
19061     } CALL_CATCH_EXCEPTION();
19062   }
19063
19064 }
19065
19066
19067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
19068   void * jresult ;
19069   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19070   Dali::Viewport result;
19071
19072   arg1 = (Dali::RenderTask *)jarg1;
19073   {
19074     try {
19075       result = ((Dali::RenderTask const *)arg1)->GetViewport();
19076     } CALL_CATCH_EXCEPTION(0);
19077   }
19078
19079   jresult = new Dali::Viewport((const Dali::Viewport &)result);
19080   return jresult;
19081 }
19082
19083
19084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
19085   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19086   Dali::Vector4 *arg2 = 0 ;
19087
19088   arg1 = (Dali::RenderTask *)jarg1;
19089   arg2 = (Dali::Vector4 *)jarg2;
19090   if (!arg2) {
19091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
19092     return ;
19093   }
19094   {
19095     try {
19096       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
19097     } CALL_CATCH_EXCEPTION();
19098   }
19099
19100 }
19101
19102
19103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
19104   void * jresult ;
19105   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19106   Dali::Vector4 result;
19107
19108   arg1 = (Dali::RenderTask *)jarg1;
19109   {
19110     try {
19111       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
19112     } CALL_CATCH_EXCEPTION(0);
19113   }
19114
19115   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
19116   return jresult;
19117 }
19118
19119
19120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, bool jarg2) {
19121   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19122   bool arg2 ;
19123
19124   arg1 = (Dali::RenderTask *)jarg1;
19125   arg2 = jarg2 ? true : false;
19126   {
19127     try {
19128       (arg1)->SetClearEnabled(arg2);
19129     } CALL_CATCH_EXCEPTION();
19130   }
19131
19132 }
19133
19134
19135 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
19136   bool jresult ;
19137   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19138   bool result;
19139
19140   arg1 = (Dali::RenderTask *)jarg1;
19141   {
19142     try {
19143       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
19144     } CALL_CATCH_EXCEPTION(0);
19145   }
19146
19147   jresult = result;
19148   return jresult;
19149 }
19150
19151
19152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, bool jarg2) {
19153   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19154   bool arg2 ;
19155
19156   arg1 = (Dali::RenderTask *)jarg1;
19157   arg2 = jarg2 ? true : false;
19158   {
19159     try {
19160       (arg1)->SetCullMode(arg2);
19161     } CALL_CATCH_EXCEPTION();
19162   }
19163
19164 }
19165
19166
19167 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
19168   bool jresult ;
19169   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19170   bool result;
19171
19172   arg1 = (Dali::RenderTask *)jarg1;
19173   {
19174     try {
19175       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
19176     } CALL_CATCH_EXCEPTION(0);
19177   }
19178
19179   jresult = result;
19180   return jresult;
19181 }
19182
19183
19184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
19185   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19186   unsigned int arg2 ;
19187
19188   arg1 = (Dali::RenderTask *)jarg1;
19189   arg2 = (unsigned int)jarg2;
19190   {
19191     try {
19192       (arg1)->SetRefreshRate(arg2);
19193     } CALL_CATCH_EXCEPTION();
19194   }
19195
19196 }
19197
19198
19199 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
19200   unsigned int jresult ;
19201   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19202   unsigned int result;
19203
19204   arg1 = (Dali::RenderTask *)jarg1;
19205   {
19206     try {
19207       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
19208     } CALL_CATCH_EXCEPTION(0);
19209   }
19210
19211   jresult = result;
19212   return jresult;
19213 }
19214
19215
19216 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
19217   bool jresult ;
19218   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19219   Dali::Vector3 *arg2 = 0 ;
19220   float *arg3 = 0 ;
19221   float *arg4 = 0 ;
19222   bool result;
19223
19224   arg1 = (Dali::RenderTask *)jarg1;
19225   arg2 = (Dali::Vector3 *)jarg2;
19226   if (!arg2) {
19227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
19228     return 0;
19229   }
19230   arg3 = (float *)jarg3;
19231   arg4 = (float *)jarg4;
19232   {
19233     try {
19234       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
19235     } CALL_CATCH_EXCEPTION(0);
19236   }
19237
19238   jresult = result;
19239   return jresult;
19240 }
19241
19242
19243 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
19244   bool jresult ;
19245   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19246   Dali::Actor arg2 ;
19247   float arg3 ;
19248   float arg4 ;
19249   float *arg5 = 0 ;
19250   float *arg6 = 0 ;
19251   Dali::Actor *argp2 ;
19252   bool result;
19253
19254   arg1 = (Dali::RenderTask *)jarg1;
19255   argp2 = (Dali::Actor *)jarg2;
19256   if (!argp2) {
19257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
19258     return 0;
19259   }
19260   arg2 = *argp2;
19261   arg3 = (float)jarg3;
19262   arg4 = (float)jarg4;
19263   arg5 = (float *)jarg5;
19264   arg6 = (float *)jarg6;
19265   {
19266     try {
19267       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
19268     } CALL_CATCH_EXCEPTION(0);
19269   }
19270
19271   jresult = result;
19272   return jresult;
19273 }
19274
19275
19276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
19277   void * jresult ;
19278   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19279   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
19280
19281   arg1 = (Dali::RenderTask *)jarg1;
19282   {
19283     try {
19284       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
19285     } CALL_CATCH_EXCEPTION(0);
19286   }
19287
19288   jresult = (void *)result;
19289   return jresult;
19290 }
19291
19292
19293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
19294   void * jresult ;
19295   int arg1 ;
19296   Dali::PointState::Type arg2 ;
19297   float arg3 ;
19298   float arg4 ;
19299   Dali::TouchPoint *result = 0 ;
19300
19301   arg1 = (int)jarg1;
19302   arg2 = (Dali::PointState::Type)jarg2;
19303   arg3 = (float)jarg3;
19304   arg4 = (float)jarg4;
19305   {
19306     try {
19307       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
19308     } CALL_CATCH_EXCEPTION(0);
19309   }
19310
19311   jresult = (void *)result;
19312   return jresult;
19313 }
19314
19315
19316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
19317   void * jresult ;
19318   int arg1 ;
19319   Dali::PointState::Type arg2 ;
19320   float arg3 ;
19321   float arg4 ;
19322   float arg5 ;
19323   float arg6 ;
19324   Dali::TouchPoint *result = 0 ;
19325
19326   arg1 = (int)jarg1;
19327   arg2 = (Dali::PointState::Type)jarg2;
19328   arg3 = (float)jarg3;
19329   arg4 = (float)jarg4;
19330   arg5 = (float)jarg5;
19331   arg6 = (float)jarg6;
19332   {
19333     try {
19334       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
19335     } CALL_CATCH_EXCEPTION(0);
19336   }
19337
19338   jresult = (void *)result;
19339   return jresult;
19340 }
19341
19342
19343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
19344   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19345
19346   arg1 = (Dali::TouchPoint *)jarg1;
19347   {
19348     try {
19349       delete arg1;
19350     } CALL_CATCH_EXCEPTION();
19351   }
19352
19353 }
19354
19355
19356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
19357   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19358   int arg2 ;
19359
19360   arg1 = (Dali::TouchPoint *)jarg1;
19361   arg2 = (int)jarg2;
19362   if (arg1) (arg1)->deviceId = arg2;
19363 }
19364
19365
19366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
19367   int jresult ;
19368   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19369   int result;
19370
19371   arg1 = (Dali::TouchPoint *)jarg1;
19372   result = (int) ((arg1)->deviceId);
19373   jresult = result;
19374   return jresult;
19375 }
19376
19377
19378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
19379   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19380   Dali::PointState::Type arg2 ;
19381
19382   arg1 = (Dali::TouchPoint *)jarg1;
19383   arg2 = (Dali::PointState::Type)jarg2;
19384   if (arg1) (arg1)->state = arg2;
19385 }
19386
19387
19388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
19389   int jresult ;
19390   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19391   Dali::PointState::Type result;
19392
19393   arg1 = (Dali::TouchPoint *)jarg1;
19394   result = (Dali::PointState::Type) ((arg1)->state);
19395   jresult = (int)result;
19396   return jresult;
19397 }
19398
19399
19400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
19401   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19402   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
19403
19404   arg1 = (Dali::TouchPoint *)jarg1;
19405   arg2 = (Dali::Actor *)jarg2;
19406   if (arg1) (arg1)->hitActor = *arg2;
19407 }
19408
19409
19410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
19411   void * jresult ;
19412   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19413   Dali::Actor *result = 0 ;
19414
19415   arg1 = (Dali::TouchPoint *)jarg1;
19416   result = (Dali::Actor *)& ((arg1)->hitActor);
19417   jresult = (void *)result;
19418   return jresult;
19419 }
19420
19421
19422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
19423   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19424   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
19425
19426   arg1 = (Dali::TouchPoint *)jarg1;
19427   arg2 = (Dali::Vector2 *)jarg2;
19428   if (arg1) (arg1)->local = *arg2;
19429 }
19430
19431
19432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
19433   void * jresult ;
19434   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19435   Dali::Vector2 *result = 0 ;
19436
19437   arg1 = (Dali::TouchPoint *)jarg1;
19438   result = (Dali::Vector2 *)& ((arg1)->local);
19439   jresult = (void *)result;
19440   return jresult;
19441 }
19442
19443
19444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
19445   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19446   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
19447
19448   arg1 = (Dali::TouchPoint *)jarg1;
19449   arg2 = (Dali::Vector2 *)jarg2;
19450   if (arg1) (arg1)->screen = *arg2;
19451 }
19452
19453
19454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
19455   void * jresult ;
19456   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19457   Dali::Vector2 *result = 0 ;
19458
19459   arg1 = (Dali::TouchPoint *)jarg1;
19460   result = (Dali::Vector2 *)& ((arg1)->screen);
19461   jresult = (void *)result;
19462   return jresult;
19463 }
19464
19465
19466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
19467   void * jresult ;
19468   Dali::TouchEvent *result = 0 ;
19469
19470   {
19471     try {
19472       result = (Dali::TouchEvent *)new Dali::TouchEvent();
19473     } CALL_CATCH_EXCEPTION(0);
19474   }
19475
19476   jresult = (void *)result;
19477   return jresult;
19478 }
19479
19480
19481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
19482   void * jresult ;
19483   Dali::TouchEvent *arg1 = 0 ;
19484   Dali::TouchEvent *result = 0 ;
19485
19486   arg1 = (Dali::TouchEvent *)jarg1;
19487   if (!arg1) {
19488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
19489     return 0;
19490   }
19491   {
19492     try {
19493       result = (Dali::TouchEvent *)new Dali::TouchEvent((Dali::TouchEvent const &)*arg1);
19494     } CALL_CATCH_EXCEPTION(0);
19495   }
19496
19497   jresult = (void *)result;
19498   return jresult;
19499 }
19500
19501
19502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
19503   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19504
19505   arg1 = (Dali::TouchEvent *)jarg1;
19506   {
19507     try {
19508       delete arg1;
19509     } CALL_CATCH_EXCEPTION();
19510   }
19511
19512 }
19513
19514
19515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
19516   void * jresult ;
19517   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19518   Dali::TouchEvent *arg2 = 0 ;
19519   Dali::TouchEvent *result = 0 ;
19520
19521   arg1 = (Dali::TouchEvent *)jarg1;
19522   arg2 = (Dali::TouchEvent *)jarg2;
19523   if (!arg2) {
19524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
19525     return 0;
19526   }
19527   {
19528     try {
19529       result = (Dali::TouchEvent *) &(arg1)->operator =((Dali::TouchEvent const &)*arg2);
19530     } CALL_CATCH_EXCEPTION(0);
19531   }
19532
19533   jresult = (void *)result;
19534   return jresult;
19535 }
19536
19537
19538 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
19539   unsigned long jresult ;
19540   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19541   unsigned long result;
19542
19543   arg1 = (Dali::TouchEvent *)jarg1;
19544   {
19545     try {
19546       result = (unsigned long)((Dali::TouchEvent const *)arg1)->GetTime();
19547     } CALL_CATCH_EXCEPTION(0);
19548   }
19549
19550   jresult = (unsigned long)result;
19551   return jresult;
19552 }
19553
19554
19555 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
19556   unsigned long jresult ;
19557   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19558   std::size_t result;
19559
19560   arg1 = (Dali::TouchEvent *)jarg1;
19561   {
19562     try {
19563       result = ((Dali::TouchEvent const *)arg1)->GetPointCount();
19564     } CALL_CATCH_EXCEPTION(0);
19565   }
19566
19567   jresult = (unsigned long)result;
19568   return jresult;
19569 }
19570
19571
19572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
19573   int jresult ;
19574   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19575   std::size_t arg2 ;
19576   int32_t result;
19577
19578   arg1 = (Dali::TouchEvent *)jarg1;
19579   arg2 = (std::size_t)jarg2;
19580   {
19581     try {
19582       result = ((Dali::TouchEvent const *)arg1)->GetDeviceId(arg2);
19583     } CALL_CATCH_EXCEPTION(0);
19584   }
19585
19586   jresult = result;
19587   return jresult;
19588 }
19589
19590
19591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
19592   int jresult ;
19593   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19594   std::size_t arg2 ;
19595   Dali::PointState::Type result;
19596
19597   arg1 = (Dali::TouchEvent *)jarg1;
19598   arg2 = (std::size_t)jarg2;
19599   {
19600     try {
19601       result = (Dali::PointState::Type)((Dali::TouchEvent const *)arg1)->GetState(arg2);
19602     } CALL_CATCH_EXCEPTION(0);
19603   }
19604
19605   jresult = (int)result;
19606   return jresult;
19607 }
19608
19609
19610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
19611   void * jresult ;
19612   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19613   std::size_t arg2 ;
19614   Dali::Actor result;
19615
19616   arg1 = (Dali::TouchEvent *)jarg1;
19617   arg2 = (std::size_t)jarg2;
19618   {
19619     try {
19620       result = ((Dali::TouchEvent const *)arg1)->GetHitActor(arg2);
19621     } CALL_CATCH_EXCEPTION(0);
19622   }
19623
19624   jresult = new Dali::Actor((const Dali::Actor &)result);
19625   return jresult;
19626 }
19627
19628
19629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
19630   void * jresult ;
19631   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19632   std::size_t arg2 ;
19633   Dali::Vector2 *result = 0 ;
19634
19635   arg1 = (Dali::TouchEvent *)jarg1;
19636   arg2 = (std::size_t)jarg2;
19637   {
19638     try {
19639       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetLocalPosition(arg2);
19640     } CALL_CATCH_EXCEPTION(0);
19641   }
19642
19643   jresult = (void *)result;
19644   return jresult;
19645 }
19646
19647
19648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
19649   void * jresult ;
19650   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19651   std::size_t arg2 ;
19652   Dali::Vector2 *result = 0 ;
19653
19654   arg1 = (Dali::TouchEvent *)jarg1;
19655   arg2 = (std::size_t)jarg2;
19656   {
19657     try {
19658       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetScreenPosition(arg2);
19659     } CALL_CATCH_EXCEPTION(0);
19660   }
19661
19662   jresult = (void *)result;
19663   return jresult;
19664 }
19665
19666
19667 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
19668   float jresult ;
19669   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19670   std::size_t arg2 ;
19671   float result;
19672
19673   arg1 = (Dali::TouchEvent *)jarg1;
19674   arg2 = (std::size_t)jarg2;
19675   {
19676     try {
19677       result = (float)((Dali::TouchEvent const *)arg1)->GetRadius(arg2);
19678     } CALL_CATCH_EXCEPTION(0);
19679   }
19680
19681   jresult = result;
19682   return jresult;
19683 }
19684
19685
19686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
19687   void * jresult ;
19688   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19689   std::size_t arg2 ;
19690   Dali::Vector2 *result = 0 ;
19691
19692   arg1 = (Dali::TouchEvent *)jarg1;
19693   arg2 = (std::size_t)jarg2;
19694   {
19695     try {
19696       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetEllipseRadius(arg2);
19697     } CALL_CATCH_EXCEPTION(0);
19698   }
19699
19700   jresult = (void *)result;
19701   return jresult;
19702 }
19703
19704
19705 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
19706   float jresult ;
19707   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19708   std::size_t arg2 ;
19709   float result;
19710
19711   arg1 = (Dali::TouchEvent *)jarg1;
19712   arg2 = (std::size_t)jarg2;
19713   {
19714     try {
19715       result = (float)((Dali::TouchEvent const *)arg1)->GetPressure(arg2);
19716     } CALL_CATCH_EXCEPTION(0);
19717   }
19718
19719   jresult = result;
19720   return jresult;
19721 }
19722
19723
19724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
19725   void * jresult ;
19726   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19727   std::size_t arg2 ;
19728   Dali::Degree result;
19729
19730   arg1 = (Dali::TouchEvent *)jarg1;
19731   arg2 = (std::size_t)jarg2;
19732   {
19733     try {
19734       result = ((Dali::TouchEvent const *)arg1)->GetAngle(arg2);
19735     } CALL_CATCH_EXCEPTION(0);
19736   }
19737
19738   jresult = new Dali::Degree((const Dali::Degree &)result);
19739   return jresult;
19740 }
19741
19742
19743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
19744   int jresult ;
19745   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19746   std::size_t arg2 ;
19747   Dali::MouseButton::Type result;
19748
19749   arg1 = (Dali::TouchEvent *)jarg1;
19750   arg2 = (std::size_t)jarg2;
19751   {
19752     try {
19753       result = ((Dali::TouchEvent const *)arg1)->GetMouseButton(arg2);
19754     } CALL_CATCH_EXCEPTION(0);
19755   }
19756
19757   jresult = static_cast< int >(result);
19758   return jresult;
19759 }
19760
19761
19762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
19763   void * jresult ;
19764   Dali::GestureDetector *result = 0 ;
19765
19766   {
19767     try {
19768       result = (Dali::GestureDetector *)new Dali::GestureDetector();
19769     } CALL_CATCH_EXCEPTION(0);
19770   }
19771
19772   jresult = (void *)result;
19773   return jresult;
19774 }
19775
19776
19777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
19778   void * jresult ;
19779   Dali::BaseHandle arg1 ;
19780   Dali::BaseHandle *argp1 ;
19781   Dali::GestureDetector result;
19782
19783   argp1 = (Dali::BaseHandle *)jarg1;
19784   if (!argp1) {
19785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19786     return 0;
19787   }
19788   arg1 = *argp1;
19789   {
19790     try {
19791       result = Dali::GestureDetector::DownCast(arg1);
19792     } CALL_CATCH_EXCEPTION(0);
19793   }
19794
19795   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
19796   return jresult;
19797 }
19798
19799
19800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
19801   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
19802
19803   arg1 = (Dali::GestureDetector *)jarg1;
19804   {
19805     try {
19806       delete arg1;
19807     } CALL_CATCH_EXCEPTION();
19808   }
19809
19810 }
19811
19812
19813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
19814   void * jresult ;
19815   Dali::GestureDetector *arg1 = 0 ;
19816   Dali::GestureDetector *result = 0 ;
19817
19818   arg1 = (Dali::GestureDetector *)jarg1;
19819   if (!arg1) {
19820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
19821     return 0;
19822   }
19823   {
19824     try {
19825       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
19826     } CALL_CATCH_EXCEPTION(0);
19827   }
19828
19829   jresult = (void *)result;
19830   return jresult;
19831 }
19832
19833
19834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
19835   void * jresult ;
19836   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
19837   Dali::GestureDetector *arg2 = 0 ;
19838   Dali::GestureDetector *result = 0 ;
19839
19840   arg1 = (Dali::GestureDetector *)jarg1;
19841   arg2 = (Dali::GestureDetector *)jarg2;
19842   if (!arg2) {
19843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
19844     return 0;
19845   }
19846   {
19847     try {
19848       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
19849     } CALL_CATCH_EXCEPTION(0);
19850   }
19851
19852   jresult = (void *)result;
19853   return jresult;
19854 }
19855
19856
19857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
19858   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
19859   Dali::Actor arg2 ;
19860   Dali::Actor *argp2 ;
19861
19862   arg1 = (Dali::GestureDetector *)jarg1;
19863   argp2 = (Dali::Actor *)jarg2;
19864   if (!argp2) {
19865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
19866     return ;
19867   }
19868   arg2 = *argp2;
19869   {
19870     try {
19871       (arg1)->Attach(arg2);
19872     } CALL_CATCH_EXCEPTION();
19873   }
19874
19875 }
19876
19877
19878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
19879   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
19880   Dali::Actor arg2 ;
19881   Dali::Actor *argp2 ;
19882
19883   arg1 = (Dali::GestureDetector *)jarg1;
19884   argp2 = (Dali::Actor *)jarg2;
19885   if (!argp2) {
19886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
19887     return ;
19888   }
19889   arg2 = *argp2;
19890   {
19891     try {
19892       (arg1)->Detach(arg2);
19893     } CALL_CATCH_EXCEPTION();
19894   }
19895
19896 }
19897
19898
19899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
19900   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
19901
19902   arg1 = (Dali::GestureDetector *)jarg1;
19903   {
19904     try {
19905       (arg1)->DetachAll();
19906     } CALL_CATCH_EXCEPTION();
19907   }
19908
19909 }
19910
19911
19912 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
19913   unsigned long jresult ;
19914   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
19915   size_t result;
19916
19917   arg1 = (Dali::GestureDetector *)jarg1;
19918   {
19919     try {
19920       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
19921     } CALL_CATCH_EXCEPTION(0);
19922   }
19923
19924   jresult = (unsigned long)result;
19925   return jresult;
19926 }
19927
19928
19929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
19930   void * jresult ;
19931   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
19932   size_t arg2 ;
19933   Dali::Actor result;
19934
19935   arg1 = (Dali::GestureDetector *)jarg1;
19936   arg2 = (size_t)jarg2;
19937   {
19938     try {
19939       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
19940     } CALL_CATCH_EXCEPTION(0);
19941   }
19942
19943   jresult = new Dali::Actor((const Dali::Actor &)result);
19944   return jresult;
19945 }
19946
19947
19948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
19949   void * jresult ;
19950   Dali::Gesture *arg1 = 0 ;
19951   Dali::Gesture *result = 0 ;
19952
19953   arg1 = (Dali::Gesture *)jarg1;
19954   if (!arg1) {
19955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
19956     return 0;
19957   }
19958   {
19959     try {
19960       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
19961     } CALL_CATCH_EXCEPTION(0);
19962   }
19963
19964   jresult = (void *)result;
19965   return jresult;
19966 }
19967
19968
19969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
19970   void * jresult ;
19971   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19972   Dali::Gesture *arg2 = 0 ;
19973   Dali::Gesture *result = 0 ;
19974
19975   arg1 = (Dali::Gesture *)jarg1;
19976   arg2 = (Dali::Gesture *)jarg2;
19977   if (!arg2) {
19978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
19979     return 0;
19980   }
19981   {
19982     try {
19983       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
19984     } CALL_CATCH_EXCEPTION(0);
19985   }
19986
19987   jresult = (void *)result;
19988   return jresult;
19989 }
19990
19991
19992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
19993   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19994
19995   arg1 = (Dali::Gesture *)jarg1;
19996   {
19997     try {
19998       delete arg1;
19999     } CALL_CATCH_EXCEPTION();
20000   }
20001
20002 }
20003
20004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
20005   int jresult ;
20006   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
20007   Dali::GestureType::Value result;
20008
20009   arg1 = (Dali::Gesture *)jarg1;
20010   result = (Dali::GestureType::Value) ((arg1)->GetType());
20011   jresult = (int)result;
20012   return jresult;
20013 }
20014
20015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
20016   int jresult ;
20017   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
20018   Dali::GestureState result;
20019
20020   arg1 = (Dali::Gesture *)jarg1;
20021   result = (Dali::GestureState) ((arg1)->GetState());
20022   jresult = (int)result;
20023   return jresult;
20024 }
20025
20026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
20027   unsigned int jresult ;
20028   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
20029   unsigned int result;
20030
20031   arg1 = (Dali::Gesture *)jarg1;
20032   result = (unsigned int) ((arg1)->GetTime());
20033   jresult = result;
20034   return jresult;
20035 }
20036
20037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_sourceType_get(void * gesture) {
20038   int jresult ;
20039   Dali::Gesture *jGesture = (Dali::Gesture *) gesture;
20040   Dali::GestureSourceType result;
20041
20042   if (!jGesture) {
20043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
20044     return 0;
20045   }
20046   {
20047     try {
20048       result = (Dali::GestureSourceType)jGesture->GetSourceType();
20049     } CALL_CATCH_EXCEPTION(0);
20050   }
20051
20052   jresult = (int)result;
20053   return jresult;
20054 }
20055
20056
20057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_sourceData_get(void * gesture) {
20058   int jresult ;
20059   Dali::Gesture *jGesture = (Dali::Gesture *) gesture;
20060   Dali::GestureSourceData result;
20061
20062   if (!jGesture) {
20063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::gesture const & type is null", 0);
20064     return 0;
20065   }
20066   {
20067     try {
20068       result = (Dali::GestureSourceData)jGesture->GetSourceData();
20069     } CALL_CATCH_EXCEPTION(0);
20070   }
20071
20072   jresult = (int)result;
20073   return jresult;
20074 }
20075
20076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
20077   void * jresult ;
20078   Dali::HoverEvent *result = 0 ;
20079
20080   {
20081     try {
20082       result = (Dali::HoverEvent *)new Dali::HoverEvent();
20083     } CALL_CATCH_EXCEPTION(0);
20084   }
20085
20086   jresult = (void *)result;
20087   return jresult;
20088 }
20089
20090
20091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(void * jarg1) {
20092   void * jresult ;
20093   Dali::HoverEvent *arg1 = 0 ;
20094   Dali::HoverEvent *result = 0 ;
20095
20096   arg1 = (Dali::HoverEvent *)jarg1;
20097   if (!arg1) {
20098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
20099     return 0;
20100   }
20101   {
20102     try {
20103       result = (Dali::HoverEvent *)new Dali::HoverEvent((Dali::HoverEvent const &)*arg1);
20104     } CALL_CATCH_EXCEPTION(0);
20105   }
20106
20107   jresult = (void *)result;
20108   return jresult;
20109 }
20110
20111
20112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
20113   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20114
20115   arg1 = (Dali::HoverEvent *)jarg1;
20116   {
20117     try {
20118       delete arg1;
20119     } CALL_CATCH_EXCEPTION();
20120   }
20121
20122 }
20123
20124
20125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_Assign(void * jarg1, void * jarg2) {
20126   void * jresult ;
20127   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20128   Dali::HoverEvent *arg2 = 0 ;
20129   Dali::HoverEvent *result = 0 ;
20130
20131   arg1 = (Dali::HoverEvent *)jarg1;
20132   arg2 = (Dali::HoverEvent *)jarg2;
20133   if (!arg2) {
20134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
20135     return 0;
20136   }
20137   {
20138     try {
20139       result = (Dali::HoverEvent *) &(arg1)->operator =((Dali::HoverEvent const &)*arg2);
20140     } catch (std::out_of_range& e) {
20141       {
20142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20143       };
20144     } catch (std::exception& e) {
20145       {
20146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20147       };
20148     } catch (Dali::DaliException e) {
20149       {
20150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20151       };
20152     } catch (...) {
20153       {
20154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20155       };
20156     }
20157   }
20158
20159   jresult = (void *)result;
20160   return jresult;
20161 }
20162
20163
20164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_New(unsigned int jarg1) {
20165   void * jresult ;
20166   unsigned int arg1 ;
20167   Dali::HoverEvent result;
20168
20169   arg1 = (unsigned int)jarg1;
20170   {
20171     try {
20172       result = DevelHoverEvent::New(arg1);
20173     } CALL_CATCH_EXCEPTION(0);
20174   }
20175
20176   jresult = new Dali::HoverEvent((const Dali::HoverEvent &)result);
20177   return jresult;
20178 }
20179
20180
20181 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetTime(void * jarg1) {
20182   unsigned long jresult ;
20183   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20184   unsigned long result;
20185
20186   arg1 = (Dali::HoverEvent *)jarg1;
20187   {
20188     try {
20189       result = (unsigned long)((Dali::HoverEvent const *)arg1)->GetTime();
20190     } catch (std::out_of_range& e) {
20191       {
20192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20193       };
20194     } catch (std::exception& e) {
20195       {
20196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20197       };
20198     } catch (Dali::DaliException e) {
20199       {
20200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20201       };
20202     } catch (...) {
20203       {
20204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20205       };
20206     }
20207   }
20208
20209   jresult = (unsigned long)result;
20210   return jresult;
20211 }
20212
20213
20214 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
20215   unsigned long jresult ;
20216   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20217   std::size_t result;
20218
20219   arg1 = (Dali::HoverEvent *)jarg1;
20220   {
20221     try {
20222       result = ((Dali::HoverEvent const *)arg1)->GetPointCount();
20223     } catch (std::out_of_range& e) {
20224       {
20225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20226       };
20227     } catch (std::exception& e) {
20228       {
20229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20230       };
20231     } catch (Dali::DaliException e) {
20232       {
20233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20234       };
20235     } catch (...) {
20236       {
20237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20238       };
20239     }
20240   }
20241
20242   jresult = (unsigned long)result;
20243   return jresult;
20244 }
20245
20246
20247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetDeviceId(void * jarg1, unsigned long jarg2) {
20248   int jresult ;
20249   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20250   std::size_t arg2 ;
20251   int32_t result;
20252
20253   arg1 = (Dali::HoverEvent *)jarg1;
20254   arg2 = (std::size_t)jarg2;
20255   {
20256     try {
20257       result = ((Dali::HoverEvent const *)arg1)->GetDeviceId(arg2);
20258     } catch (std::out_of_range& e) {
20259       {
20260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20261       };
20262     } catch (std::exception& e) {
20263       {
20264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20265       };
20266     } catch (Dali::DaliException e) {
20267       {
20268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20269       };
20270     } catch (...) {
20271       {
20272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20273       };
20274     }
20275   }
20276
20277   jresult = result;
20278   return jresult;
20279 }
20280
20281
20282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetState(void * jarg1, unsigned long jarg2) {
20283   int jresult ;
20284   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20285   std::size_t arg2 ;
20286   Dali::PointState::Type result;
20287
20288   arg1 = (Dali::HoverEvent *)jarg1;
20289   arg2 = (std::size_t)jarg2;
20290   {
20291     try {
20292       result = (Dali::PointState::Type)((Dali::HoverEvent const *)arg1)->GetState(arg2);
20293     } CALL_CATCH_EXCEPTION(0);
20294   }
20295
20296   jresult = (int)result;
20297   return jresult;
20298 }
20299
20300
20301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetHitActor(void * jarg1, unsigned long jarg2) {
20302   void * jresult ;
20303   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20304   std::size_t arg2 ;
20305   Dali::Actor result;
20306
20307   arg1 = (Dali::HoverEvent *)jarg1;
20308   arg2 = (std::size_t)jarg2;
20309   {
20310     try {
20311       result = ((Dali::HoverEvent const *)arg1)->GetHitActor(arg2);
20312     } catch (std::out_of_range& e) {
20313       {
20314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20315       };
20316     } catch (std::exception& e) {
20317       {
20318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20319       };
20320     } catch (Dali::DaliException e) {
20321       {
20322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20323       };
20324     } catch (...) {
20325       {
20326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20327       };
20328     }
20329   }
20330
20331   jresult = new Dali::Actor((const Dali::Actor &)result);
20332   return jresult;
20333 }
20334
20335
20336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetLocalPosition(void * jarg1, unsigned long jarg2) {
20337   void * jresult ;
20338   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20339   std::size_t arg2 ;
20340   Dali::Vector2 *result = 0 ;
20341
20342   arg1 = (Dali::HoverEvent *)jarg1;
20343   arg2 = (std::size_t)jarg2;
20344   {
20345     try {
20346       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetLocalPosition(arg2);
20347     } catch (std::out_of_range& e) {
20348       {
20349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20350       };
20351     } catch (std::exception& e) {
20352       {
20353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20354       };
20355     } catch (Dali::DaliException e) {
20356       {
20357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20358       };
20359     } catch (...) {
20360       {
20361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20362       };
20363     }
20364   }
20365
20366   jresult = (void *)result;
20367   return jresult;
20368 }
20369
20370
20371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetScreenPosition(void * jarg1, unsigned long jarg2) {
20372   void * jresult ;
20373   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20374   std::size_t arg2 ;
20375   Dali::Vector2 *result = 0 ;
20376
20377   arg1 = (Dali::HoverEvent *)jarg1;
20378   arg2 = (std::size_t)jarg2;
20379   {
20380     try {
20381       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetScreenPosition(arg2);
20382     } CALL_CATCH_EXCEPTION(0);
20383   }
20384
20385   jresult = (void *)result;
20386   return jresult;
20387 }
20388
20389
20390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
20391   void * jresult ;
20392   Dali::KeyEvent *result = 0 ;
20393
20394   {
20395     try {
20396       result = (Dali::KeyEvent *)new Dali::KeyEvent();
20397     } CALL_CATCH_EXCEPTION(0);
20398   }
20399
20400   jresult = (void *)result;
20401   return jresult;
20402 }
20403
20404
20405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(void * jarg1) {
20406   void * jresult ;
20407   Dali::KeyEvent *arg1 = 0 ;
20408   Dali::KeyEvent *result = 0 ;
20409
20410   arg1 = (Dali::KeyEvent *)jarg1;
20411   if (!arg1) {
20412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
20413     return 0;
20414   }
20415   {
20416     try {
20417       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
20418     } CALL_CATCH_EXCEPTION(0);
20419   }
20420
20421   jresult = (void *)result;
20422   return jresult;
20423 }
20424
20425
20426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
20427   void * jresult ;
20428   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
20429   Dali::KeyEvent *arg2 = 0 ;
20430   Dali::KeyEvent *result = 0 ;
20431
20432   arg1 = (Dali::KeyEvent *)jarg1;
20433   arg2 = (Dali::KeyEvent *)jarg2;
20434   if (!arg2) {
20435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
20436     return 0;
20437   }
20438   {
20439     try {
20440       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
20441     } CALL_CATCH_EXCEPTION(0);
20442   }
20443
20444   jresult = (void *)result;
20445   return jresult;
20446 }
20447
20448
20449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_New(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
20450   void * jresult ;
20451   std::string *arg1 = 0 ;
20452   std::string *arg2 = 0 ;
20453   int arg3 ;
20454   int arg4 ;
20455   unsigned long arg5 ;
20456   Dali::KeyEvent::State *arg6 = 0 ;
20457   Dali::KeyEvent::State temp6 ;
20458   Dali::KeyEvent result;
20459
20460   if (!jarg1) {
20461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20462     return 0;
20463   }
20464   std::string arg1_str(jarg1);
20465   arg1 = &arg1_str;
20466   if (!jarg2) {
20467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20468     return 0;
20469   }
20470   std::string arg2_str(jarg2);
20471   arg2 = &arg2_str;
20472   arg3 = (int)jarg3;
20473   arg4 = (int)jarg4;
20474   arg5 = (unsigned long)jarg5;
20475   temp6 = (Dali::KeyEvent::State)jarg6;
20476   arg6 = &temp6;
20477   {
20478     try {
20479       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);
20480     } CALL_CATCH_EXCEPTION(0);
20481   }
20482
20483   jresult = new Dali::KeyEvent((const Dali::KeyEvent &)result);
20484
20485   //argout typemap for const std::string&
20486
20487
20488   //argout typemap for const std::string&
20489
20490   return jresult;
20491 }
20492
20493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
20494   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
20495
20496   arg1 = (Dali::KeyEvent *)jarg1;
20497   {
20498     try {
20499       delete arg1;
20500     } CALL_CATCH_EXCEPTION();
20501   }
20502
20503 }
20504
20505
20506 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
20507   bool jresult ;
20508   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
20509   bool result;
20510
20511   arg1 = (Dali::KeyEvent *)jarg1;
20512   {
20513     try {
20514       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
20515     } CALL_CATCH_EXCEPTION(0);
20516   }
20517
20518   jresult = result;
20519   return jresult;
20520 }
20521
20522
20523 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
20524   bool jresult ;
20525   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
20526   bool result;
20527
20528   arg1 = (Dali::KeyEvent *)jarg1;
20529   {
20530     try {
20531       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
20532     } CALL_CATCH_EXCEPTION(0);
20533   }
20534
20535   jresult = result;
20536   return jresult;
20537 }
20538
20539
20540 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
20541   bool jresult ;
20542   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
20543   bool result;
20544
20545   arg1 = (Dali::KeyEvent *)jarg1;
20546   {
20547     try {
20548       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
20549     } CALL_CATCH_EXCEPTION(0);
20550   }
20551
20552   jresult = result;
20553   return jresult;
20554 }
20555
20556
20557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
20558   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
20559   std::string *arg2 = 0 ;
20560
20561   argp1 = (Dali::KeyEvent *) jarg1;
20562   if (!argp1) {
20563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
20564     return ;
20565   }
20566
20567   Dali::KeyEvent arg1 = *argp1;
20568   if (!jarg2) {
20569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20570     return ;
20571   }
20572   std::string arg2_str(jarg2);
20573   arg2 = &arg2_str;
20574
20575   {
20576     try {
20577       Dali::DevelKeyEvent::SetKeyName(arg1, (std::string const &)*arg2);
20578     } catch (std::out_of_range& e) {
20579       {
20580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20581       };
20582     } catch (std::exception& e) {
20583       {
20584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20585       };
20586     } catch (Dali::DaliException e) {
20587       {
20588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20589       };
20590     } catch (...) {
20591       {
20592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20593       };
20594     }
20595   }
20596 }
20597
20598
20599 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
20600   char * jresult ;
20601
20602   if( jarg1 == NULL )
20603   {
20604     jresult = SWIG_csharp_string_callback( "" );
20605   }
20606   else
20607   {
20608     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
20609     std::string *result = 0;
20610     std::string str = "";
20611
20612     arg1 = ( Dali::KeyEvent * )jarg1;
20613     {
20614       try {
20615         str = ((Dali::KeyEvent const *)arg1)->GetKeyName();
20616         result = (std::string *) &str;
20617         jresult = SWIG_csharp_string_callback(result->c_str());
20618       } catch (std::out_of_range& e) {
20619         {
20620           SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20621         };
20622       } catch (std::exception& e) {
20623         {
20624           SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20625         };
20626       } catch (Dali::DaliException e) {
20627         {
20628           SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20629         };
20630       } catch (...) {
20631         {
20632           SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20633         };
20634       }
20635     }
20636
20637   }
20638
20639   return jresult;
20640 }
20641
20642
20643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
20644   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
20645   std::string *arg2 = 0 ;
20646
20647   argp1 = (Dali::KeyEvent *) jarg1;
20648   if (!argp1) {
20649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
20650     return ;
20651   }
20652
20653   Dali::KeyEvent arg1 = *argp1;
20654   if (!jarg2) {
20655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20656     return ;
20657   }
20658   std::string arg2_str(jarg2);
20659   arg2 = &arg2_str;
20660
20661   {
20662     try {
20663       Dali::DevelKeyEvent::SetKeyString(arg1, (std::string const &)*arg2);
20664     } catch (std::out_of_range& e) {
20665       {
20666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20667       };
20668     } catch (std::exception& e) {
20669       {
20670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20671       };
20672     } catch (Dali::DaliException e) {
20673       {
20674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20675       };
20676     } catch (...) {
20677       {
20678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20679       };
20680     }
20681   }
20682 }
20683
20684
20685 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
20686   char * jresult ;
20687
20688   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
20689   std::string *result = 0;
20690   std::string str = "";
20691   arg1 = ( Dali::KeyEvent * )jarg1;
20692   {
20693     try {
20694       str = ((Dali::KeyEvent const *)arg1)->GetKeyString();
20695       result = (std::string *) &str;
20696       jresult = SWIG_csharp_string_callback(result->c_str());
20697     } catch (std::out_of_range& e) {
20698       {
20699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20700       };
20701     } catch (std::exception& e) {
20702       {
20703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20704       };
20705     } catch (Dali::DaliException e) {
20706       {
20707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20708       };
20709     } catch (...) {
20710       {
20711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20712       };
20713     }
20714   }
20715
20716   return jresult;
20717 }
20718
20719
20720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
20721   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
20722   int arg2 ;
20723
20724   argp1 = (Dali::KeyEvent *) jarg1;
20725   if (!argp1) {
20726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
20727     return ;
20728   }
20729
20730   Dali::KeyEvent arg1 = *argp1;
20731   arg2 = (int)jarg2;
20732   {
20733     try {
20734       Dali::DevelKeyEvent::SetKeyCode(arg1, arg2);
20735     } catch (std::out_of_range& e) {
20736       {
20737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20738       };
20739     } catch (std::exception& e) {
20740       {
20741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20742       };
20743     } catch (Dali::DaliException e) {
20744       {
20745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20746       };
20747     } catch (...) {
20748       {
20749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20750       };
20751     }
20752   }
20753 }
20754
20755
20756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
20757   int jresult ;
20758   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
20759   int result;
20760
20761   arg1 = (Dali::KeyEvent *)jarg1;
20762   {
20763     try {
20764       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyCode();
20765     } catch (std::out_of_range& e) {
20766       {
20767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20768       };
20769     } catch (std::exception& e) {
20770       {
20771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20772       };
20773     } catch (Dali::DaliException e) {
20774       {
20775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20776       };
20777     } catch (...) {
20778       {
20779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20780       };
20781     }
20782   }
20783
20784   jresult = result;
20785   return jresult;
20786 }
20787
20788
20789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
20790   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
20791   int arg2 ;
20792
20793   argp1 = (Dali::KeyEvent *) jarg1;
20794   if (!argp1) {
20795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
20796     return ;
20797   }
20798
20799   Dali::KeyEvent arg1 = *argp1;
20800   arg2 = (int)jarg2;
20801   {
20802     try {
20803       Dali::DevelKeyEvent::SetKeyModifier(arg1, arg2);
20804     } catch (std::out_of_range& e) {
20805       {
20806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20807       };
20808     } catch (std::exception& e) {
20809       {
20810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20811       };
20812     } catch (Dali::DaliException e) {
20813       {
20814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20815       };
20816     } catch (...) {
20817       {
20818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20819       };
20820     }
20821   }
20822 }
20823
20824
20825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
20826   int jresult ;
20827   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
20828   int result;
20829
20830   arg1 = (Dali::KeyEvent *)jarg1;
20831   {
20832     try {
20833       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyModifier();
20834     } catch (std::out_of_range& e) {
20835       {
20836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20837       };
20838     } catch (std::exception& e) {
20839       {
20840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20841       };
20842     } catch (Dali::DaliException e) {
20843       {
20844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20845       };
20846     } catch (...) {
20847       {
20848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20849       };
20850     }
20851   }
20852
20853   jresult = result;
20854   return jresult;
20855 }
20856
20857
20858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
20859   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
20860   unsigned long arg2 ;
20861
20862   argp1 = (Dali::KeyEvent *) jarg1;
20863   if (!argp1) {
20864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
20865     return ;
20866   }
20867
20868   Dali::KeyEvent arg1 = *argp1;
20869   arg2 = (int)jarg2;
20870   {
20871     try {
20872       Dali::DevelKeyEvent::SetTime(arg1, arg2);
20873     } catch (std::out_of_range& e) {
20874       {
20875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20876       };
20877     } catch (std::exception& e) {
20878       {
20879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20880       };
20881     } catch (Dali::DaliException e) {
20882       {
20883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20884       };
20885     } catch (...) {
20886       {
20887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20888       };
20889     }
20890   }
20891 }
20892
20893
20894 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
20895   unsigned long jresult ;
20896   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
20897   unsigned long result;
20898
20899   arg1 = (Dali::KeyEvent *)jarg1;
20900   {
20901     try {
20902       result = (int)((Dali::KeyEvent const *)arg1)->GetTime();
20903     } catch (std::out_of_range& e) {
20904       {
20905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20906       };
20907     } catch (std::exception& e) {
20908       {
20909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20910       };
20911     } catch (Dali::DaliException e) {
20912       {
20913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20914       };
20915     } catch (...) {
20916       {
20917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20918       };
20919     }
20920   }
20921
20922   jresult = result;
20923   return jresult;
20924 }
20925
20926
20927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
20928   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0;
20929   Dali::KeyEvent::State arg2;
20930
20931   argp1 = (Dali::KeyEvent *) jarg1;
20932   if (!argp1) {
20933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
20934     return ;
20935   }
20936
20937   Dali::KeyEvent arg1 = *argp1;
20938   arg2 = (Dali::KeyEvent::State)jarg2;
20939   {
20940     try {
20941       Dali::DevelKeyEvent::SetState(arg1, arg2);
20942     } catch (std::out_of_range& e) {
20943       {
20944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20945       };
20946     } catch (std::exception& e) {
20947       {
20948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20949       };
20950     } catch (Dali::DaliException e) {
20951       {
20952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20953       };
20954     } catch (...) {
20955       {
20956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20957       };
20958     }
20959   }
20960 }
20961
20962
20963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
20964   int jresult ;
20965   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
20966   Dali::KeyEvent::State result;
20967
20968   arg1 = (Dali::KeyEvent *)jarg1;
20969   {
20970     try {
20971       result = (Dali::KeyEvent::State)((Dali::KeyEvent const *)arg1)->GetState();
20972     } catch (std::out_of_range& e) {
20973       {
20974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20975       };
20976     } catch (std::exception& e) {
20977       {
20978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20979       };
20980     } catch (Dali::DaliException e) {
20981       {
20982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20983       };
20984     } catch (...) {
20985       {
20986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20987       };
20988     }
20989   }
20990
20991   jresult = (int)result;
20992   return jresult;
20993
20994 }
20995
20996 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
20997   char * jresult ;
20998
20999   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
21000   std::string *result = 0;
21001   std::string str = "";
21002
21003   arg1 = ( Dali::KeyEvent * )jarg1;
21004   {
21005     try {
21006       str = ((Dali::KeyEvent const *)arg1)->GetLogicalKey();
21007       result = (std::string *) &str;
21008       jresult = SWIG_csharp_string_callback(result->c_str());
21009     } CALL_CATCH_EXCEPTION(0);
21010   }
21011
21012   return jresult;
21013 }
21014
21015
21016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
21017   void * jresult ;
21018   Dali::LongPressGestureDetector *result = 0 ;
21019
21020   {
21021     try {
21022       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
21023     } CALL_CATCH_EXCEPTION(0);
21024   }
21025
21026   jresult = (void *)result;
21027   return jresult;
21028 }
21029
21030
21031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
21032   void * jresult ;
21033   Dali::LongPressGestureDetector result;
21034
21035   {
21036     try {
21037       result = Dali::LongPressGestureDetector::New();
21038     } CALL_CATCH_EXCEPTION(0);
21039   }
21040
21041   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
21042   return jresult;
21043 }
21044
21045
21046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
21047   void * jresult ;
21048   unsigned int arg1 ;
21049   Dali::LongPressGestureDetector result;
21050
21051   arg1 = (unsigned int)jarg1;
21052   {
21053     try {
21054       result = Dali::LongPressGestureDetector::New(arg1);
21055     } CALL_CATCH_EXCEPTION(0);
21056   }
21057
21058   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
21059   return jresult;
21060 }
21061
21062
21063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
21064   void * jresult ;
21065   unsigned int arg1 ;
21066   unsigned int arg2 ;
21067   Dali::LongPressGestureDetector result;
21068
21069   arg1 = (unsigned int)jarg1;
21070   arg2 = (unsigned int)jarg2;
21071   {
21072     try {
21073       result = Dali::LongPressGestureDetector::New(arg1,arg2);
21074     } CALL_CATCH_EXCEPTION(0);
21075   }
21076
21077   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
21078   return jresult;
21079 }
21080
21081
21082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
21083   void * jresult ;
21084   Dali::BaseHandle arg1 ;
21085   Dali::BaseHandle *argp1 ;
21086   Dali::LongPressGestureDetector result;
21087
21088   argp1 = (Dali::BaseHandle *)jarg1;
21089   if (!argp1) {
21090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21091     return 0;
21092   }
21093   arg1 = *argp1;
21094   {
21095     try {
21096       result = Dali::LongPressGestureDetector::DownCast(arg1);
21097     } CALL_CATCH_EXCEPTION(0);
21098   }
21099
21100   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
21101   return jresult;
21102 }
21103
21104
21105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
21106   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
21107
21108   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21109   {
21110     try {
21111       delete arg1;
21112     } CALL_CATCH_EXCEPTION();
21113   }
21114
21115 }
21116
21117
21118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
21119   void * jresult ;
21120   Dali::LongPressGestureDetector *arg1 = 0 ;
21121   Dali::LongPressGestureDetector *result = 0 ;
21122
21123   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21124   if (!arg1) {
21125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
21126     return 0;
21127   }
21128   {
21129     try {
21130       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
21131     } CALL_CATCH_EXCEPTION(0);
21132   }
21133
21134   jresult = (void *)result;
21135   return jresult;
21136 }
21137
21138
21139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
21140   void * jresult ;
21141   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
21142   Dali::LongPressGestureDetector *arg2 = 0 ;
21143   Dali::LongPressGestureDetector *result = 0 ;
21144
21145   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21146   arg2 = (Dali::LongPressGestureDetector *)jarg2;
21147   if (!arg2) {
21148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
21149     return 0;
21150   }
21151   {
21152     try {
21153       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
21154     } CALL_CATCH_EXCEPTION(0);
21155   }
21156
21157   jresult = (void *)result;
21158   return jresult;
21159 }
21160
21161
21162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
21163   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
21164   unsigned int arg2 ;
21165
21166   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21167   arg2 = (unsigned int)jarg2;
21168   {
21169     try {
21170       (arg1)->SetTouchesRequired(arg2);
21171     } CALL_CATCH_EXCEPTION();
21172   }
21173
21174 }
21175
21176
21177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
21178   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
21179   unsigned int arg2 ;
21180   unsigned int arg3 ;
21181
21182   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21183   arg2 = (unsigned int)jarg2;
21184   arg3 = (unsigned int)jarg3;
21185   {
21186     try {
21187       (arg1)->SetTouchesRequired(arg2,arg3);
21188     } CALL_CATCH_EXCEPTION();
21189   }
21190
21191 }
21192
21193
21194 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
21195   unsigned int jresult ;
21196   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
21197   unsigned int result;
21198
21199   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21200   {
21201     try {
21202       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
21203     } CALL_CATCH_EXCEPTION(0);
21204   }
21205
21206   jresult = result;
21207   return jresult;
21208 }
21209
21210
21211 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
21212   unsigned int jresult ;
21213   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
21214   unsigned int result;
21215
21216   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21217   {
21218     try {
21219       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
21220     } CALL_CATCH_EXCEPTION(0);
21221   }
21222
21223   jresult = result;
21224   return jresult;
21225 }
21226
21227
21228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
21229   void * jresult ;
21230   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
21231   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
21232
21233   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21234   {
21235     try {
21236       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
21237     } CALL_CATCH_EXCEPTION(0);
21238   }
21239
21240   jresult = (void *)result;
21241   return jresult;
21242 }
21243
21244
21245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0() {
21246   void * jresult ;
21247   Dali::LongPressGesture *result = 0 ;
21248
21249   {
21250     try {
21251       result = (Dali::LongPressGesture *)new Dali::LongPressGesture();
21252     } CALL_CATCH_EXCEPTION(0);
21253   }
21254
21255   jresult = (void *)result;
21256   return jresult;
21257 }
21258
21259
21260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_New(int jarg1) {
21261   void * jresult ;
21262   Dali::GestureState arg1 ;
21263   Dali::LongPressGesture result;
21264
21265   arg1 = (Dali::GestureState)jarg1;
21266   {
21267     try {
21268       result = DevelLongPressGesture::New(arg1);
21269     } CALL_CATCH_EXCEPTION(0);
21270   }
21271
21272   jresult = new Dali::LongPressGesture((const Dali::LongPressGesture &)result);
21273   return jresult;
21274 }
21275
21276
21277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
21278   void * jresult ;
21279   Dali::LongPressGesture *arg1 = 0 ;
21280   Dali::LongPressGesture *result = 0 ;
21281
21282   arg1 = (Dali::LongPressGesture *)jarg1;
21283   if (!arg1) {
21284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
21285     return 0;
21286   }
21287   {
21288     try {
21289       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
21290     } CALL_CATCH_EXCEPTION(0);
21291   }
21292
21293   jresult = (void *)result;
21294   return jresult;
21295 }
21296
21297
21298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
21299   void * jresult ;
21300   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
21301   Dali::LongPressGesture *arg2 = 0 ;
21302   Dali::LongPressGesture *result = 0 ;
21303
21304   arg1 = (Dali::LongPressGesture *)jarg1;
21305   arg2 = (Dali::LongPressGesture *)jarg2;
21306   if (!arg2) {
21307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
21308     return 0;
21309   }
21310   {
21311     try {
21312       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
21313     } CALL_CATCH_EXCEPTION(0);
21314   }
21315
21316   jresult = (void *)result;
21317   return jresult;
21318 }
21319
21320
21321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
21322   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
21323
21324   arg1 = (Dali::LongPressGesture *)jarg1;
21325   {
21326     try {
21327       delete arg1;
21328     } CALL_CATCH_EXCEPTION();
21329   }
21330
21331 }
21332
21333
21334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
21335   unsigned int jresult ;
21336   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
21337   unsigned int result;
21338
21339   arg1 = (Dali::LongPressGesture *)jarg1;
21340   result = (unsigned int) ((arg1)->GetNumberOfTouches());
21341   jresult = result;
21342   return jresult;
21343 }
21344
21345
21346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
21347   void * jresult ;
21348   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
21349   Dali::Vector2 result;
21350
21351   arg1 = (Dali::LongPressGesture *)jarg1;
21352   {
21353     try {
21354       result = ((Dali::LongPressGesture const *)arg1)->GetScreenPoint();
21355     } catch (std::out_of_range& e) {
21356       {
21357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21358       };
21359     } catch (std::exception& e) {
21360       {
21361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21362       };
21363     } catch (Dali::DaliException e) {
21364       {
21365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21366       };
21367     } catch (...) {
21368       {
21369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21370       };
21371     }
21372   }
21373   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
21374   return jresult;
21375 }
21376
21377
21378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
21379   void * jresult ;
21380   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
21381   Dali::Vector2 result;
21382
21383   arg1 = (Dali::LongPressGesture *)jarg1;
21384   {
21385     try {
21386       result = ((Dali::LongPressGesture const *)arg1)->GetLocalPoint();
21387     } catch (std::out_of_range& e) {
21388       {
21389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21390       };
21391     } catch (std::exception& e) {
21392       {
21393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21394       };
21395     } catch (Dali::DaliException e) {
21396       {
21397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21398       };
21399     } catch (...) {
21400       {
21401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21402       };
21403     }
21404   }
21405   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
21406   return jresult;
21407 }
21408
21409
21410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
21411   void * jresult ;
21412   Dali::WheelEvent *result = 0 ;
21413
21414   {
21415     try {
21416       result = (Dali::WheelEvent *)new Dali::WheelEvent();
21417     } CALL_CATCH_EXCEPTION(0);
21418   }
21419
21420   jresult = (void *)result;
21421   return jresult;
21422 }
21423
21424
21425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(void * jarg1) {
21426   void * jresult ;
21427   Dali::WheelEvent *arg1 = 0 ;
21428   Dali::WheelEvent *result = 0 ;
21429
21430   arg1 = (Dali::WheelEvent *)jarg1;
21431   if (!arg1) {
21432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
21433     return 0;
21434   }
21435   {
21436     try {
21437       result = (Dali::WheelEvent *)new Dali::WheelEvent((Dali::WheelEvent const &)*arg1);
21438     } catch (std::out_of_range& e) {
21439       {
21440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21441       };
21442     } catch (std::exception& e) {
21443       {
21444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21445       };
21446     } catch (Dali::DaliException e) {
21447       {
21448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21449       };
21450     } catch (...) {
21451       {
21452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21453       };
21454     }
21455   }
21456
21457   jresult = (void *)result;
21458   return jresult;
21459 }
21460
21461
21462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_Assign(void * jarg1, void * jarg2) {
21463   void * jresult ;
21464   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21465   Dali::WheelEvent *arg2 = 0 ;
21466   Dali::WheelEvent *result = 0 ;
21467
21468   arg1 = (Dali::WheelEvent *)jarg1;
21469   arg2 = (Dali::WheelEvent *)jarg2;
21470   if (!arg2) {
21471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
21472     return 0;
21473   }
21474   {
21475     try {
21476       result = (Dali::WheelEvent *) &(arg1)->operator =((Dali::WheelEvent const &)*arg2);
21477     } catch (std::out_of_range& e) {
21478       {
21479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21480       };
21481     } catch (std::exception& e) {
21482       {
21483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21484       };
21485     } catch (Dali::DaliException e) {
21486       {
21487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21488       };
21489     } catch (...) {
21490       {
21491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21492       };
21493     }
21494   }
21495
21496   jresult = (void *)result;
21497   return jresult;
21498 }
21499
21500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_New(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
21501   void * jresult ;
21502   Dali::WheelEvent::Type arg1 ;
21503   int arg2 ;
21504   unsigned int arg3 ;
21505   Dali::Vector2 arg4 ;
21506   int arg5 ;
21507   unsigned int arg6 ;
21508   Dali::Vector2 *argp4 ;
21509   Dali::WheelEvent result;
21510
21511   arg1 = (Dali::WheelEvent::Type)jarg1;
21512   arg2 = (int)jarg2;
21513   arg3 = (unsigned int)jarg3;
21514   argp4 = (Dali::Vector2 *)jarg4;
21515   if (!argp4) {
21516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
21517     return 0;
21518   }
21519   arg4 = *argp4;
21520   arg5 = (int)jarg5;
21521   arg6 = (unsigned int)jarg6;
21522   {
21523     try {
21524       result = DevelWheelEvent::New(arg1,arg2,arg3,arg4,arg5,arg6);
21525     } CALL_CATCH_EXCEPTION(0);
21526   }
21527
21528   jresult = new Dali::WheelEvent((const Dali::WheelEvent &)result);
21529   return jresult;
21530 }
21531
21532
21533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
21534   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21535
21536   arg1 = (Dali::WheelEvent *)jarg1;
21537   {
21538     try {
21539       delete arg1;
21540     } CALL_CATCH_EXCEPTION();
21541   }
21542
21543 }
21544
21545
21546 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
21547   bool jresult ;
21548   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21549   bool result;
21550
21551   arg1 = (Dali::WheelEvent *)jarg1;
21552   {
21553     try {
21554       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
21555     } CALL_CATCH_EXCEPTION(0);
21556   }
21557
21558   jresult = result;
21559   return jresult;
21560 }
21561
21562
21563 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
21564   bool jresult ;
21565   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21566   bool result;
21567
21568   arg1 = (Dali::WheelEvent *)jarg1;
21569   {
21570     try {
21571       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
21572     } catch (std::out_of_range& e) {
21573       {
21574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21575       };
21576     } catch (std::exception& e) {
21577       {
21578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21579       };
21580     } catch (Dali::DaliException e) {
21581       {
21582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21583       };
21584     } catch (...) {
21585       {
21586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21587       };
21588     }
21589   }
21590
21591   jresult = result;
21592   return jresult;
21593 }
21594
21595
21596 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
21597   bool jresult ;
21598   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21599   bool result;
21600
21601   arg1 = (Dali::WheelEvent *)jarg1;
21602   {
21603     try {
21604       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
21605     } catch (std::out_of_range& e) {
21606       {
21607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21608       };
21609     } catch (std::exception& e) {
21610       {
21611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21612       };
21613     } catch (Dali::DaliException e) {
21614       {
21615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21616       };
21617     } catch (...) {
21618       {
21619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21620       };
21621     }
21622   }
21623
21624   jresult = result;
21625   return jresult;
21626 }
21627
21628
21629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
21630   int jresult ;
21631   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21632   Dali::WheelEvent::Type result;
21633
21634   arg1 = (Dali::WheelEvent *)jarg1;
21635   {
21636     try {
21637       result = ((Dali::WheelEvent const *)arg1)->GetType();
21638     } catch (std::out_of_range& e) {
21639       {
21640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21641       };
21642     } catch (std::exception& e) {
21643       {
21644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21645       };
21646     } catch (Dali::DaliException e) {
21647       {
21648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21649       };
21650     } catch (...) {
21651       {
21652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21653       };
21654     }
21655   }
21656
21657   jresult = (int)result;
21658   return jresult;
21659 }
21660
21661
21662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
21663   int jresult ;
21664   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21665   int result;
21666
21667   arg1 = (Dali::WheelEvent *)jarg1;
21668   {
21669     try {
21670       result = ((Dali::WheelEvent const *)arg1)->GetDirection();
21671     } catch (std::out_of_range& e) {
21672       {
21673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21674       };
21675     } catch (std::exception& e) {
21676       {
21677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21678       };
21679     } catch (Dali::DaliException e) {
21680       {
21681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21682       };
21683     } catch (...) {
21684       {
21685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21686       };
21687     }
21688   }
21689
21690   jresult = result;
21691   return jresult;
21692 }
21693
21694
21695 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
21696   unsigned int jresult ;
21697   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21698   unsigned int result;
21699
21700   arg1 = (Dali::WheelEvent *)jarg1;
21701   {
21702     try {
21703       result = ((Dali::WheelEvent const *)arg1)->GetModifiers();
21704     } CALL_CATCH_EXCEPTION(0);
21705   }
21706
21707   jresult = result;
21708   return jresult;
21709 }
21710
21711
21712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
21713   void * jresult ;
21714   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21715   Dali::Vector2 *result = 0 ;
21716
21717   arg1 = (Dali::WheelEvent *)jarg1;
21718   {
21719     try {
21720       result = (Dali::Vector2 *) &((Dali::WheelEvent const *)arg1)->GetPoint();
21721     } CALL_CATCH_EXCEPTION(0);
21722   }
21723
21724   jresult = (void *)result;
21725   return jresult;
21726 }
21727
21728
21729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_delta_get(void * jarg1) {
21730   int jresult ;
21731   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21732   int result;
21733
21734   arg1 = (Dali::WheelEvent *)jarg1;
21735   {
21736     try {
21737       result = ((Dali::WheelEvent const *)arg1)->GetDelta();
21738     } catch (std::out_of_range& e) {
21739       {
21740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21741       };
21742     } catch (std::exception& e) {
21743       {
21744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21745       };
21746     } catch (Dali::DaliException e) {
21747       {
21748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21749       };
21750     } catch (...) {
21751       {
21752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21753       };
21754     }
21755   }
21756
21757   jresult = result;
21758   return jresult;
21759 }
21760
21761
21762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
21763   unsigned int jresult ;
21764   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21765   unsigned int result;
21766
21767   arg1 = (Dali::WheelEvent *)jarg1;
21768   {
21769     try {
21770       result = ((Dali::WheelEvent const *)arg1)->GetTime();
21771     } catch (std::out_of_range& e) {
21772       {
21773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21774       };
21775     } catch (std::exception& e) {
21776       {
21777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21778       };
21779     } catch (Dali::DaliException e) {
21780       {
21781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21782       };
21783     } catch (...) {
21784       {
21785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21786       };
21787     }
21788   }
21789
21790   jresult = result;
21791   return jresult;
21792 }
21793
21794 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
21795   char * jresult ;
21796   Dali::KeyEvent *arg1 = 0 ;
21797   std::string result;
21798
21799   arg1 = (Dali::KeyEvent *)jarg1;
21800   if (!arg1) {
21801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
21802     return 0;
21803   }
21804   {
21805     try {
21806       result = arg1->GetDeviceName();
21807     } CALL_CATCH_EXCEPTION(0);
21808   }
21809
21810   jresult = SWIG_csharp_string_callback((&result)->c_str());
21811   return jresult;
21812 }
21813
21814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
21815   int jresult ;
21816   Dali::KeyEvent *arg1 = 0 ;
21817   Dali::Device::Class::Type result;
21818
21819   arg1 = (Dali::KeyEvent *)jarg1;
21820   if (!arg1) {
21821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
21822     return 0;
21823   }
21824   {
21825     try {
21826       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
21827     } CALL_CATCH_EXCEPTION(0);
21828   }
21829
21830   jresult = (int)result;
21831   return jresult;
21832 }
21833
21834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
21835   int jresult ;
21836   Dali::KeyEvent *arg1 = 0 ;
21837   Dali::Device::Subclass::Type result;
21838
21839   arg1 = (Dali::KeyEvent *)jarg1;
21840   if (!arg1) {
21841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
21842     return 0;
21843   }
21844   {
21845     try {
21846       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
21847     } CALL_CATCH_EXCEPTION(0);
21848   }
21849
21850   jresult = (int)result;
21851   return jresult;
21852 }
21853
21854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
21855   Dali::Actor arg1 ;
21856   Dali::Actor *argp1 ;
21857
21858   argp1 = (Dali::Actor *)jarg1;
21859   if (!argp1) {
21860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
21861     return ;
21862   }
21863   arg1 = *argp1;
21864   {
21865     try {
21866       arg1.Raise();
21867     } CALL_CATCH_EXCEPTION();
21868   }
21869
21870 }
21871
21872
21873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
21874   Dali::Actor arg1 ;
21875   Dali::Actor *argp1 ;
21876
21877   argp1 = (Dali::Actor *)jarg1;
21878   if (!argp1) {
21879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
21880     return ;
21881   }
21882   arg1 = *argp1;
21883   {
21884     try {
21885       arg1.Lower();
21886     } CALL_CATCH_EXCEPTION();
21887   }
21888
21889 }
21890
21891
21892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
21893   Dali::Actor arg1 ;
21894   Dali::Actor *argp1 ;
21895
21896   argp1 = (Dali::Actor *)jarg1;
21897   if (!argp1) {
21898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
21899     return ;
21900   }
21901   arg1 = *argp1;
21902   {
21903     try {
21904       arg1.RaiseToTop();
21905     } CALL_CATCH_EXCEPTION();
21906   }
21907
21908 }
21909
21910
21911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
21912   Dali::Actor arg1 ;
21913   Dali::Actor *argp1 ;
21914
21915   argp1 = (Dali::Actor *)jarg1;
21916   if (!argp1) {
21917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
21918     return ;
21919   }
21920   arg1 = *argp1;
21921   {
21922     try {
21923       arg1.LowerToBottom();
21924     } CALL_CATCH_EXCEPTION();
21925   }
21926
21927 }
21928
21929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
21930   Dali::Actor arg1 ;
21931   Dali::Actor arg2 ;
21932   Dali::Actor *argp1 ;
21933   Dali::Actor *argp2 ;
21934
21935   argp1 = (Dali::Actor *)jarg1;
21936   if (!argp1) {
21937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
21938     return ;
21939   }
21940   arg1 = *argp1;
21941   argp2 = (Dali::Actor *)jarg2;
21942   if (!argp2) {
21943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
21944     return ;
21945   }
21946   arg2 = *argp2;
21947   {
21948     try {
21949       arg1.RaiseAbove(arg2);
21950     } CALL_CATCH_EXCEPTION();
21951   }
21952
21953 }
21954
21955
21956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
21957   Dali::Actor arg1 ;
21958   Dali::Actor arg2 ;
21959   Dali::Actor *argp1 ;
21960   Dali::Actor *argp2 ;
21961
21962   argp1 = (Dali::Actor *)jarg1;
21963   if (!argp1) {
21964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
21965     return ;
21966   }
21967   arg1 = *argp1;
21968   argp2 = (Dali::Actor *)jarg2;
21969   if (!argp2) {
21970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
21971     return ;
21972   }
21973   arg2 = *argp2;
21974   {
21975     try {
21976       arg1.LowerBelow(arg2);
21977     } CALL_CATCH_EXCEPTION();
21978   }
21979
21980 }
21981
21982
21983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
21984   void * jresult ;
21985   Dali::Actor arg1 ;
21986   Dali::Actor *argp1 ;
21987   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
21988
21989   argp1 = (Dali::Actor *)jarg1;
21990   if (!argp1) {
21991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
21992     return 0;
21993   }
21994   arg1 = *argp1;
21995   {
21996     try {
21997       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
21998     } CALL_CATCH_EXCEPTION(0);
21999   }
22000
22001   jresult = (void *)result;
22002   return jresult;
22003 }
22004
22005
22006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
22007   void * jresult ;
22008   Dali::Actor *arg1 ;
22009   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
22010
22011   arg1 = (Dali::Actor *)jarg1;
22012   {
22013     try {
22014       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
22015     } CALL_CATCH_EXCEPTION(0);
22016   }
22017
22018   jresult = (void *)result;
22019   return jresult;
22020 }
22021
22022
22023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
22024   int jresult ;
22025   int result;
22026
22027   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
22028   jresult = (int)result;
22029   return jresult;
22030 }
22031
22032
22033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
22034   int jresult ;
22035   int result;
22036
22037   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
22038   jresult = (int)result;
22039   return jresult;
22040 }
22041
22042
22043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
22044   int jresult ;
22045   int result;
22046
22047   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
22048   jresult = (int)result;
22049   return jresult;
22050 }
22051
22052
22053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
22054   int jresult ;
22055   int result;
22056
22057   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
22058   jresult = (int)result;
22059   return jresult;
22060 }
22061
22062
22063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
22064   int jresult ;
22065   int result;
22066
22067   result = (int)Dali::Actor::Property::ANCHOR_POINT;
22068   jresult = (int)result;
22069   return jresult;
22070 }
22071
22072
22073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
22074   int jresult ;
22075   int result;
22076
22077   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
22078   jresult = (int)result;
22079   return jresult;
22080 }
22081
22082
22083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
22084   int jresult ;
22085   int result;
22086
22087   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
22088   jresult = (int)result;
22089   return jresult;
22090 }
22091
22092
22093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
22094   int jresult ;
22095   int result;
22096
22097   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
22098   jresult = (int)result;
22099   return jresult;
22100 }
22101
22102
22103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
22104   int jresult ;
22105   int result;
22106
22107   result = (int)Dali::Actor::Property::SIZE;
22108   jresult = (int)result;
22109   return jresult;
22110 }
22111
22112
22113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
22114   int jresult ;
22115   int result;
22116
22117   result = (int)Dali::Actor::Property::SIZE_WIDTH;
22118   jresult = (int)result;
22119   return jresult;
22120 }
22121
22122
22123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
22124   int jresult ;
22125   int result;
22126
22127   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
22128   jresult = (int)result;
22129   return jresult;
22130 }
22131
22132
22133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
22134   int jresult ;
22135   int result;
22136
22137   result = (int)Dali::Actor::Property::SIZE_DEPTH;
22138   jresult = (int)result;
22139   return jresult;
22140 }
22141
22142
22143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
22144   int jresult ;
22145   int result;
22146
22147   result = (int)Dali::Actor::Property::POSITION;
22148   jresult = (int)result;
22149   return jresult;
22150 }
22151
22152
22153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
22154   int jresult ;
22155   int result;
22156
22157   result = (int)Dali::Actor::Property::POSITION_X;
22158   jresult = (int)result;
22159   return jresult;
22160 }
22161
22162
22163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
22164   int jresult ;
22165   int result;
22166
22167   result = (int)Dali::Actor::Property::POSITION_Y;
22168   jresult = (int)result;
22169   return jresult;
22170 }
22171
22172
22173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
22174   int jresult ;
22175   int result;
22176
22177   result = (int)Dali::Actor::Property::POSITION_Z;
22178   jresult = (int)result;
22179   return jresult;
22180 }
22181
22182
22183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
22184   int jresult ;
22185   int result;
22186
22187   result = (int)Dali::Actor::Property::WORLD_POSITION;
22188   jresult = (int)result;
22189   return jresult;
22190 }
22191
22192
22193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
22194   int jresult ;
22195   int result;
22196
22197   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
22198   jresult = (int)result;
22199   return jresult;
22200 }
22201
22202
22203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
22204   int jresult ;
22205   int result;
22206
22207   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
22208   jresult = (int)result;
22209   return jresult;
22210 }
22211
22212
22213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
22214   int jresult ;
22215   int result;
22216
22217   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
22218   jresult = (int)result;
22219   return jresult;
22220 }
22221
22222
22223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
22224   int jresult ;
22225   int result;
22226
22227   result = (int)Dali::Actor::Property::ORIENTATION;
22228   jresult = (int)result;
22229   return jresult;
22230 }
22231
22232
22233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
22234   int jresult ;
22235   int result;
22236
22237   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
22238   jresult = (int)result;
22239   return jresult;
22240 }
22241
22242
22243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
22244   int jresult ;
22245   int result;
22246
22247   result = (int)Dali::Actor::Property::SCALE;
22248   jresult = (int)result;
22249   return jresult;
22250 }
22251
22252
22253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
22254   int jresult ;
22255   int result;
22256
22257   result = (int)Dali::Actor::Property::SCALE_X;
22258   jresult = (int)result;
22259   return jresult;
22260 }
22261
22262
22263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
22264   int jresult ;
22265   int result;
22266
22267   result = (int)Dali::Actor::Property::SCALE_Y;
22268   jresult = (int)result;
22269   return jresult;
22270 }
22271
22272
22273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
22274   int jresult ;
22275   int result;
22276
22277   result = (int)Dali::Actor::Property::SCALE_Z;
22278   jresult = (int)result;
22279   return jresult;
22280 }
22281
22282
22283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
22284   int jresult ;
22285   int result;
22286
22287   result = (int)Dali::Actor::Property::WORLD_SCALE;
22288   jresult = (int)result;
22289   return jresult;
22290 }
22291
22292
22293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
22294   int jresult ;
22295   int result;
22296
22297   result = (int)Dali::Actor::Property::VISIBLE;
22298   jresult = (int)result;
22299   return jresult;
22300 }
22301
22302
22303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
22304   int jresult ;
22305   int result;
22306
22307   result = (int)Dali::Actor::Property::COLOR;
22308   jresult = (int)result;
22309   return jresult;
22310 }
22311
22312
22313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
22314   int jresult ;
22315   int result;
22316
22317   result = (int)Dali::Actor::Property::COLOR_RED;
22318   jresult = (int)result;
22319   return jresult;
22320 }
22321
22322
22323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
22324   int jresult ;
22325   int result;
22326
22327   result = (int)Dali::Actor::Property::COLOR_GREEN;
22328   jresult = (int)result;
22329   return jresult;
22330 }
22331
22332
22333 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
22334   int jresult ;
22335   int result;
22336
22337   result = (int)Dali::Actor::Property::COLOR_BLUE;
22338   jresult = (int)result;
22339   return jresult;
22340 }
22341
22342
22343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
22344   int jresult ;
22345   int result;
22346
22347   result = (int)Dali::Actor::Property::COLOR_ALPHA;
22348   jresult = (int)result;
22349   return jresult;
22350 }
22351
22352
22353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
22354   int jresult ;
22355   int result;
22356
22357   result = (int)Dali::Actor::Property::WORLD_COLOR;
22358   jresult = (int)result;
22359   return jresult;
22360 }
22361
22362
22363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
22364   int jresult ;
22365   int result;
22366
22367   result = (int)Dali::Actor::Property::WORLD_MATRIX;
22368   jresult = (int)result;
22369   return jresult;
22370 }
22371
22372
22373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
22374   int jresult ;
22375   int result;
22376
22377   result = (int)Dali::Actor::Property::NAME;
22378   jresult = (int)result;
22379   return jresult;
22380 }
22381
22382
22383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
22384   int jresult ;
22385   int result;
22386
22387   result = (int)Dali::Actor::Property::SENSITIVE;
22388   jresult = (int)result;
22389   return jresult;
22390 }
22391
22392
22393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_USER_INTERACTION_ENABLED_get() {
22394   int jresult ;
22395   int result;
22396
22397   result = (int)Dali::DevelActor::Property::USER_INTERACTION_ENABLED;
22398   jresult = (int)result;
22399   return jresult;
22400 }
22401
22402
22403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
22404   int jresult ;
22405   int result;
22406
22407   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
22408   jresult = (int)result;
22409   return jresult;
22410 }
22411
22412
22413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
22414   int jresult ;
22415   int result;
22416
22417   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
22418   jresult = (int)result;
22419   return jresult;
22420 }
22421
22422
22423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
22424   int jresult ;
22425   int result;
22426
22427   result = (int)Dali::Actor::Property::INHERIT_SCALE;
22428   jresult = (int)result;
22429   return jresult;
22430 }
22431
22432
22433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
22434   int jresult ;
22435   int result;
22436
22437   result = (int)Dali::Actor::Property::COLOR_MODE;
22438   jresult = (int)result;
22439   return jresult;
22440 }
22441
22442
22443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
22444   int jresult ;
22445   int result;
22446
22447   result = (int)Dali::Actor::Property::DRAW_MODE;
22448   jresult = (int)result;
22449   return jresult;
22450 }
22451
22452
22453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
22454   int jresult ;
22455   int result;
22456
22457   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
22458   jresult = (int)result;
22459   return jresult;
22460 }
22461
22462
22463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
22464   int jresult ;
22465   int result;
22466
22467   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
22468   jresult = (int)result;
22469   return jresult;
22470 }
22471
22472
22473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
22474   int jresult ;
22475   int result;
22476
22477   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
22478   jresult = (int)result;
22479   return jresult;
22480 }
22481
22482
22483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
22484   int jresult ;
22485   int result;
22486
22487   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
22488   jresult = (int)result;
22489   return jresult;
22490 }
22491
22492
22493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
22494   int jresult ;
22495   int result;
22496
22497   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
22498   jresult = (int)result;
22499   return jresult;
22500 }
22501
22502
22503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
22504   int jresult ;
22505   int result;
22506
22507   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
22508   jresult = (int)result;
22509   return jresult;
22510 }
22511
22512
22513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
22514   int jresult ;
22515   int result;
22516
22517   result = (int)Dali::Actor::Property::PADDING;
22518   jresult = (int)result;
22519   return jresult;
22520 }
22521
22522
22523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
22524   int jresult ;
22525   int result;
22526
22527   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
22528   jresult = (int)result;
22529   return jresult;
22530 }
22531
22532
22533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
22534   int jresult ;
22535   int result;
22536
22537   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
22538   jresult = (int)result;
22539   return jresult;
22540 }
22541
22542
22543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
22544   int jresult ;
22545   int result;
22546
22547   result = (int)Dali::Actor::Property::INHERIT_POSITION;
22548   jresult = (int)result;
22549   return jresult;
22550 }
22551
22552
22553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
22554   int jresult ;
22555   int result;
22556
22557   result = (int)Dali::Actor::Property::CLIPPING_MODE;
22558   jresult = (int)result;
22559   return jresult;
22560 }
22561
22562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_UPDATE_AREA_HINT_get() {
22563   int jresult ;
22564   int result;
22565
22566   result = (int)Dali::Actor::Property::UPDATE_AREA_HINT;
22567   jresult = (int)result;
22568   return jresult;
22569 }
22570
22571 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_OPACITY_get() {
22572
22573   return Dali::Actor::Property::OPACITY;
22574 }
22575
22576 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SCREEN_POSITION_get() {
22577
22578   return Dali::Actor::Property::SCREEN_POSITION;
22579 }
22580
22581 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_POSITION_USES_ANCHOR_POINT_get() {
22582
22583   return Dali::Actor::Property::POSITION_USES_ANCHOR_POINT;
22584 }
22585
22586 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_INHERIT_LAYOUT_DIRECTION_get() {
22587   return Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION;
22588 }
22589
22590 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_LAYOUT_DIRECTION_get() {
22591   return Dali::Actor::Property::LAYOUT_DIRECTION;
22592 }
22593
22594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
22595   void * jresult ;
22596   Dali::Actor::Property *result = 0 ;
22597
22598   {
22599     try {
22600       result = (Dali::Actor::Property *)new Dali::Actor::Property();
22601     } CALL_CATCH_EXCEPTION(0);
22602   }
22603
22604   jresult = (void *)result;
22605   return jresult;
22606 }
22607
22608
22609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
22610   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
22611
22612   arg1 = (Dali::Actor::Property *)jarg1;
22613   {
22614     try {
22615       delete arg1;
22616     } CALL_CATCH_EXCEPTION();
22617   }
22618
22619 }
22620
22621
22622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
22623   void * jresult ;
22624   Dali::Actor *result = 0 ;
22625
22626   {
22627     try {
22628       result = (Dali::Actor *)new Dali::Actor();
22629     } CALL_CATCH_EXCEPTION(0);
22630   }
22631
22632   jresult = (void *)result;
22633   return jresult;
22634 }
22635
22636
22637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
22638   void * jresult ;
22639   Dali::Actor result;
22640
22641   {
22642     try {
22643       result = Dali::Actor::New();
22644     } CALL_CATCH_EXCEPTION(0);
22645   }
22646
22647   jresult = new Dali::Actor((const Dali::Actor &)result);
22648   return jresult;
22649 }
22650
22651
22652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
22653   void * jresult ;
22654   Dali::BaseHandle arg1 ;
22655   Dali::BaseHandle *argp1 ;
22656   Dali::Actor result;
22657
22658   argp1 = (Dali::BaseHandle *)jarg1;
22659   if (!argp1) {
22660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22661     return 0;
22662   }
22663   arg1 = *argp1;
22664   {
22665     try {
22666       result = Dali::Actor::DownCast(arg1);
22667     } CALL_CATCH_EXCEPTION(0);
22668   }
22669
22670   jresult = new Dali::Actor((const Dali::Actor &)result);
22671   return jresult;
22672 }
22673
22674
22675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
22676   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22677
22678   arg1 = (Dali::Actor *)jarg1;
22679   {
22680     try {
22681       delete arg1;
22682     } CALL_CATCH_EXCEPTION();
22683   }
22684
22685 }
22686
22687
22688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
22689   void * jresult ;
22690   Dali::Actor *arg1 = 0 ;
22691   Dali::Actor *result = 0 ;
22692
22693   arg1 = (Dali::Actor *)jarg1;
22694   if (!arg1) {
22695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
22696     return 0;
22697   }
22698   {
22699     try {
22700       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
22701     } CALL_CATCH_EXCEPTION(0);
22702   }
22703
22704   jresult = (void *)result;
22705   return jresult;
22706 }
22707
22708
22709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
22710   void * jresult ;
22711   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22712   Dali::Actor *arg2 = 0 ;
22713   Dali::Actor *result = 0 ;
22714
22715   if (!jarg1) {
22716     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22717     return 0;
22718   }
22719
22720   if (!jarg2) {
22721     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg2 is null!");
22722     return 0;
22723   }
22724
22725   arg1 = (Dali::Actor *)jarg1;
22726   arg2 = (Dali::Actor *)jarg2;
22727   {
22728     try {
22729       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
22730     } CALL_CATCH_EXCEPTION(0);
22731   }
22732
22733   jresult = (void *)result;
22734   return jresult;
22735 }
22736
22737
22738 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
22739   char * jresult ;
22740   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22741   std::string *result = 0 ;
22742   std::string name = "";
22743
22744   if (!jarg1) {
22745     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22746     return 0;
22747   }
22748
22749   arg1 = (Dali::Actor *)jarg1;
22750   {
22751     try {
22752       name = ((Dali::Actor const *)arg1)->GetProperty< std::string >( Dali::Actor::Property::NAME );
22753       result = (std::string *) &name;
22754       jresult = SWIG_csharp_string_callback(result->c_str());
22755     } CALL_CATCH_EXCEPTION(0);
22756   }
22757   return jresult;
22758 }
22759
22760
22761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
22762   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22763   std::string *arg2 = 0 ;
22764
22765   if (!jarg1) {
22766     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22767     return ;
22768   }
22769
22770   arg1 = (Dali::Actor *)jarg1;
22771   if (!jarg2) {
22772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22773     return ;
22774   }
22775   std::string arg2_str(jarg2);
22776   arg2 = &arg2_str;
22777   {
22778     try {
22779       (arg1)->SetProperty( Dali::Actor::Property::NAME, (std::string const &)*arg2);
22780     } CALL_CATCH_EXCEPTION();
22781   }
22782
22783
22784   //argout typemap for const std::string&
22785
22786 }
22787
22788
22789 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
22790   unsigned int jresult ;
22791   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22792   unsigned int result;
22793
22794   arg1 = (Dali::Actor *)jarg1;
22795
22796   if(!arg1) {
22797     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
22798     return -1;
22799   }
22800
22801   {
22802     try {
22803       result = (unsigned int)((Dali::Actor const *)arg1)->GetProperty< int >( Actor::Property::ID );
22804     } CALL_CATCH_EXCEPTION(0);
22805   }
22806
22807   jresult = result;
22808   return jresult;
22809 }
22810
22811
22812 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
22813   bool jresult ;
22814   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22815   bool result;
22816
22817   if (!jarg1) {
22818     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22819     return 0;
22820   }
22821
22822   arg1 = (Dali::Actor *)jarg1;
22823   {
22824     try {
22825       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_ROOT );
22826     } CALL_CATCH_EXCEPTION(0);
22827   }
22828
22829   jresult = result;
22830   return jresult;
22831 }
22832
22833
22834 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
22835   bool jresult ;
22836   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22837   bool result;
22838
22839   if (!jarg1) {
22840     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22841     return 0;
22842   }
22843
22844   arg1 = (Dali::Actor *)jarg1;
22845   {
22846     try {
22847       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE );
22848     } CALL_CATCH_EXCEPTION(0);
22849   }
22850
22851   jresult = result;
22852   return jresult;
22853 }
22854
22855
22856 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
22857   bool jresult ;
22858   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22859   bool result;
22860
22861   if (!jarg1) {
22862     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22863     return 0;
22864   }
22865
22866   arg1 = (Dali::Actor *)jarg1;
22867   {
22868     try {
22869       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_LAYER );
22870     } CALL_CATCH_EXCEPTION(0);
22871   }
22872
22873   jresult = result;
22874   return jresult;
22875 }
22876
22877
22878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
22879   void * jresult ;
22880   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22881   Dali::Layer result;
22882
22883   if (!jarg1) {
22884     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22885     return 0;
22886   }
22887
22888   arg1 = (Dali::Actor *)jarg1;
22889   {
22890     try {
22891       result = (arg1)->GetLayer();
22892     } CALL_CATCH_EXCEPTION(0);
22893   }
22894
22895   jresult = new Dali::Layer((const Dali::Layer &)result);
22896   return jresult;
22897 }
22898
22899
22900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
22901   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22902   Dali::Actor arg2 ;
22903
22904   if (!jarg1) {
22905     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22906     return ;
22907   }
22908   if (!jarg2) {
22909     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg2 is null!");
22910     return ;
22911   }
22912
22913   arg1 = (Dali::Actor *)jarg1;
22914   arg2 = *((Dali::Actor *)jarg2);
22915   {
22916     try {
22917       (arg1)->Add(arg2);
22918     } CALL_CATCH_EXCEPTION();
22919   }
22920
22921 }
22922
22923
22924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
22925   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22926   Dali::Actor arg2 ;
22927
22928   if (!jarg1) {
22929     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22930     return ;
22931   }
22932   if (!jarg2) {
22933     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg2 is null!");
22934     return ;
22935   }
22936
22937   arg1 = (Dali::Actor *)jarg1;
22938   arg2 = *((Dali::Actor *)jarg2);
22939   {
22940     try {
22941       (arg1)->Remove(arg2);
22942     } CALL_CATCH_EXCEPTION();
22943   }
22944
22945 }
22946
22947
22948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
22949   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22950
22951   if (!jarg1) {
22952     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22953     return ;
22954   }
22955
22956   arg1 = (Dali::Actor *)jarg1;
22957   {
22958     try {
22959       (arg1)->Unparent();
22960     } CALL_CATCH_EXCEPTION();
22961   }
22962
22963 }
22964
22965
22966 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
22967   unsigned int jresult ;
22968   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22969   unsigned int result;
22970
22971   if (!jarg1) {
22972     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22973     return 0;
22974   }
22975
22976   arg1 = (Dali::Actor *)jarg1;
22977   {
22978     try {
22979       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
22980     } CALL_CATCH_EXCEPTION(0);
22981   }
22982
22983   jresult = result;
22984   return jresult;
22985 }
22986
22987
22988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
22989   void * jresult ;
22990   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22991   unsigned int arg2 ;
22992   Dali::Actor result;
22993
22994   if (!jarg1) {
22995     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
22996     return 0;
22997   }
22998
22999   arg1 = (Dali::Actor *)jarg1;
23000   arg2 = (unsigned int)jarg2;
23001   {
23002     try {
23003       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
23004     } CALL_CATCH_EXCEPTION(0);
23005   }
23006
23007   jresult = new Dali::Actor((const Dali::Actor &)result);
23008   return jresult;
23009 }
23010
23011
23012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
23013   void * jresult ;
23014   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23015   std::string *arg2 = 0 ;
23016   Dali::Actor result;
23017
23018   if (!jarg1) {
23019     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23020     return 0;
23021   }
23022
23023   arg1 = (Dali::Actor *)jarg1;
23024   if (!jarg2) {
23025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23026     return 0;
23027   }
23028   std::string arg2_str(jarg2);
23029   arg2 = &arg2_str;
23030   {
23031     try {
23032       result = (arg1)->FindChildByName((std::string const &)*arg2);
23033     } CALL_CATCH_EXCEPTION(0);
23034   }
23035
23036   jresult = new Dali::Actor((const Dali::Actor &)result);
23037
23038   //argout typemap for const std::string&
23039
23040   return jresult;
23041 }
23042
23043
23044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
23045   void * jresult ;
23046   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23047   unsigned int arg2 ;
23048   Dali::Actor result;
23049
23050   if (!jarg1) {
23051     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23052     return 0;
23053   }
23054
23055   arg1 = (Dali::Actor *)jarg1;
23056   arg2 = (unsigned int)jarg2;
23057   {
23058     try {
23059       result = (arg1)->FindChildById(arg2);
23060     } CALL_CATCH_EXCEPTION(0);
23061   }
23062
23063   jresult = new Dali::Actor((const Dali::Actor &)result);
23064   return jresult;
23065 }
23066
23067
23068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
23069   void * jresult ;
23070   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23071   Dali::Actor result;
23072
23073   if (!jarg1) {
23074     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23075     return 0;
23076   }
23077
23078   arg1 = (Dali::Actor *)jarg1;
23079   {
23080     try {
23081       result = ((Dali::Actor const *)arg1)->GetParent();
23082     } CALL_CATCH_EXCEPTION(0);
23083   }
23084
23085   jresult = new Dali::Actor((const Dali::Actor &)result);
23086   return jresult;
23087 }
23088
23089
23090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
23091   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23092   Dali::Vector3 *arg2 = 0 ;
23093
23094   if (!jarg1) {
23095     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23096     return ;
23097   }
23098
23099   arg1 = (Dali::Actor *)jarg1;
23100   arg2 = (Dali::Vector3 *)jarg2;
23101   if (!arg2) {
23102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23103     return ;
23104   }
23105   {
23106     try {
23107       (arg1)->SetProperty( Actor::Property::PARENT_ORIGIN,(Dali::Vector3 const &)*arg2);
23108     } CALL_CATCH_EXCEPTION();
23109   }
23110
23111 }
23112
23113
23114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
23115   void * jresult ;
23116   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23117   Dali::Vector3 result;
23118
23119   if (!jarg1) {
23120     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23121     return 0;
23122   }
23123
23124   arg1 = (Dali::Actor *)jarg1;
23125   {
23126     try {
23127       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN );
23128     } CALL_CATCH_EXCEPTION(0);
23129   }
23130
23131   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23132   return jresult;
23133 }
23134
23135
23136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
23137   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23138   Dali::Vector3 *arg2 = 0 ;
23139
23140   if (!jarg1) {
23141     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23142     return ;
23143   }
23144
23145   arg1 = (Dali::Actor *)jarg1;
23146   arg2 = (Dali::Vector3 *)jarg2;
23147   if (!arg2) {
23148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23149     return ;
23150   }
23151   {
23152     try {
23153       (arg1)->SetProperty( Actor::Property::ANCHOR_POINT,(Dali::Vector3 const &)*arg2);
23154     } CALL_CATCH_EXCEPTION();
23155   }
23156
23157 }
23158
23159
23160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
23161   void * jresult ;
23162   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23163   Dali::Vector3 result;
23164
23165   if (!jarg1) {
23166     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23167     return 0;
23168   }
23169
23170   arg1 = (Dali::Actor *)jarg1;
23171   {
23172     try {
23173       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
23174     } CALL_CATCH_EXCEPTION(0);
23175   }
23176
23177   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23178   return jresult;
23179 }
23180
23181
23182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
23183   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23184   float arg2 ;
23185   float arg3 ;
23186
23187   if (!jarg1) {
23188     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23189     return ;
23190   }
23191
23192   arg1 = (Dali::Actor *)jarg1;
23193   arg2 = (float)jarg2;
23194   arg3 = (float)jarg3;
23195   {
23196     try {
23197       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector2(arg2,arg3) );
23198     } CALL_CATCH_EXCEPTION();
23199   }
23200
23201 }
23202
23203
23204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
23205   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23206   float arg2 ;
23207   float arg3 ;
23208   float arg4 ;
23209
23210   if (!jarg1) {
23211     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23212     return ;
23213   }
23214
23215   arg1 = (Dali::Actor *)jarg1;
23216   arg2 = (float)jarg2;
23217   arg3 = (float)jarg3;
23218   arg4 = (float)jarg4;
23219   {
23220     try {
23221       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector3(arg2,arg3,arg4) );
23222     } CALL_CATCH_EXCEPTION();
23223   }
23224
23225 }
23226
23227
23228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
23229   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23230   Dali::Vector2 *arg2 = 0 ;
23231
23232   if (!jarg1) {
23233     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23234     return ;
23235   }
23236
23237   arg1 = (Dali::Actor *)jarg1;
23238   arg2 = (Dali::Vector2 *)jarg2;
23239   if (!arg2) {
23240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
23241     return ;
23242   }
23243   {
23244     try {
23245       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector2 const &)*arg2);
23246     } CALL_CATCH_EXCEPTION();
23247   }
23248
23249 }
23250
23251
23252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
23253   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23254   Dali::Vector3 *arg2 = 0 ;
23255
23256   if (!jarg1) {
23257     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23258     return ;
23259   }
23260
23261   arg1 = (Dali::Actor *)jarg1;
23262   arg2 = (Dali::Vector3 *)jarg2;
23263   if (!arg2) {
23264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23265     return ;
23266   }
23267   {
23268     try {
23269       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector3 const &)*arg2);
23270     } CALL_CATCH_EXCEPTION();
23271   }
23272
23273 }
23274
23275
23276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
23277   void * jresult ;
23278   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23279   Dali::Vector3 result;
23280
23281   if (!jarg1) {
23282     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23283     return 0;
23284   }
23285
23286   arg1 = (Dali::Actor *)jarg1;
23287   {
23288     try {
23289       result = ((Dali::Actor const *)arg1)->GetTargetSize();
23290     } CALL_CATCH_EXCEPTION(0);
23291   }
23292
23293   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23294   return jresult;
23295 }
23296
23297
23298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
23299   void * jresult ;
23300   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23301   Dali::Vector3 result;
23302
23303   if (!jarg1) {
23304     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23305     return 0;
23306   }
23307
23308   arg1 = (Dali::Actor *)jarg1;
23309   {
23310     try {
23311       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
23312     } CALL_CATCH_EXCEPTION(0);
23313   }
23314
23315   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23316   return jresult;
23317 }
23318
23319
23320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
23321   void * jresult ;
23322   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23323   Dali::Vector3 result;
23324
23325   if (!jarg1) {
23326     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23327     return 0;
23328   }
23329
23330   arg1 = (Dali::Actor *)jarg1;
23331   {
23332     try {
23333       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
23334     } CALL_CATCH_EXCEPTION(0);
23335   }
23336
23337   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23338   return jresult;
23339 }
23340
23341
23342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
23343   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23344   float arg2 ;
23345   float arg3 ;
23346
23347   if (!jarg1) {
23348     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23349     return ;
23350   }
23351
23352   arg1 = (Dali::Actor *)jarg1;
23353   arg2 = (float)jarg2;
23354   arg3 = (float)jarg3;
23355   {
23356     try {
23357       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector2( arg2, arg3 ) );
23358     } CALL_CATCH_EXCEPTION();
23359   }
23360
23361 }
23362
23363
23364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
23365   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23366   float arg2 ;
23367   float arg3 ;
23368   float arg4 ;
23369
23370   if (!jarg1) {
23371     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23372     return ;
23373   }
23374
23375   arg1 = (Dali::Actor *)jarg1;
23376   arg2 = (float)jarg2;
23377   arg3 = (float)jarg3;
23378   arg4 = (float)jarg4;
23379   {
23380     try {
23381       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector3( arg2, arg3, arg4 ) );
23382     } CALL_CATCH_EXCEPTION();
23383   }
23384
23385 }
23386
23387
23388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
23389   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23390   Dali::Vector3 *arg2 = 0 ;
23391
23392   if (!jarg1) {
23393     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23394     return ;
23395   }
23396
23397   arg1 = (Dali::Actor *)jarg1;
23398   arg2 = (Dali::Vector3 *)jarg2;
23399   if (!arg2) {
23400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23401     return ;
23402   }
23403   {
23404     try {
23405       (arg1)->SetProperty( Actor::Property::POSITION, (Dali::Vector3 const &)*arg2 );
23406     } CALL_CATCH_EXCEPTION();
23407   }
23408
23409 }
23410
23411
23412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
23413   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23414   float arg2 ;
23415
23416   if (!jarg1) {
23417     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23418     return ;
23419   }
23420
23421   arg1 = (Dali::Actor *)jarg1;
23422   arg2 = (float)jarg2;
23423   {
23424     try {
23425       (arg1)->SetProperty( Actor::Property::POSITION_X, (arg2) );
23426     } CALL_CATCH_EXCEPTION();
23427   }
23428
23429 }
23430
23431
23432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
23433   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23434   float arg2 ;
23435
23436   if (!jarg1) {
23437     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23438     return ;
23439   }
23440
23441   arg1 = (Dali::Actor *)jarg1;
23442   arg2 = (float)jarg2;
23443   {
23444     try {
23445       (arg1)->SetProperty( Actor::Property::POSITION_Y, arg2 );
23446     } CALL_CATCH_EXCEPTION();
23447   }
23448
23449 }
23450
23451
23452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
23453   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23454   float arg2 ;
23455
23456   if (!jarg1) {
23457     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23458     return ;
23459   }
23460
23461   arg1 = (Dali::Actor *)jarg1;
23462   arg2 = (float)jarg2;
23463   {
23464     try {
23465       (arg1)->SetProperty( Actor::Property::POSITION_Z, arg2 );
23466     } CALL_CATCH_EXCEPTION();
23467   }
23468
23469 }
23470
23471
23472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
23473   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23474   Dali::Vector3 *arg2 = 0 ;
23475
23476   if (!jarg1) {
23477     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23478     return ;
23479   }
23480
23481   arg1 = (Dali::Actor *)jarg1;
23482   arg2 = (Dali::Vector3 *)jarg2;
23483   if (!arg2) {
23484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23485     return ;
23486   }
23487   {
23488     try {
23489       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
23490     } CALL_CATCH_EXCEPTION();
23491   }
23492
23493 }
23494
23495
23496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
23497   void * jresult ;
23498   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23499   Dali::Vector3 result;
23500
23501   if (!jarg1) {
23502     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23503     return 0;
23504   }
23505
23506   arg1 = (Dali::Actor *)jarg1;
23507   {
23508     try {
23509       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
23510     } CALL_CATCH_EXCEPTION(0);
23511   }
23512
23513   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23514   return jresult;
23515 }
23516
23517
23518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
23519   void * jresult ;
23520   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23521   Dali::Vector3 result;
23522
23523   if (!jarg1) {
23524     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23525     return 0;
23526   }
23527
23528   arg1 = (Dali::Actor *)jarg1;
23529   {
23530     try {
23531       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION );
23532     } CALL_CATCH_EXCEPTION(0);
23533   }
23534
23535   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23536   return jresult;
23537 }
23538
23539
23540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, bool jarg2) {
23541   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23542   bool arg2 ;
23543
23544   if (!jarg1) {
23545     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23546     return ;
23547   }
23548
23549   arg1 = (Dali::Actor *)jarg1;
23550   arg2 = jarg2 ? true : false;
23551   {
23552     try {
23553       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
23554     } CALL_CATCH_EXCEPTION();
23555   }
23556
23557 }
23558
23559
23560 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
23561   bool jresult ;
23562   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23563   bool result;
23564
23565   if (!jarg1) {
23566     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23567     return 0;
23568   }
23569
23570   arg1 = (Dali::Actor *)jarg1;
23571   {
23572     try {
23573       result = (bool)((Dali::Actor const *)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
23574     } CALL_CATCH_EXCEPTION(0);
23575   }
23576
23577   jresult = result;
23578   return jresult;
23579 }
23580
23581
23582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
23583   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23584   Dali::Degree *arg2 = 0 ;
23585   Dali::Vector3 *arg3 = 0 ;
23586
23587   if (!jarg1) {
23588     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23589     return ;
23590   }
23591
23592   arg1 = (Dali::Actor *)jarg1;
23593   arg2 = (Dali::Degree *)jarg2;
23594   if (!arg2) {
23595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
23596     return ;
23597   }
23598   arg3 = (Dali::Vector3 *)jarg3;
23599   if (!arg3) {
23600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23601     return ;
23602   }
23603   {
23604     try {
23605       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
23606     } CALL_CATCH_EXCEPTION();
23607   }
23608
23609 }
23610
23611
23612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
23613   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23614   Dali::Radian *arg2 = 0 ;
23615   Dali::Vector3 *arg3 = 0 ;
23616
23617   if (!jarg1) {
23618     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23619     return ;
23620   }
23621
23622   arg1 = (Dali::Actor *)jarg1;
23623   arg2 = (Dali::Radian *)jarg2;
23624   if (!arg2) {
23625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
23626     return ;
23627   }
23628   arg3 = (Dali::Vector3 *)jarg3;
23629   if (!arg3) {
23630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23631     return ;
23632   }
23633   {
23634     try {
23635       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
23636     } CALL_CATCH_EXCEPTION();
23637   }
23638
23639 }
23640
23641
23642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
23643   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23644   Dali::Quaternion *arg2 = 0 ;
23645
23646   if (!jarg1) {
23647     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23648     return ;
23649   }
23650
23651   arg1 = (Dali::Actor *)jarg1;
23652   arg2 = (Dali::Quaternion *)jarg2;
23653   if (!arg2) {
23654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
23655     return ;
23656   }
23657   {
23658     try {
23659       (arg1)->SetProperty( Actor::Property::ORIENTATION, (Dali::Quaternion const &)*arg2 );
23660     } CALL_CATCH_EXCEPTION();
23661   }
23662
23663 }
23664
23665
23666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
23667   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23668   Dali::Degree *arg2 = 0 ;
23669   Dali::Vector3 *arg3 = 0 ;
23670
23671   if (!jarg1) {
23672     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23673     return ;
23674   }
23675
23676   arg1 = (Dali::Actor *)jarg1;
23677   arg2 = (Dali::Degree *)jarg2;
23678   if (!arg2) {
23679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
23680     return ;
23681   }
23682   arg3 = (Dali::Vector3 *)jarg3;
23683   if (!arg3) {
23684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23685     return ;
23686   }
23687   {
23688     try {
23689       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
23690     } CALL_CATCH_EXCEPTION();
23691   }
23692
23693 }
23694
23695
23696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
23697   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23698   Dali::Radian *arg2 = 0 ;
23699   Dali::Vector3 *arg3 = 0 ;
23700
23701   if (!jarg1) {
23702     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23703     return ;
23704   }
23705
23706   arg1 = (Dali::Actor *)jarg1;
23707   arg2 = (Dali::Radian *)jarg2;
23708   if (!arg2) {
23709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
23710     return ;
23711   }
23712   arg3 = (Dali::Vector3 *)jarg3;
23713   if (!arg3) {
23714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23715     return ;
23716   }
23717   {
23718     try {
23719       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
23720     } CALL_CATCH_EXCEPTION();
23721   }
23722
23723 }
23724
23725
23726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
23727   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23728   Dali::Quaternion *arg2 = 0 ;
23729
23730   if (!jarg1) {
23731     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23732     return ;
23733   }
23734
23735   arg1 = (Dali::Actor *)jarg1;
23736   arg2 = (Dali::Quaternion *)jarg2;
23737   if (!arg2) {
23738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
23739     return ;
23740   }
23741   {
23742     try {
23743       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
23744     } CALL_CATCH_EXCEPTION();
23745   }
23746
23747 }
23748
23749
23750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
23751   void * jresult ;
23752   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23753   Dali::Quaternion result;
23754
23755   if (!jarg1) {
23756     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23757     return 0;
23758   }
23759
23760   arg1 = (Dali::Actor *)jarg1;
23761   {
23762     try {
23763       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION );
23764     } CALL_CATCH_EXCEPTION(0);
23765   }
23766
23767   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
23768   return jresult;
23769 }
23770
23771
23772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, bool jarg2) {
23773   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23774   bool arg2 ;
23775
23776   if (!jarg1) {
23777     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23778     return ;
23779   }
23780
23781   arg1 = (Dali::Actor *)jarg1;
23782   arg2 = jarg2 ? true : false;
23783   {
23784     try {
23785       (arg1)->SetProperty( Actor::Property::INHERIT_ORIENTATION,arg2);
23786     } CALL_CATCH_EXCEPTION();
23787   }
23788
23789 }
23790
23791
23792 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
23793   bool jresult ;
23794   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23795   bool result;
23796
23797   if (!jarg1) {
23798     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23799     return 0;
23800   }
23801
23802   arg1 = (Dali::Actor *)jarg1;
23803   {
23804     try {
23805       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION );
23806     } CALL_CATCH_EXCEPTION(0);
23807   }
23808
23809   jresult = result;
23810   return jresult;
23811 }
23812
23813
23814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
23815   void * jresult ;
23816   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23817   Dali::Quaternion result;
23818
23819   if (!jarg1) {
23820     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23821     return 0;
23822   }
23823
23824   arg1 = (Dali::Actor *)jarg1;
23825   {
23826     try {
23827       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION );
23828     } CALL_CATCH_EXCEPTION(0);
23829   }
23830
23831   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
23832   return jresult;
23833 }
23834
23835
23836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
23837   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23838   float arg2 ;
23839
23840   if (!jarg1) {
23841     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23842     return ;
23843   }
23844
23845   arg1 = (Dali::Actor *)jarg1;
23846   arg2 = (float)jarg2;
23847   {
23848     try {
23849       (arg1)->SetProperty( Actor::Property::SCALE, arg2);
23850     } CALL_CATCH_EXCEPTION();
23851   }
23852
23853 }
23854
23855
23856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
23857   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23858   float arg2 ;
23859   float arg3 ;
23860   float arg4 ;
23861
23862   if (!jarg1) {
23863     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23864     return ;
23865   }
23866
23867   arg1 = (Dali::Actor *)jarg1;
23868   arg2 = (float)jarg2;
23869   arg3 = (float)jarg3;
23870   arg4 = (float)jarg4;
23871   {
23872     try {
23873       (arg1)->SetProperty( Actor::Property::SCALE, Vector3( arg2, arg3, arg4 ) );
23874     } CALL_CATCH_EXCEPTION();
23875   }
23876
23877 }
23878
23879
23880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
23881   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23882   Dali::Vector3 *arg2 = 0 ;
23883
23884   if (!jarg1) {
23885     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23886     return ;
23887   }
23888
23889   arg1 = (Dali::Actor *)jarg1;
23890   arg2 = (Dali::Vector3 *)jarg2;
23891   if (!arg2) {
23892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23893     return ;
23894   }
23895   {
23896     try {
23897       (arg1)->SetProperty( Actor::Property::SCALE, (Dali::Vector3 const &)*arg2 );
23898     } CALL_CATCH_EXCEPTION();
23899   }
23900
23901 }
23902
23903
23904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
23905   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23906   Dali::Vector3 *arg2 = 0 ;
23907
23908   if (!jarg1) {
23909     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23910     return ;
23911   }
23912
23913   arg1 = (Dali::Actor *)jarg1;
23914   arg2 = (Dali::Vector3 *)jarg2;
23915   if (!arg2) {
23916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23917     return ;
23918   }
23919   {
23920     try {
23921       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
23922     } CALL_CATCH_EXCEPTION();
23923   }
23924
23925 }
23926
23927
23928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
23929   void * jresult ;
23930   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23931   Dali::Vector3 result;
23932
23933   if (!jarg1) {
23934     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23935     return 0;
23936   }
23937
23938   arg1 = (Dali::Actor *)jarg1;
23939   {
23940     try {
23941       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
23942     } CALL_CATCH_EXCEPTION(0);
23943   }
23944
23945   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23946   return jresult;
23947 }
23948
23949
23950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
23951   void * jresult ;
23952   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23953   Dali::Vector3 result;
23954
23955   if (!jarg1) {
23956     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23957     return 0;
23958   }
23959
23960   arg1 = (Dali::Actor *)jarg1;
23961   {
23962     try {
23963       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE );
23964     } CALL_CATCH_EXCEPTION(0);
23965   }
23966
23967   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23968   return jresult;
23969 }
23970
23971
23972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, bool jarg2) {
23973   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23974   bool arg2 ;
23975
23976   if (!jarg1) {
23977     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23978     return ;
23979   }
23980
23981   arg1 = (Dali::Actor *)jarg1;
23982   arg2 = jarg2 ? true : false;
23983   {
23984     try {
23985       (arg1)->SetProperty( Actor::Property::INHERIT_SCALE,arg2);
23986     } CALL_CATCH_EXCEPTION();
23987   }
23988
23989 }
23990
23991
23992 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
23993   bool jresult ;
23994   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23995   bool result;
23996
23997   if (!jarg1) {
23998     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23999     return 0;
24000   }
24001
24002   arg1 = (Dali::Actor *)jarg1;
24003   {
24004     try {
24005       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_SCALE );
24006     } CALL_CATCH_EXCEPTION(0);
24007   }
24008
24009   jresult = result;
24010   return jresult;
24011 }
24012
24013
24014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
24015   void * jresult ;
24016   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24017   Dali::Matrix result;
24018
24019   if (!jarg1) {
24020     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24021     return 0;
24022   }
24023
24024   arg1 = (Dali::Actor *)jarg1;
24025   {
24026     try {
24027       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
24028     } CALL_CATCH_EXCEPTION(0);
24029   }
24030
24031   jresult = new Dali::Matrix((const Dali::Matrix &)result);
24032   return jresult;
24033 }
24034
24035
24036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, bool jarg2) {
24037   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24038   bool arg2 ;
24039
24040   if (!jarg1) {
24041     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24042     return ;
24043   }
24044
24045   arg1 = (Dali::Actor *)jarg1;
24046   arg2 = jarg2 ? true : false;
24047   {
24048     try {
24049       (arg1)->SetProperty( Actor::Property::VISIBLE,arg2);
24050     } CALL_CATCH_EXCEPTION();
24051   }
24052
24053 }
24054
24055
24056 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
24057   bool jresult ;
24058   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24059   bool result;
24060
24061   if (!jarg1) {
24062     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24063     return 0;
24064   }
24065
24066   arg1 = (Dali::Actor *)jarg1;
24067   {
24068     try {
24069       result = (bool)((Dali::Actor const *)arg1)->GetCurrentProperty< bool >( Actor::Property::VISIBLE );
24070     } CALL_CATCH_EXCEPTION(0);
24071   }
24072
24073   jresult = result;
24074   return jresult;
24075 }
24076
24077
24078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
24079   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24080   float arg2 ;
24081
24082   if (!jarg1) {
24083     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24084     return ;
24085   }
24086
24087   arg1 = (Dali::Actor *)jarg1;
24088   arg2 = (float)jarg2;
24089   {
24090     try {
24091       (arg1)->SetProperty( Actor::Property::OPACITY,arg2);
24092     } CALL_CATCH_EXCEPTION();
24093   }
24094
24095 }
24096
24097
24098 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
24099   float jresult ;
24100   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24101   float result;
24102
24103   if (!jarg1) {
24104     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24105     return 0;
24106   }
24107
24108   arg1 = (Dali::Actor *)jarg1;
24109   {
24110     try {
24111       result = (float)((Dali::Actor const *)arg1)->GetCurrentProperty< float >( Actor::Property::OPACITY );
24112     } CALL_CATCH_EXCEPTION(0);
24113   }
24114
24115   jresult = result;
24116   return jresult;
24117 }
24118
24119
24120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
24121   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24122   Dali::Vector4 *arg2 = 0 ;
24123
24124   if (!jarg1) {
24125     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24126     return ;
24127   }
24128
24129   arg1 = (Dali::Actor *)jarg1;
24130   arg2 = (Dali::Vector4 *)jarg2;
24131   if (!arg2) {
24132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
24133     return ;
24134   }
24135   {
24136     try {
24137       (arg1)->SetProperty( Actor::Property::COLOR,(Dali::Vector4 const &)*arg2);
24138     } CALL_CATCH_EXCEPTION();
24139   }
24140
24141 }
24142
24143
24144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
24145   void * jresult ;
24146   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24147   Dali::Vector4 result;
24148
24149   if (!jarg1) {
24150     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24151     return 0;
24152   }
24153
24154   arg1 = (Dali::Actor *)jarg1;
24155   {
24156     try {
24157       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::COLOR );
24158     } CALL_CATCH_EXCEPTION(0);
24159   }
24160
24161   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
24162   return jresult;
24163 }
24164
24165
24166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
24167   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24168   Dali::ColorMode arg2 ;
24169
24170   if (!jarg1) {
24171     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24172     return ;
24173   }
24174
24175   arg1 = (Dali::Actor *)jarg1;
24176   arg2 = (Dali::ColorMode)jarg2;
24177   {
24178     try {
24179       (arg1)->SetProperty( Actor::Property::COLOR_MODE,arg2);
24180     } CALL_CATCH_EXCEPTION();
24181   }
24182
24183 }
24184
24185
24186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
24187   int jresult ;
24188   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24189   Dali::ColorMode result;
24190
24191   if (!jarg1) {
24192     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24193     return 0;
24194   }
24195
24196   arg1 = (Dali::Actor *)jarg1;
24197   {
24198     try {
24199       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetProperty< ColorMode >( Actor::Property::COLOR_MODE );
24200     } CALL_CATCH_EXCEPTION(0);
24201   }
24202
24203   jresult = (int)result;
24204   return jresult;
24205 }
24206
24207
24208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
24209   void * jresult ;
24210   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24211   Dali::Vector4 result;
24212
24213   if (!jarg1) {
24214     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24215     return 0;
24216   }
24217
24218   arg1 = (Dali::Actor *)jarg1;
24219   {
24220     try {
24221       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR );
24222     } CALL_CATCH_EXCEPTION(0);
24223   }
24224
24225   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
24226   return jresult;
24227 }
24228
24229
24230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
24231   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24232   Dali::DrawMode::Type arg2 ;
24233
24234   if (!jarg1) {
24235     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24236     return ;
24237   }
24238
24239   arg1 = (Dali::Actor *)jarg1;
24240   arg2 = (Dali::DrawMode::Type)jarg2;
24241   {
24242     try {
24243       (arg1)->SetProperty( Actor::Property::DRAW_MODE,arg2);
24244     } CALL_CATCH_EXCEPTION();
24245   }
24246
24247 }
24248
24249
24250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
24251   int jresult ;
24252   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24253   Dali::DrawMode::Type result;
24254
24255   if (!jarg1) {
24256     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24257     return 0;
24258   }
24259
24260   arg1 = (Dali::Actor *)jarg1;
24261   {
24262     try {
24263       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE );
24264     } CALL_CATCH_EXCEPTION(0);
24265   }
24266
24267   jresult = (int)result;
24268   return jresult;
24269 }
24270
24271
24272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, bool jarg2) {
24273   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24274   bool arg2 ;
24275
24276   if (!jarg1) {
24277     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24278     return ;
24279   }
24280
24281   arg1 = (Dali::Actor *)jarg1;
24282   arg2 = jarg2 ? true : false;
24283   {
24284     try {
24285       (arg1)->SetProperty( Actor::Property::SENSITIVE,arg2);
24286     } CALL_CATCH_EXCEPTION();
24287   }
24288
24289 }
24290
24291
24292 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
24293   bool jresult ;
24294   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24295   bool result;
24296
24297   if (!jarg1) {
24298     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24299     return 0;
24300   }
24301
24302   arg1 = (Dali::Actor *)jarg1;
24303   {
24304     try {
24305       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::SENSITIVE );
24306     } CALL_CATCH_EXCEPTION(0);
24307   }
24308
24309   jresult = result;
24310   return jresult;
24311 }
24312
24313
24314 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
24315   bool jresult ;
24316   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24317   float *arg2 = 0 ;
24318   float *arg3 = 0 ;
24319   float arg4 ;
24320   float arg5 ;
24321   bool result;
24322
24323   if (!jarg1) {
24324     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24325     return 0;
24326   }
24327
24328   arg1 = (Dali::Actor *)jarg1;
24329   arg2 = (float *)jarg2;
24330   arg3 = (float *)jarg3;
24331   arg4 = (float)jarg4;
24332   arg5 = (float)jarg5;
24333   {
24334     try {
24335       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
24336     } CALL_CATCH_EXCEPTION(0);
24337   }
24338
24339   jresult = result;
24340   return jresult;
24341 }
24342
24343
24344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, bool jarg2) {
24345   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24346   bool arg2 ;
24347
24348   if (!jarg1) {
24349     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24350     return ;
24351   }
24352
24353   arg1 = (Dali::Actor *)jarg1;
24354   arg2 = jarg2 ? true : false;
24355   {
24356     try {
24357       (arg1)->SetProperty( Actor::Property::LEAVE_REQUIRED,arg2);
24358     } CALL_CATCH_EXCEPTION();
24359   }
24360
24361 }
24362
24363
24364 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
24365   bool jresult ;
24366   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24367   bool result;
24368
24369   if (!jarg1) {
24370     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24371     return 0;
24372   }
24373
24374   arg1 = (Dali::Actor *)jarg1;
24375   {
24376     try {
24377       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::LEAVE_REQUIRED );
24378     } CALL_CATCH_EXCEPTION(0);
24379   }
24380
24381   jresult = result;
24382   return jresult;
24383 }
24384
24385
24386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, bool jarg2) {
24387   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24388   bool arg2 ;
24389
24390   if (!jarg1) {
24391     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24392     return ;
24393   }
24394
24395   arg1 = (Dali::Actor *)jarg1;
24396   arg2 = jarg2 ? true : false;
24397   {
24398     try {
24399       (arg1)->SetProperty( Actor::Property::KEYBOARD_FOCUSABLE, arg2 );
24400     } CALL_CATCH_EXCEPTION();
24401   }
24402
24403 }
24404
24405
24406 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
24407   bool jresult ;
24408   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24409   bool result;
24410
24411   if (!jarg1) {
24412     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24413     return 0;
24414   }
24415
24416   arg1 = (Dali::Actor *)jarg1;
24417   {
24418     try {
24419       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE );
24420     } CALL_CATCH_EXCEPTION(0);
24421   }
24422
24423   jresult = result;
24424   return jresult;
24425 }
24426
24427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusableChildren(void * actor, bool keyboardFocusableChildren) {
24428   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24429
24430   if (!actor) {
24431     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!");
24432     return ;
24433   }
24434
24435   arg1 = (Dali::Actor *)actor;
24436   {
24437     try {
24438       (arg1)->SetProperty( DevelActor::Property::KEYBOARD_FOCUSABLE_CHILDREN, keyboardFocusableChildren );
24439     } CALL_CATCH_EXCEPTION();
24440   }
24441 }
24442
24443
24444 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_AreChildrenKeyBoardFocusable(void * actor) {
24445   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24446   bool result;
24447
24448   if (!actor) {
24449     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!");
24450     return 0;
24451   }
24452
24453   arg1 = (Dali::Actor *)actor;
24454   {
24455     try {
24456       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( DevelActor::Property::KEYBOARD_FOCUSABLE_CHILDREN );
24457     } CALL_CATCH_EXCEPTION(0);
24458   }
24459   return result;
24460 }
24461
24462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetTouchFocusable(void * jarg1, bool jarg2) {
24463   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24464   bool arg2 ;
24465
24466   if (!jarg1) {
24467     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24468     return ;
24469   }
24470
24471   arg1 = (Dali::Actor *)jarg1;
24472   arg2 = jarg2 ? true : false;
24473   {
24474     try {
24475       (arg1)->SetProperty( DevelActor::Property::TOUCH_FOCUSABLE, arg2 );
24476     } CALL_CATCH_EXCEPTION();
24477   }
24478
24479 }
24480
24481
24482 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsTouchFocusable(void * jarg1) {
24483   bool jresult ;
24484   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24485   bool result;
24486
24487   if (!jarg1) {
24488     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24489     return 0;
24490   }
24491
24492   arg1 = (Dali::Actor *)jarg1;
24493   {
24494     try {
24495       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( DevelActor::Property::TOUCH_FOCUSABLE );
24496     } CALL_CATCH_EXCEPTION(0);
24497   }
24498
24499   jresult = result;
24500   return jresult;
24501 }
24502
24503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
24504   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24505   Dali::ResizePolicy::Type arg2 ;
24506   Dali::Dimension::Type arg3 ;
24507
24508   if (!jarg1) {
24509     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24510     return ;
24511   }
24512
24513   arg1 = (Dali::Actor *)jarg1;
24514   arg2 = (Dali::ResizePolicy::Type)jarg2;
24515   arg3 = (Dali::Dimension::Type)jarg3;
24516   {
24517     try {
24518       (arg1)->SetResizePolicy(arg2,arg3);
24519     } CALL_CATCH_EXCEPTION();
24520   }
24521
24522 }
24523
24524
24525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
24526   int jresult ;
24527   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24528   Dali::Dimension::Type arg2 ;
24529   Dali::ResizePolicy::Type result;
24530
24531   if (!jarg1) {
24532     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24533     return 0;
24534   }
24535
24536   arg1 = (Dali::Actor *)jarg1;
24537   arg2 = (Dali::Dimension::Type)jarg2;
24538   {
24539     try {
24540       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
24541     } CALL_CATCH_EXCEPTION(0);
24542   }
24543
24544   jresult = (int)result;
24545   return jresult;
24546 }
24547
24548
24549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
24550   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24551   Dali::SizeScalePolicy::Type arg2 ;
24552
24553   if (!jarg1) {
24554     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24555     return ;
24556   }
24557
24558   arg1 = (Dali::Actor *)jarg1;
24559   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
24560   {
24561     try {
24562       (arg1)->SetProperty( Actor::Property::SIZE_SCALE_POLICY,arg2);
24563     } CALL_CATCH_EXCEPTION();
24564   }
24565
24566 }
24567
24568
24569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
24570   int jresult ;
24571   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24572   Dali::SizeScalePolicy::Type result;
24573
24574   if (!jarg1) {
24575     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24576     return 0;
24577   }
24578
24579   arg1 = (Dali::Actor *)jarg1;
24580   {
24581     try {
24582       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY );
24583     } CALL_CATCH_EXCEPTION(0);
24584   }
24585
24586   jresult = (int)result;
24587   return jresult;
24588 }
24589
24590
24591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
24592   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24593   Dali::Vector3 *arg2 = 0 ;
24594
24595   if (!jarg1) {
24596     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24597     return ;
24598   }
24599
24600   arg1 = (Dali::Actor *)jarg1;
24601   arg2 = (Dali::Vector3 *)jarg2;
24602   if (!arg2) {
24603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
24604     return ;
24605   }
24606   {
24607     try {
24608       (arg1)->SetProperty( Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const &)*arg2);
24609     } CALL_CATCH_EXCEPTION();
24610   }
24611
24612 }
24613
24614
24615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
24616   void * jresult ;
24617   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24618   Dali::Vector3 result;
24619
24620   if (!jarg1) {
24621     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24622     return 0;
24623   }
24624
24625   arg1 = (Dali::Actor *)jarg1;
24626   {
24627     try {
24628       result = ((Dali::Actor const *)arg1)->GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR );
24629     } CALL_CATCH_EXCEPTION(0);
24630   }
24631
24632   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
24633   return jresult;
24634 }
24635
24636
24637 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
24638   float jresult ;
24639   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24640   float arg2 ;
24641   float result;
24642
24643   if (!jarg1) {
24644     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24645     return 0;
24646   }
24647
24648   arg1 = (Dali::Actor *)jarg1;
24649   arg2 = (float)jarg2;
24650   {
24651     try {
24652       result = (float)(arg1)->GetHeightForWidth(arg2);
24653     } CALL_CATCH_EXCEPTION(0);
24654   }
24655
24656   jresult = result;
24657   return jresult;
24658 }
24659
24660
24661 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
24662   float jresult ;
24663   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24664   float arg2 ;
24665   float result;
24666
24667   if (!jarg1) {
24668     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24669     return 0;
24670   }
24671
24672   arg1 = (Dali::Actor *)jarg1;
24673   arg2 = (float)jarg2;
24674   {
24675     try {
24676       result = (float)(arg1)->GetWidthForHeight(arg2);
24677     } CALL_CATCH_EXCEPTION(0);
24678   }
24679
24680   jresult = result;
24681   return jresult;
24682 }
24683
24684
24685 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
24686   float jresult ;
24687   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24688   Dali::Dimension::Type arg2 ;
24689   float result;
24690
24691   if (!jarg1) {
24692     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24693     return 0;
24694   }
24695
24696   arg1 = (Dali::Actor *)jarg1;
24697   arg2 = (Dali::Dimension::Type)jarg2;
24698   {
24699     try {
24700       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
24701     } CALL_CATCH_EXCEPTION(0);
24702   }
24703
24704   jresult = result;
24705   return jresult;
24706 }
24707
24708
24709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
24710   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24711   Dali::Padding *arg2 = 0 ;
24712
24713   if (!jarg1) {
24714     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24715     return ;
24716   }
24717
24718   arg1 = (Dali::Actor *)jarg1;
24719   arg2 = (Dali::Padding *)jarg2;
24720   if (!arg2) {
24721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
24722     return ;
24723   }
24724   {
24725     try {
24726       (arg1)->SetProperty( Actor::Property::PADDING, (Dali::Padding const &)*arg2);
24727     } CALL_CATCH_EXCEPTION();
24728   }
24729
24730 }
24731
24732
24733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
24734   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24735   Dali::Padding *arg2 = 0 ;
24736
24737   if (!jarg1) {
24738     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24739     return ;
24740   }
24741
24742   arg1 = (Dali::Actor *)jarg1;
24743   arg2 = (Dali::Padding *)jarg2;
24744   if (!arg2) {
24745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
24746     return ;
24747   }
24748   {
24749     try {
24750       *arg2 = ((Dali::Actor const *)arg1)->GetProperty<Vector4>( Actor::Property::PADDING );
24751     } CALL_CATCH_EXCEPTION();
24752   }
24753
24754 }
24755
24756
24757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
24758   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24759   Dali::Vector2 *arg2 = 0 ;
24760
24761   if (!jarg1) {
24762     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24763     return ;
24764   }
24765
24766   arg1 = (Dali::Actor *)jarg1;
24767   arg2 = (Dali::Vector2 *)jarg2;
24768   if (!arg2) {
24769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
24770     return ;
24771   }
24772   {
24773     try {
24774       (arg1)->SetProperty( Actor::Property::MINIMUM_SIZE,(Dali::Vector2 const &)*arg2);
24775     } CALL_CATCH_EXCEPTION();
24776   }
24777
24778 }
24779
24780
24781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
24782   void * jresult ;
24783   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24784   Dali::Vector2 result;
24785
24786   if (!jarg1) {
24787     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24788     return 0;
24789   }
24790
24791   arg1 = (Dali::Actor *)jarg1;
24792   {
24793     try {
24794       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
24795     } CALL_CATCH_EXCEPTION(0);
24796   }
24797
24798   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
24799   return jresult;
24800 }
24801
24802
24803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
24804   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24805   Dali::Vector2 *arg2 = 0 ;
24806
24807   if (!jarg1) {
24808     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24809     return ;
24810   }
24811
24812   arg1 = (Dali::Actor *)jarg1;
24813   arg2 = (Dali::Vector2 *)jarg2;
24814   if (!arg2) {
24815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
24816     return ;
24817   }
24818   {
24819     try {
24820       (arg1)->SetProperty( Actor::Property::MAXIMUM_SIZE,(Dali::Vector2 const &)*arg2);
24821     } CALL_CATCH_EXCEPTION();
24822   }
24823
24824 }
24825
24826
24827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
24828   void * jresult ;
24829   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24830   Dali::Vector2 result;
24831
24832   if (!jarg1) {
24833     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24834     return 0;
24835   }
24836
24837   arg1 = (Dali::Actor *)jarg1;
24838   {
24839     try {
24840       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
24841     } CALL_CATCH_EXCEPTION(0);
24842   }
24843
24844   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
24845   return jresult;
24846 }
24847
24848
24849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
24850   int jresult ;
24851   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24852   int result;
24853
24854   if (!jarg1) {
24855     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24856     return 0;
24857   }
24858
24859   arg1 = (Dali::Actor *)jarg1;
24860   {
24861     try {
24862       result = (int)(arg1)->GetProperty< int >( Actor::Property::HIERARCHY_DEPTH );
24863       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
24864     } CALL_CATCH_EXCEPTION(0);
24865   }
24866
24867   jresult = result;
24868   return jresult;
24869 }
24870
24871
24872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
24873   unsigned int jresult ;
24874   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24875   Dali::Renderer *arg2 = 0 ;
24876   unsigned int result;
24877
24878   if (!jarg1) {
24879     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24880     return 0;
24881   }
24882
24883   arg1 = (Dali::Actor *)jarg1;
24884   arg2 = (Dali::Renderer *)jarg2;
24885   if (!arg2) {
24886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
24887     return 0;
24888   }
24889   {
24890     try {
24891       result = (unsigned int)(arg1)->AddRenderer(*arg2);
24892     } CALL_CATCH_EXCEPTION(0);
24893   }
24894
24895   jresult = result;
24896   return jresult;
24897 }
24898
24899
24900 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
24901   unsigned int jresult ;
24902   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24903   unsigned int result;
24904
24905   if (!jarg1) {
24906     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24907     return 0;
24908   }
24909
24910   arg1 = (Dali::Actor *)jarg1;
24911   {
24912     try {
24913       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
24914     } CALL_CATCH_EXCEPTION(0);
24915   }
24916
24917   jresult = result;
24918   return jresult;
24919 }
24920
24921
24922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
24923   void * jresult ;
24924   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24925   unsigned int arg2 ;
24926   Dali::Renderer result;
24927
24928   if (!jarg1) {
24929     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24930     return 0;
24931   }
24932
24933   arg1 = (Dali::Actor *)jarg1;
24934   arg2 = (unsigned int)jarg2;
24935   {
24936     try {
24937       result = (arg1)->GetRendererAt(arg2);
24938     } CALL_CATCH_EXCEPTION(0);
24939   }
24940
24941   jresult = new Dali::Renderer((const Dali::Renderer &)result);
24942   return jresult;
24943 }
24944
24945
24946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
24947   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24948   Dali::Renderer *arg2 = 0 ;
24949
24950   if (!jarg1) {
24951     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24952     return ;
24953   }
24954
24955   arg1 = (Dali::Actor *)jarg1;
24956   arg2 = (Dali::Renderer *)jarg2;
24957   if (!arg2) {
24958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
24959     return ;
24960   }
24961   {
24962     try {
24963       (arg1)->RemoveRenderer(*arg2);
24964     } CALL_CATCH_EXCEPTION();
24965   }
24966
24967 }
24968
24969
24970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
24971   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24972   unsigned int arg2 ;
24973
24974   if (!jarg1) {
24975     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24976     return ;
24977   }
24978
24979   arg1 = (Dali::Actor *)jarg1;
24980   arg2 = (unsigned int)jarg2;
24981   {
24982     try {
24983       (arg1)->RemoveRenderer(arg2);
24984     } CALL_CATCH_EXCEPTION();
24985   }
24986
24987 }
24988
24989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HitTestResultSignal(void * jarg1) {
24990   void * jresult ;
24991   Dali::Actor arg1 ;
24992   Dali::Actor *argp1 = (Dali::Actor *) 0 ;
24993   Dali::Actor::TouchEventSignalType *result = 0 ;
24994
24995
24996   argp1 = (Dali::Actor *)jarg1;
24997   if (!argp1) {
24998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24999     return 0;
25000   }
25001   arg1 = *argp1;
25002   {
25003     try {
25004       result = (Dali::Actor::TouchEventSignalType *) &Dali::DevelActor::HitTestResultSignal(arg1);
25005     } CALL_CATCH_EXCEPTION(0);
25006   }
25007
25008   jresult = (void *)result;
25009   return jresult;
25010 }
25011
25012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_InterceptTouchSignal(void * jarg1) {
25013   void * jresult ;
25014   Dali::Actor arg1 ;
25015   Dali::Actor *argp1 = (Dali::Actor *) 0 ;
25016   Dali::Actor::TouchEventSignalType *result = 0 ;
25017
25018
25019   argp1 = (Dali::Actor *)jarg1;
25020   if (!argp1) {
25021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25022     return 0;
25023   }
25024   arg1 = *argp1;
25025   {
25026     try {
25027       result = (Dali::Actor::TouchEventSignalType *) &Dali::DevelActor::InterceptTouchedSignal(arg1);
25028     } CALL_CATCH_EXCEPTION(0);
25029   }
25030
25031   jresult = (void *)result;
25032   return jresult;
25033 }
25034
25035
25036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
25037   void * jresult ;
25038   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25039   Dali::Actor::TouchEventSignalType *result = 0 ;
25040
25041   if (!jarg1) {
25042     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25043     return 0;
25044   }
25045
25046   arg1 = (Dali::Actor *)jarg1;
25047   {
25048     try {
25049       result = (Dali::Actor::TouchEventSignalType *) &(arg1)->TouchedSignal();
25050     } CALL_CATCH_EXCEPTION(0);
25051   }
25052
25053   jresult = (void *)result;
25054   return jresult;
25055 }
25056
25057
25058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
25059   void * jresult ;
25060   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25061   Dali::Actor::HoverSignalType *result = 0 ;
25062
25063   if (!jarg1) {
25064     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25065     return 0;
25066   }
25067
25068   arg1 = (Dali::Actor *)jarg1;
25069   {
25070     try {
25071       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
25072     } CALL_CATCH_EXCEPTION(0);
25073   }
25074
25075   jresult = (void *)result;
25076   return jresult;
25077 }
25078
25079
25080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
25081   void * jresult ;
25082   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25083   Dali::Actor::WheelEventSignalType *result = 0 ;
25084
25085   if (!jarg1) {
25086     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25087     return 0;
25088   }
25089
25090   arg1 = (Dali::Actor *)jarg1;
25091   {
25092     try {
25093       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
25094     } CALL_CATCH_EXCEPTION(0);
25095   }
25096
25097   jresult = (void *)result;
25098   return jresult;
25099 }
25100
25101
25102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnSceneSignal(void * jarg1) {
25103   void * jresult ;
25104   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25105   Dali::Actor::OnSceneSignalType *result = 0 ;
25106
25107   if (!jarg1) {
25108     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25109     return 0;
25110   }
25111
25112   arg1 = (Dali::Actor *)jarg1;
25113   {
25114     try {
25115       result = (Dali::Actor::OnSceneSignalType *) &(arg1)->OnSceneSignal();
25116     } CALL_CATCH_EXCEPTION(0);
25117   }
25118
25119   jresult = (void *)result;
25120   return jresult;
25121 }
25122
25123
25124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffSceneSignal(void * jarg1) {
25125   void * jresult ;
25126   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25127   Dali::Actor::OffSceneSignalType *result = 0 ;
25128
25129   if (!jarg1) {
25130     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25131     return 0;
25132   }
25133
25134   arg1 = (Dali::Actor *)jarg1;
25135   {
25136     try {
25137       result = (Dali::Actor::OffSceneSignalType *) &(arg1)->OffSceneSignal();
25138     } CALL_CATCH_EXCEPTION(0);
25139   }
25140
25141   jresult = (void *)result;
25142   return jresult;
25143 }
25144
25145
25146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
25147   void * jresult ;
25148   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25149   Dali::Actor::OnRelayoutSignalType *result = 0 ;
25150
25151   if (!jarg1) {
25152     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25153     return 0;
25154   }
25155
25156   arg1 = (Dali::Actor *)jarg1;
25157   {
25158     try {
25159       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
25160     } CALL_CATCH_EXCEPTION(0);
25161   }
25162
25163   jresult = (void *)result;
25164   return jresult;
25165 }
25166
25167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetNeedGesturePropagation(void * jarg1, bool jarg2) {
25168   Dali::Actor arg1 ;
25169   bool arg2;
25170   Dali::Actor *argp1 = (Dali::Actor *) 0 ;
25171
25172
25173   argp1 = (Dali::Actor *)jarg1;
25174   if (!argp1) {
25175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25176     return;
25177   }
25178   arg1 = *argp1;
25179   arg2 = jarg2;
25180   {
25181     try {
25182       Dali::DevelActor::SetNeedGesturePropagation(arg1, arg2);
25183     } CALL_CATCH_EXCEPTION();
25184   }
25185   return;
25186 }
25187
25188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_CalculateScreenExtents(void * actor) {
25189   Dali::Actor arg1 ;
25190   Dali::Actor *argp1 = (Dali::Actor *) 0 ;
25191   Dali::Rect<float> result;
25192
25193   argp1 = (Dali::Actor *)actor;
25194   if (!argp1) {
25195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25196     return 0;
25197   }
25198   arg1 = *argp1;
25199   {
25200     try {
25201       result = Dali::DevelActor::CalculateScreenExtents(arg1);
25202     } CALL_CATCH_EXCEPTION(0);
25203   }
25204
25205   // Note: The float type Rectangle class is not ready yet.
25206   //      Therefore, it transmits data in Vector4 class.
25207   //      This type should later be changed to the appropriate data type.
25208   return new Dali::Vector4(result.x, result.y, result.width, result.height);
25209 }
25210
25211
25212 SWIGEXPORT void SWIGSTDCALL CSharp_DevelActor_Property_SetTouchAreaOffset(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
25213   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25214   arg1 = (Dali::Actor *)jarg1;
25215   Rect<int> arg2 = Rect(jarg2, jarg3, jarg4, jarg5);
25216   {
25217     try {
25218       (arg1)->SetProperty( Dali::DevelActor::Property::TOUCH_AREA_OFFSET, arg2 );
25219     } CALL_CATCH_EXCEPTION();
25220   }
25221 }
25222
25223 SWIGEXPORT void SWIGSTDCALL CSharp_DevelActor_Property_GetTouchAreaOffset(void * jarg1, int* jarg2, int* jarg3, int* jarg4, int* jarg5) {
25224   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25225   arg1 = (Dali::Actor *)jarg1;
25226
25227   Rect<int32_t> result;
25228   {
25229     try {
25230       result = (arg1)->GetProperty<Rect<int32_t>>( Dali::DevelActor::Property::TOUCH_AREA_OFFSET);
25231       *jarg2 = result.left;
25232       *jarg3 = result.right;
25233       *jarg4 = result.bottom;
25234       *jarg5 = result.top;
25235     } CALL_CATCH_EXCEPTION();
25236   }
25237 }
25238
25239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
25240   Dali::Actor *arg1 = 0 ;
25241
25242   arg1 = (Dali::Actor *)jarg1;
25243   if (!arg1) {
25244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
25245     return ;
25246   }
25247   {
25248     try {
25249       Dali::UnparentAndReset(*arg1);
25250     } CALL_CATCH_EXCEPTION();
25251   }
25252
25253 }
25254
25255
25256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
25257   int jresult ;
25258   int result;
25259
25260   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
25261   jresult = (int)result;
25262   return jresult;
25263 }
25264
25265
25266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
25267   int jresult ;
25268   int result;
25269
25270   result = (int)Dali::Layer::Property::CLIPPING_BOX;
25271   jresult = (int)result;
25272   return jresult;
25273 }
25274
25275
25276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
25277   int jresult ;
25278   int result;
25279
25280   result = (int)Dali::Layer::Property::BEHAVIOR;
25281   jresult = (int)result;
25282   return jresult;
25283 }
25284
25285
25286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
25287   void * jresult ;
25288   Dali::Layer::Property *result = 0 ;
25289
25290   {
25291     try {
25292       result = (Dali::Layer::Property *)new Dali::Layer::Property();
25293     } CALL_CATCH_EXCEPTION(0);
25294   }
25295
25296   jresult = (void *)result;
25297   return jresult;
25298 }
25299
25300
25301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
25302   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
25303
25304   arg1 = (Dali::Layer::Property *)jarg1;
25305   {
25306     try {
25307       delete arg1;
25308     } CALL_CATCH_EXCEPTION();
25309   }
25310
25311 }
25312
25313
25314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
25315   void * jresult ;
25316   Dali::Layer *result = 0 ;
25317
25318   {
25319     try {
25320       result = (Dali::Layer *)new Dali::Layer();
25321     } CALL_CATCH_EXCEPTION(0);
25322   }
25323
25324   jresult = (void *)result;
25325   return jresult;
25326 }
25327
25328
25329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
25330   void * jresult ;
25331   Dali::Layer result;
25332
25333   {
25334     try {
25335       result = Dali::Layer::New();
25336     } CALL_CATCH_EXCEPTION(0);
25337   }
25338
25339   jresult = new Dali::Layer((const Dali::Layer &)result);
25340   return jresult;
25341 }
25342
25343
25344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
25345   void * jresult ;
25346   Dali::BaseHandle arg1 ;
25347   Dali::BaseHandle *argp1 ;
25348   Dali::Layer result;
25349
25350   argp1 = (Dali::BaseHandle *)jarg1;
25351   if (!argp1) {
25352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25353     return 0;
25354   }
25355   arg1 = *argp1;
25356   {
25357     try {
25358       result = Dali::Layer::DownCast(arg1);
25359     } CALL_CATCH_EXCEPTION(0);
25360   }
25361
25362   jresult = new Dali::Layer((const Dali::Layer &)result);
25363   return jresult;
25364 }
25365
25366
25367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
25368   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25369
25370   arg1 = (Dali::Layer *)jarg1;
25371   {
25372     try {
25373       delete arg1;
25374     } CALL_CATCH_EXCEPTION();
25375   }
25376
25377 }
25378
25379
25380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
25381   void * jresult ;
25382   Dali::Layer *arg1 = 0 ;
25383   Dali::Layer *result = 0 ;
25384
25385   arg1 = (Dali::Layer *)jarg1;
25386   if (!arg1) {
25387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
25388     return 0;
25389   }
25390   {
25391     try {
25392       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
25393     } CALL_CATCH_EXCEPTION(0);
25394   }
25395
25396   jresult = (void *)result;
25397   return jresult;
25398 }
25399
25400
25401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
25402   void * jresult ;
25403   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25404   Dali::Layer *arg2 = 0 ;
25405   Dali::Layer *result = 0 ;
25406
25407   arg1 = (Dali::Layer *)jarg1;
25408   arg2 = (Dali::Layer *)jarg2;
25409   if (!arg2) {
25410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
25411     return 0;
25412   }
25413   {
25414     try {
25415       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
25416     } CALL_CATCH_EXCEPTION(0);
25417   }
25418
25419   jresult = (void *)result;
25420   return jresult;
25421 }
25422
25423
25424 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
25425   unsigned int jresult ;
25426   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25427   unsigned int result;
25428
25429   arg1 = (Dali::Layer *)jarg1;
25430   {
25431     try {
25432       result = (unsigned int)((Dali::Layer const *)arg1)->GetProperty< int >( Layer::Property::DEPTH );
25433     } CALL_CATCH_EXCEPTION(0);
25434   }
25435
25436   jresult = result;
25437   return jresult;
25438 }
25439
25440
25441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
25442   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25443
25444   arg1 = (Dali::Layer *)jarg1;
25445   {
25446     try {
25447       (arg1)->Raise();
25448     } CALL_CATCH_EXCEPTION();
25449   }
25450
25451 }
25452
25453
25454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
25455   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25456
25457   arg1 = (Dali::Layer *)jarg1;
25458   {
25459     try {
25460       (arg1)->Lower();
25461     } CALL_CATCH_EXCEPTION();
25462   }
25463
25464 }
25465
25466
25467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
25468   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25469   Dali::Layer arg2 ;
25470   Dali::Layer *argp2 ;
25471
25472   arg1 = (Dali::Layer *)jarg1;
25473   argp2 = (Dali::Layer *)jarg2;
25474   if (!argp2) {
25475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
25476     return ;
25477   }
25478   arg2 = *argp2;
25479   {
25480     try {
25481       (arg1)->RaiseAbove(arg2);
25482     } CALL_CATCH_EXCEPTION();
25483   }
25484
25485 }
25486
25487
25488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
25489   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25490   Dali::Layer arg2 ;
25491   Dali::Layer *argp2 ;
25492
25493   arg1 = (Dali::Layer *)jarg1;
25494   argp2 = (Dali::Layer *)jarg2;
25495   if (!argp2) {
25496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
25497     return ;
25498   }
25499   arg2 = *argp2;
25500   {
25501     try {
25502       (arg1)->LowerBelow(arg2);
25503     } CALL_CATCH_EXCEPTION();
25504   }
25505
25506 }
25507
25508
25509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
25510   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25511
25512   arg1 = (Dali::Layer *)jarg1;
25513   {
25514     try {
25515       (arg1)->RaiseToTop();
25516     } CALL_CATCH_EXCEPTION();
25517   }
25518
25519 }
25520
25521
25522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
25523   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25524
25525   arg1 = (Dali::Layer *)jarg1;
25526   {
25527     try {
25528       (arg1)->LowerToBottom();
25529     } CALL_CATCH_EXCEPTION();
25530   }
25531
25532 }
25533
25534
25535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
25536   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25537   Dali::Layer arg2 ;
25538   Dali::Layer *argp2 ;
25539
25540   arg1 = (Dali::Layer *)jarg1;
25541   argp2 = (Dali::Layer *)jarg2;
25542   if (!argp2) {
25543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
25544     return ;
25545   }
25546   arg2 = *argp2;
25547   {
25548     try {
25549       (arg1)->MoveAbove(arg2);
25550     } CALL_CATCH_EXCEPTION();
25551   }
25552
25553 }
25554
25555
25556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
25557   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25558   Dali::Layer arg2 ;
25559   Dali::Layer *argp2 ;
25560
25561   arg1 = (Dali::Layer *)jarg1;
25562   argp2 = (Dali::Layer *)jarg2;
25563   if (!argp2) {
25564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
25565     return ;
25566   }
25567   arg2 = *argp2;
25568   {
25569     try {
25570       (arg1)->MoveBelow(arg2);
25571     } CALL_CATCH_EXCEPTION();
25572   }
25573
25574 }
25575
25576
25577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
25578   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25579   Dali::Layer::Behavior arg2 ;
25580
25581   arg1 = (Dali::Layer *)jarg1;
25582   arg2 = (Dali::Layer::Behavior)jarg2;
25583   {
25584     try {
25585       (arg1)->SetProperty( Layer::Property::BEHAVIOR, arg2 );
25586     } CALL_CATCH_EXCEPTION();
25587   }
25588
25589 }
25590
25591
25592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
25593   int jresult ;
25594   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25595   Dali::Layer::Behavior result;
25596
25597   arg1 = (Dali::Layer *)jarg1;
25598   {
25599     try {
25600       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetProperty<Dali::Layer::Behavior>( Dali::Layer::Property::BEHAVIOR );
25601     } CALL_CATCH_EXCEPTION(0);
25602   }
25603
25604   jresult = (int)result;
25605   return jresult;
25606 }
25607
25608
25609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, bool jarg2) {
25610   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25611   bool arg2 ;
25612
25613   arg1 = (Dali::Layer *)jarg1;
25614   arg2 = jarg2 ? true : false;
25615   {
25616     try {
25617       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_ENABLE, arg2 );
25618     } CALL_CATCH_EXCEPTION();
25619   }
25620
25621 }
25622
25623
25624 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
25625   bool jresult ;
25626   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25627   bool result;
25628
25629   arg1 = (Dali::Layer *)jarg1;
25630   {
25631     try {
25632       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Dali::Layer::Property::CLIPPING_ENABLE );
25633     } CALL_CATCH_EXCEPTION(0);
25634   }
25635
25636   jresult = result;
25637   return jresult;
25638 }
25639
25640
25641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
25642   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25643   int arg2 ;
25644   int arg3 ;
25645   int arg4 ;
25646   int arg5 ;
25647
25648   arg1 = (Dali::Layer *)jarg1;
25649   arg2 = (int)jarg2;
25650   arg3 = (int)jarg3;
25651   arg4 = (int)jarg4;
25652   arg5 = (int)jarg5;
25653   {
25654     try {
25655       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, Rect<int32_t>( arg2,arg3,arg4,arg5 ) );
25656     } CALL_CATCH_EXCEPTION();
25657   }
25658
25659 }
25660
25661
25662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
25663   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25664   Dali::ClippingBox arg2 ;
25665   Dali::ClippingBox *argp2 ;
25666
25667   arg1 = (Dali::Layer *)jarg1;
25668   argp2 = (Dali::ClippingBox *)jarg2;
25669   if (!argp2) {
25670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
25671     return ;
25672   }
25673   arg2 = *argp2;
25674   {
25675     try {
25676       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, arg2 );
25677     } CALL_CATCH_EXCEPTION();
25678   }
25679
25680 }
25681
25682
25683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
25684   void * jresult ;
25685   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25686   Dali::ClippingBox result;
25687
25688   arg1 = (Dali::Layer *)jarg1;
25689   {
25690     try {
25691       result = ((Dali::Layer const *)arg1)->GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX );
25692     } CALL_CATCH_EXCEPTION(0);
25693   }
25694
25695   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
25696   return jresult;
25697 }
25698
25699
25700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, bool jarg2) {
25701   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25702   bool arg2 ;
25703
25704   arg1 = (Dali::Layer *)jarg1;
25705   arg2 = jarg2 ? true : false;
25706   {
25707     try {
25708       (arg1)->SetProperty( Layer::Property::DEPTH_TEST, !arg2 );
25709     } CALL_CATCH_EXCEPTION();
25710   }
25711
25712 }
25713
25714
25715 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
25716   bool jresult ;
25717   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25718   bool result;
25719
25720   arg1 = (Dali::Layer *)jarg1;
25721   {
25722     try {
25723       result = !(bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::DEPTH_TEST );
25724     } CALL_CATCH_EXCEPTION(0);
25725   }
25726
25727   jresult = result;
25728   return jresult;
25729 }
25730
25731
25732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
25733   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25734   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
25735
25736   arg1 = (Dali::Layer *)jarg1;
25737   arg2 = (Dali::Layer::SortFunctionType)jarg2;
25738   {
25739     try {
25740       (arg1)->SetSortFunction(arg2);
25741     } CALL_CATCH_EXCEPTION();
25742   }
25743
25744 }
25745
25746
25747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, bool jarg2) {
25748   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25749   bool arg2 ;
25750
25751   arg1 = (Dali::Layer *)jarg1;
25752   arg2 = jarg2 ? true : false;
25753   {
25754     try {
25755       (arg1)->SetProperty( Layer::Property::CONSUMES_TOUCH, arg2 );
25756     } CALL_CATCH_EXCEPTION();
25757   }
25758
25759 }
25760
25761
25762 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
25763   bool jresult ;
25764   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25765   bool result;
25766
25767   arg1 = (Dali::Layer *)jarg1;
25768   {
25769     try {
25770       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_TOUCH );
25771     } CALL_CATCH_EXCEPTION(0);
25772   }
25773
25774   jresult = result;
25775   return jresult;
25776 }
25777
25778
25779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, bool jarg2) {
25780   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25781   bool arg2 ;
25782
25783   arg1 = (Dali::Layer *)jarg1;
25784   arg2 = jarg2 ? true : false;
25785   {
25786     try {
25787       (arg1)->SetProperty( Layer::Property::CONSUMES_HOVER, arg2 );
25788     } CALL_CATCH_EXCEPTION();
25789   }
25790
25791 }
25792
25793
25794 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
25795   bool jresult ;
25796   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25797   bool result;
25798
25799   arg1 = (Dali::Layer *)jarg1;
25800   {
25801     try {
25802       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_HOVER );
25803     } CALL_CATCH_EXCEPTION(0);
25804   }
25805
25806   jresult = result;
25807   return jresult;
25808 }
25809
25810
25811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
25812   void * jresult ;
25813   Dali::Stage result;
25814
25815   {
25816     try {
25817       result = Dali::Stage::GetCurrent();
25818     } CALL_CATCH_EXCEPTION(0);
25819   }
25820
25821   jresult = new Dali::Stage((const Dali::Stage &)result);
25822   return jresult;
25823 }
25824
25825
25826 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
25827   bool jresult ;
25828   bool result;
25829
25830   {
25831     try {
25832       result = (bool)Dali::Stage::IsInstalled();
25833     } CALL_CATCH_EXCEPTION(0);
25834   }
25835
25836   jresult = result;
25837   return jresult;
25838 }
25839
25840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
25841   void * jresult ;
25842   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
25843   Dali::RenderTaskList result;
25844
25845   arg1 = (Dali::Stage *)jarg1;
25846   {
25847     try {
25848       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
25849     } CALL_CATCH_EXCEPTION(0);
25850   }
25851
25852   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
25853   return jresult;
25854 }
25855
25856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
25857   void * jresult ;
25858   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
25859   Dali::Vector2 result;
25860
25861   arg1 = (Dali::Stage *)jarg1;
25862   {
25863     try {
25864       result = ((Dali::Stage const *)arg1)->GetDpi();
25865     } CALL_CATCH_EXCEPTION(0);
25866   }
25867
25868   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25869   return jresult;
25870 }
25871
25872
25873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
25874   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
25875   float arg2 ;
25876
25877   arg1 = (Dali::Stage *)jarg1;
25878   arg2 = (float)jarg2;
25879   {
25880     try {
25881       (arg1)->KeepRendering(arg2);
25882     } CALL_CATCH_EXCEPTION();
25883   }
25884
25885 }
25886
25887
25888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
25889   void * jresult ;
25890   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
25891   Dali::Stage::KeyEventSignalType *result = 0 ;
25892
25893   arg1 = (Dali::Stage *)jarg1;
25894   {
25895     try {
25896       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
25897     } CALL_CATCH_EXCEPTION(0);
25898   }
25899
25900   jresult = (void *)result;
25901   return jresult;
25902 }
25903
25904
25905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
25906   void * jresult ;
25907   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
25908   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
25909
25910   arg1 = (Dali::Stage *)jarg1;
25911   {
25912     try {
25913       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
25914     } CALL_CATCH_EXCEPTION(0);
25915   }
25916
25917   jresult = (void *)result;
25918   return jresult;
25919 }
25920
25921
25922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
25923   void * jresult ;
25924   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
25925   Dali::Stage::TouchEventSignalType *result = 0 ;
25926
25927   arg1 = (Dali::Stage *)jarg1;
25928   {
25929     try {
25930       result = (Dali::Stage::TouchEventSignalType *) &(arg1)->TouchedSignal();
25931     } CALL_CATCH_EXCEPTION(0);
25932   }
25933
25934   jresult = (void *)result;
25935   return jresult;
25936 }
25937
25938
25939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
25940   void * jresult ;
25941   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
25942   Dali::Stage::WheelEventSignalType *result = 0 ;
25943
25944   arg1 = (Dali::Stage *)jarg1;
25945   {
25946     try {
25947       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
25948     } CALL_CATCH_EXCEPTION(0);
25949   }
25950
25951   jresult = (void *)result;
25952   return jresult;
25953 }
25954
25955
25956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
25957   void * jresult ;
25958   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
25959   Dali::Stage::ContextStatusSignal *result = 0 ;
25960
25961   arg1 = (Dali::Stage *)jarg1;
25962   {
25963     try {
25964       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
25965     } CALL_CATCH_EXCEPTION(0);
25966   }
25967
25968   jresult = (void *)result;
25969   return jresult;
25970 }
25971
25972
25973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
25974   void * jresult ;
25975   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
25976   Dali::Stage::ContextStatusSignal *result = 0 ;
25977
25978   arg1 = (Dali::Stage *)jarg1;
25979   {
25980     try {
25981       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
25982     } CALL_CATCH_EXCEPTION(0);
25983   }
25984
25985   jresult = (void *)result;
25986   return jresult;
25987 }
25988
25989
25990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
25991   void * jresult ;
25992   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
25993   Dali::Stage::SceneCreatedSignalType *result = 0 ;
25994
25995   arg1 = (Dali::Stage *)jarg1;
25996   {
25997     try {
25998       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
25999     } CALL_CATCH_EXCEPTION(0);
26000   }
26001
26002   jresult = (void *)result;
26003   return jresult;
26004 }
26005
26006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
26007   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
26008   Dali::DevelStage::Rendering arg2 ;
26009
26010   arg1 = (Dali::Stage *)jarg1;
26011   arg2 = (Dali::DevelStage::Rendering)jarg2;
26012   {
26013     try {
26014       DevelStage::SetRenderingBehavior(*arg1,arg2);
26015     } CALL_CATCH_EXCEPTION();
26016   }
26017
26018 }
26019
26020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
26021
26022   int jresult ;
26023   int result ;
26024   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
26025
26026   arg1 = (Dali::Stage *)jarg1;
26027   {
26028     try {
26029       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
26030     } CALL_CATCH_EXCEPTION(0);
26031   }
26032
26033   jresult = result;
26034   return jresult;
26035 }
26036
26037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
26038   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
26039
26040   arg1 = (Dali::RelayoutContainer *)jarg1;
26041   {
26042     try {
26043       delete arg1;
26044     } CALL_CATCH_EXCEPTION();
26045   }
26046
26047 }
26048
26049
26050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
26051   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
26052   Dali::Actor *arg2 = 0 ;
26053   Dali::Vector2 *arg3 = 0 ;
26054
26055   arg1 = (Dali::RelayoutContainer *)jarg1;
26056   arg2 = (Dali::Actor *)jarg2;
26057   if (!arg2) {
26058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
26059     return ;
26060   }
26061   arg3 = (Dali::Vector2 *)jarg3;
26062   if (!arg3) {
26063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
26064     return ;
26065   }
26066   {
26067     try {
26068       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
26069     } CALL_CATCH_EXCEPTION();
26070   }
26071
26072 }
26073
26074
26075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
26076   void * jresult ;
26077   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26078   Dali::CustomActor result;
26079
26080   arg1 = (Dali::CustomActorImpl *)jarg1;
26081   {
26082     try {
26083       result = ((Dali::CustomActorImpl const *)arg1)->Self();
26084     } CALL_CATCH_EXCEPTION(0);
26085   }
26086
26087   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
26088   return jresult;
26089 }
26090
26091
26092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneConnection(void * jarg1, int jarg2) {
26093   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26094   int arg2 ;
26095
26096   arg1 = (Dali::CustomActorImpl *)jarg1;
26097   arg2 = (int)jarg2;
26098   {
26099     try {
26100       (arg1)->OnSceneConnection(arg2);
26101     } CALL_CATCH_EXCEPTION();
26102   }
26103
26104 }
26105
26106
26107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneDisconnection(void * jarg1) {
26108   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26109
26110   arg1 = (Dali::CustomActorImpl *)jarg1;
26111   {
26112     try {
26113       (arg1)->OnSceneDisconnection();
26114     } CALL_CATCH_EXCEPTION();
26115   }
26116
26117 }
26118
26119
26120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
26121   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26122   Dali::Actor *arg2 = 0 ;
26123
26124   arg1 = (Dali::CustomActorImpl *)jarg1;
26125   arg2 = (Dali::Actor *)jarg2;
26126   if (!arg2) {
26127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
26128     return ;
26129   }
26130   {
26131     try {
26132       (arg1)->OnChildAdd(*arg2);
26133     } CALL_CATCH_EXCEPTION();
26134   }
26135
26136 }
26137
26138
26139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
26140   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26141   Dali::Actor *arg2 = 0 ;
26142
26143   arg1 = (Dali::CustomActorImpl *)jarg1;
26144   arg2 = (Dali::Actor *)jarg2;
26145   if (!arg2) {
26146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
26147     return ;
26148   }
26149   {
26150     try {
26151       (arg1)->OnChildRemove(*arg2);
26152     } CALL_CATCH_EXCEPTION();
26153   }
26154
26155 }
26156
26157
26158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
26159   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26160   Dali::Property::Index arg2 ;
26161   Dali::Property::Value arg3 ;
26162   Dali::Property::Value *argp3 ;
26163
26164   arg1 = (Dali::CustomActorImpl *)jarg1;
26165   arg2 = (Dali::Property::Index)jarg2;
26166   argp3 = (Dali::Property::Value *)jarg3;
26167   if (!argp3) {
26168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
26169     return ;
26170   }
26171   arg3 = *argp3;
26172   {
26173     try {
26174       (arg1)->OnPropertySet(arg2,arg3);
26175     } CALL_CATCH_EXCEPTION();
26176   }
26177
26178 }
26179
26180
26181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
26182   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26183   Dali::Vector3 *arg2 = 0 ;
26184
26185   arg1 = (Dali::CustomActorImpl *)jarg1;
26186   arg2 = (Dali::Vector3 *)jarg2;
26187   if (!arg2) {
26188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
26189     return ;
26190   }
26191   {
26192     try {
26193       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
26194     } CALL_CATCH_EXCEPTION();
26195   }
26196
26197 }
26198
26199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
26200   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26201   Dali::Animation *arg2 = 0 ;
26202   Dali::Vector3 *arg3 = 0 ;
26203
26204   arg1 = (Dali::CustomActorImpl *)jarg1;
26205   arg2 = (Dali::Animation *)jarg2;
26206   if (!arg2) {
26207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
26208     return ;
26209   }
26210   arg3 = (Dali::Vector3 *)jarg3;
26211   if (!arg3) {
26212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
26213     return ;
26214   }
26215   {
26216     try {
26217       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
26218     } CALL_CATCH_EXCEPTION();
26219   }
26220 }
26221
26222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
26223   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26224   Dali::Vector2 *arg2 = 0 ;
26225   Dali::RelayoutContainer *arg3 = 0 ;
26226
26227   arg1 = (Dali::CustomActorImpl *)jarg1;
26228   arg2 = (Dali::Vector2 *)jarg2;
26229   if (!arg2) {
26230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
26231     return ;
26232   }
26233   arg3 = (Dali::RelayoutContainer *)jarg3;
26234   if (!arg3) {
26235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
26236     return ;
26237   }
26238   {
26239     try {
26240       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
26241     } CALL_CATCH_EXCEPTION();
26242   }
26243
26244 }
26245
26246
26247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
26248   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26249   Dali::ResizePolicy::Type arg2 ;
26250   Dali::Dimension::Type arg3 ;
26251
26252   arg1 = (Dali::CustomActorImpl *)jarg1;
26253   arg2 = (Dali::ResizePolicy::Type)jarg2;
26254   arg3 = (Dali::Dimension::Type)jarg3;
26255   {
26256     try {
26257       (arg1)->OnSetResizePolicy(arg2,arg3);
26258     } CALL_CATCH_EXCEPTION();
26259   }
26260
26261 }
26262
26263
26264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
26265   void * jresult ;
26266   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26267   Dali::Vector3 result;
26268
26269   arg1 = (Dali::CustomActorImpl *)jarg1;
26270   {
26271     try {
26272       result = (arg1)->GetNaturalSize();
26273     } CALL_CATCH_EXCEPTION(0);
26274   }
26275
26276   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
26277   return jresult;
26278 }
26279
26280
26281 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
26282   float jresult ;
26283   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26284   Dali::Actor *arg2 = 0 ;
26285   Dali::Dimension::Type arg3 ;
26286   float result;
26287
26288   arg1 = (Dali::CustomActorImpl *)jarg1;
26289   arg2 = (Dali::Actor *)jarg2;
26290   if (!arg2) {
26291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
26292     return 0;
26293   }
26294   arg3 = (Dali::Dimension::Type)jarg3;
26295   {
26296     try {
26297       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
26298     } CALL_CATCH_EXCEPTION(0);
26299   }
26300
26301   jresult = result;
26302   return jresult;
26303 }
26304
26305
26306 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
26307   float jresult ;
26308   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26309   float arg2 ;
26310   float result;
26311
26312   arg1 = (Dali::CustomActorImpl *)jarg1;
26313   arg2 = (float)jarg2;
26314   {
26315     try {
26316       result = (float)(arg1)->GetHeightForWidth(arg2);
26317     } CALL_CATCH_EXCEPTION(0);
26318   }
26319
26320   jresult = result;
26321   return jresult;
26322 }
26323
26324
26325 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
26326   float jresult ;
26327   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26328   float arg2 ;
26329   float result;
26330
26331   arg1 = (Dali::CustomActorImpl *)jarg1;
26332   arg2 = (float)jarg2;
26333   {
26334     try {
26335       result = (float)(arg1)->GetWidthForHeight(arg2);
26336     } CALL_CATCH_EXCEPTION(0);
26337   }
26338
26339   jresult = result;
26340   return jresult;
26341 }
26342
26343
26344 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
26345   bool jresult ;
26346   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26347   Dali::Dimension::Type arg2 ;
26348   bool result;
26349
26350   arg1 = (Dali::CustomActorImpl *)jarg1;
26351   arg2 = (Dali::Dimension::Type)jarg2;
26352   {
26353     try {
26354       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
26355     } CALL_CATCH_EXCEPTION(0);
26356   }
26357
26358   jresult = result;
26359   return jresult;
26360 }
26361
26362
26363 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
26364   bool jresult ;
26365   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26366   bool result;
26367
26368   arg1 = (Dali::CustomActorImpl *)jarg1;
26369   {
26370     try {
26371       result = (bool)(arg1)->RelayoutDependentOnChildren();
26372     } CALL_CATCH_EXCEPTION(0);
26373   }
26374
26375   jresult = result;
26376   return jresult;
26377 }
26378
26379
26380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
26381   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26382   Dali::Dimension::Type arg2 ;
26383
26384   arg1 = (Dali::CustomActorImpl *)jarg1;
26385   arg2 = (Dali::Dimension::Type)jarg2;
26386   {
26387     try {
26388       (arg1)->OnCalculateRelayoutSize(arg2);
26389     } CALL_CATCH_EXCEPTION();
26390   }
26391
26392 }
26393
26394
26395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
26396   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26397   float arg2 ;
26398   Dali::Dimension::Type arg3 ;
26399
26400   arg1 = (Dali::CustomActorImpl *)jarg1;
26401   arg2 = (float)jarg2;
26402   arg3 = (Dali::Dimension::Type)jarg3;
26403   {
26404     try {
26405       (arg1)->OnLayoutNegotiated(arg2,arg3);
26406     } CALL_CATCH_EXCEPTION();
26407   }
26408
26409 }
26410
26411 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
26412   bool jresult ;
26413   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26414   bool result;
26415
26416   arg1 = (Dali::CustomActorImpl *)jarg1;
26417   {
26418     try {
26419       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
26420     } CALL_CATCH_EXCEPTION(0);
26421   }
26422
26423   jresult = result;
26424   return jresult;
26425 }
26426
26427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
26428   void * jresult ;
26429   Dali::CustomActor *result = 0 ;
26430
26431   {
26432     try {
26433       result = (Dali::CustomActor *)new Dali::CustomActor();
26434     } CALL_CATCH_EXCEPTION(0);
26435   }
26436
26437   jresult = (void *)result;
26438   return jresult;
26439 }
26440
26441
26442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
26443   void * jresult ;
26444   Dali::BaseHandle arg1 ;
26445   Dali::BaseHandle *argp1 ;
26446   Dali::CustomActor result;
26447
26448   argp1 = (Dali::BaseHandle *)jarg1;
26449   if (!argp1) {
26450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26451     return 0;
26452   }
26453   arg1 = *argp1;
26454   {
26455     try {
26456       result = Dali::CustomActor::DownCast(arg1);
26457     } CALL_CATCH_EXCEPTION(0);
26458   }
26459
26460   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
26461   return jresult;
26462 }
26463
26464
26465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
26466   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
26467
26468   arg1 = (Dali::CustomActor *)jarg1;
26469   {
26470     try {
26471       delete arg1;
26472     } CALL_CATCH_EXCEPTION();
26473   }
26474
26475 }
26476
26477
26478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
26479   void * jresult ;
26480   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
26481   Dali::CustomActorImpl *result = 0 ;
26482
26483   arg1 = (Dali::CustomActor *)jarg1;
26484   {
26485     try {
26486       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
26487     } CALL_CATCH_EXCEPTION(0);
26488   }
26489
26490   jresult = (void *)result;
26491   return jresult;
26492 }
26493
26494
26495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
26496   void * jresult ;
26497   Dali::CustomActorImpl *arg1 = 0 ;
26498   Dali::CustomActor *result = 0 ;
26499
26500   arg1 = (Dali::CustomActorImpl *)jarg1;
26501   if (!arg1) {
26502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
26503     return 0;
26504   }
26505   {
26506     try {
26507       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
26508     } CALL_CATCH_EXCEPTION(0);
26509   }
26510
26511   jresult = (void *)result;
26512   return jresult;
26513 }
26514
26515
26516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
26517   void * jresult ;
26518   Dali::CustomActor *arg1 = 0 ;
26519   Dali::CustomActor *result = 0 ;
26520
26521   arg1 = (Dali::CustomActor *)jarg1;
26522   if (!arg1) {
26523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
26524     return 0;
26525   }
26526   {
26527     try {
26528       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
26529     } CALL_CATCH_EXCEPTION(0);
26530   }
26531
26532   jresult = (void *)result;
26533   return jresult;
26534 }
26535
26536
26537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
26538   void * jresult ;
26539   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
26540   Dali::CustomActor *arg2 = 0 ;
26541   Dali::CustomActor *result = 0 ;
26542
26543   arg1 = (Dali::CustomActor *)jarg1;
26544   arg2 = (Dali::CustomActor *)jarg2;
26545   if (!arg2) {
26546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
26547     return 0;
26548   }
26549   {
26550     try {
26551       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
26552     } CALL_CATCH_EXCEPTION(0);
26553   }
26554
26555   jresult = (void *)result;
26556   return jresult;
26557 }
26558
26559
26560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
26561   int jresult ;
26562   int result;
26563
26564   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
26565   jresult = (int)result;
26566   return jresult;
26567 }
26568
26569
26570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
26571   int jresult ;
26572   int result;
26573
26574   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
26575   jresult = (int)result;
26576   return jresult;
26577 }
26578
26579
26580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
26581   int jresult ;
26582   int result;
26583
26584   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
26585   jresult = (int)result;
26586   return jresult;
26587 }
26588
26589
26590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
26591   int jresult ;
26592   int result;
26593
26594   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
26595   jresult = (int)result;
26596   return jresult;
26597 }
26598
26599
26600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
26601   int jresult ;
26602   int result;
26603
26604   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
26605   jresult = (int)result;
26606   return jresult;
26607 }
26608
26609
26610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
26611   int jresult ;
26612   int result;
26613
26614   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
26615   jresult = (int)result;
26616   return jresult;
26617 }
26618
26619
26620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
26621   int jresult ;
26622   int result;
26623
26624   result = (int)Dali::PanGestureDetector::Property::PANNING;
26625   jresult = (int)result;
26626   return jresult;
26627 }
26628
26629
26630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
26631   void * jresult ;
26632   Dali::PanGestureDetector::Property *result = 0 ;
26633
26634   {
26635     try {
26636       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
26637     } CALL_CATCH_EXCEPTION(0);
26638   }
26639
26640   jresult = (void *)result;
26641   return jresult;
26642 }
26643
26644
26645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
26646   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
26647
26648   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
26649   {
26650     try {
26651       delete arg1;
26652     } CALL_CATCH_EXCEPTION();
26653   }
26654
26655 }
26656
26657
26658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
26659   void * jresult ;
26660   Dali::Radian *result = 0 ;
26661
26662   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
26663   jresult = (void *)result;
26664   return jresult;
26665 }
26666
26667
26668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
26669   void * jresult ;
26670   Dali::Radian *result = 0 ;
26671
26672   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
26673   jresult = (void *)result;
26674   return jresult;
26675 }
26676
26677
26678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
26679   void * jresult ;
26680   Dali::Radian *result = 0 ;
26681
26682   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
26683   jresult = (void *)result;
26684   return jresult;
26685 }
26686
26687
26688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
26689   void * jresult ;
26690   Dali::Radian *result = 0 ;
26691
26692   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
26693   jresult = (void *)result;
26694   return jresult;
26695 }
26696
26697
26698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
26699   void * jresult ;
26700   Dali::Radian *result = 0 ;
26701
26702   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
26703   jresult = (void *)result;
26704   return jresult;
26705 }
26706
26707
26708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
26709   void * jresult ;
26710   Dali::Radian *result = 0 ;
26711
26712   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
26713   jresult = (void *)result;
26714   return jresult;
26715 }
26716
26717
26718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
26719   void * jresult ;
26720   Dali::Radian *result = 0 ;
26721
26722   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
26723   jresult = (void *)result;
26724   return jresult;
26725 }
26726
26727
26728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
26729   void * jresult ;
26730   Dali::PanGestureDetector *result = 0 ;
26731
26732   {
26733     try {
26734       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
26735     } CALL_CATCH_EXCEPTION(0);
26736   }
26737
26738   jresult = (void *)result;
26739   return jresult;
26740 }
26741
26742
26743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
26744   void * jresult ;
26745   Dali::PanGestureDetector result;
26746
26747   {
26748     try {
26749       result = Dali::PanGestureDetector::New();
26750     } CALL_CATCH_EXCEPTION(0);
26751   }
26752
26753   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
26754   return jresult;
26755 }
26756
26757
26758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
26759   void * jresult ;
26760   Dali::BaseHandle arg1 ;
26761   Dali::BaseHandle *argp1 ;
26762   Dali::PanGestureDetector result;
26763
26764   argp1 = (Dali::BaseHandle *)jarg1;
26765   if (!argp1) {
26766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26767     return 0;
26768   }
26769   arg1 = *argp1;
26770   {
26771     try {
26772       result = Dali::PanGestureDetector::DownCast(arg1);
26773     } CALL_CATCH_EXCEPTION(0);
26774   }
26775
26776   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
26777   return jresult;
26778 }
26779
26780
26781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
26782   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26783
26784   arg1 = (Dali::PanGestureDetector *)jarg1;
26785   {
26786     try {
26787       delete arg1;
26788     } CALL_CATCH_EXCEPTION();
26789   }
26790
26791 }
26792
26793
26794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
26795   void * jresult ;
26796   Dali::PanGestureDetector *arg1 = 0 ;
26797   Dali::PanGestureDetector *result = 0 ;
26798
26799   arg1 = (Dali::PanGestureDetector *)jarg1;
26800   if (!arg1) {
26801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
26802     return 0;
26803   }
26804   {
26805     try {
26806       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
26807     } CALL_CATCH_EXCEPTION(0);
26808   }
26809
26810   jresult = (void *)result;
26811   return jresult;
26812 }
26813
26814
26815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
26816   void * jresult ;
26817   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26818   Dali::PanGestureDetector *arg2 = 0 ;
26819   Dali::PanGestureDetector *result = 0 ;
26820
26821   arg1 = (Dali::PanGestureDetector *)jarg1;
26822   arg2 = (Dali::PanGestureDetector *)jarg2;
26823   if (!arg2) {
26824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
26825     return 0;
26826   }
26827   {
26828     try {
26829       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
26830     } CALL_CATCH_EXCEPTION(0);
26831   }
26832
26833   jresult = (void *)result;
26834   return jresult;
26835 }
26836
26837
26838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
26839   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26840   unsigned int arg2 ;
26841
26842   arg1 = (Dali::PanGestureDetector *)jarg1;
26843   arg2 = (unsigned int)jarg2;
26844   {
26845     try {
26846       (arg1)->SetMinimumTouchesRequired(arg2);
26847     } CALL_CATCH_EXCEPTION();
26848   }
26849
26850 }
26851
26852
26853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
26854   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26855   unsigned int arg2 ;
26856
26857   arg1 = (Dali::PanGestureDetector *)jarg1;
26858   arg2 = (unsigned int)jarg2;
26859   {
26860     try {
26861       (arg1)->SetMaximumTouchesRequired(arg2);
26862     } CALL_CATCH_EXCEPTION();
26863   }
26864
26865 }
26866
26867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumMotionEventAge(void * jarg1, unsigned int jarg2) {
26868   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26869   uint32_t arg2 ;
26870
26871   arg1 = (Dali::PanGestureDetector *)jarg1;
26872   arg2 = (uint32_t)jarg2;
26873   {
26874     try {
26875       (arg1)->SetMaximumMotionEventAge(arg2);
26876     } CALL_CATCH_EXCEPTION();
26877   }
26878
26879 }
26880
26881
26882 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
26883   unsigned int jresult ;
26884   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26885   unsigned int result;
26886
26887   arg1 = (Dali::PanGestureDetector *)jarg1;
26888   {
26889     try {
26890       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
26891     } CALL_CATCH_EXCEPTION(0);
26892   }
26893
26894   jresult = result;
26895   return jresult;
26896 }
26897
26898
26899 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
26900   unsigned int jresult ;
26901   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26902   unsigned int result;
26903
26904   arg1 = (Dali::PanGestureDetector *)jarg1;
26905   {
26906     try {
26907       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
26908     } CALL_CATCH_EXCEPTION(0);
26909   }
26910
26911   jresult = result;
26912   return jresult;
26913 }
26914
26915 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumMotionEventAge(void * jarg1) {
26916   unsigned int jresult ;
26917   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26918   uint32_t result;
26919
26920   arg1 = (Dali::PanGestureDetector *)jarg1;
26921   {
26922     try {
26923       result = (uint32_t)((Dali::PanGestureDetector const *)arg1)->GetMaximumMotionEventAge();
26924     } CALL_CATCH_EXCEPTION(0);
26925   }
26926
26927   jresult = result;
26928   return jresult;
26929 }
26930
26931
26932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
26933   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26934   Dali::Radian arg2 ;
26935   Dali::Radian arg3 ;
26936   Dali::Radian *argp2 ;
26937   Dali::Radian *argp3 ;
26938
26939   arg1 = (Dali::PanGestureDetector *)jarg1;
26940   argp2 = (Dali::Radian *)jarg2;
26941   if (!argp2) {
26942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
26943     return ;
26944   }
26945   arg2 = *argp2;
26946   argp3 = (Dali::Radian *)jarg3;
26947   if (!argp3) {
26948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
26949     return ;
26950   }
26951   arg3 = *argp3;
26952   {
26953     try {
26954       (arg1)->AddAngle(arg2,arg3);
26955     } CALL_CATCH_EXCEPTION();
26956   }
26957
26958 }
26959
26960
26961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
26962   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26963   Dali::Radian arg2 ;
26964   Dali::Radian *argp2 ;
26965
26966   arg1 = (Dali::PanGestureDetector *)jarg1;
26967   argp2 = (Dali::Radian *)jarg2;
26968   if (!argp2) {
26969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
26970     return ;
26971   }
26972   arg2 = *argp2;
26973   {
26974     try {
26975       (arg1)->AddAngle(arg2);
26976     } CALL_CATCH_EXCEPTION();
26977   }
26978
26979 }
26980
26981
26982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
26983   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26984   Dali::Radian arg2 ;
26985   Dali::Radian arg3 ;
26986   Dali::Radian *argp2 ;
26987   Dali::Radian *argp3 ;
26988
26989   arg1 = (Dali::PanGestureDetector *)jarg1;
26990   argp2 = (Dali::Radian *)jarg2;
26991   if (!argp2) {
26992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
26993     return ;
26994   }
26995   arg2 = *argp2;
26996   argp3 = (Dali::Radian *)jarg3;
26997   if (!argp3) {
26998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
26999     return ;
27000   }
27001   arg3 = *argp3;
27002   {
27003     try {
27004       (arg1)->AddDirection(arg2,arg3);
27005     } CALL_CATCH_EXCEPTION();
27006   }
27007
27008 }
27009
27010
27011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
27012   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27013   Dali::Radian arg2 ;
27014   Dali::Radian *argp2 ;
27015
27016   arg1 = (Dali::PanGestureDetector *)jarg1;
27017   argp2 = (Dali::Radian *)jarg2;
27018   if (!argp2) {
27019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
27020     return ;
27021   }
27022   arg2 = *argp2;
27023   {
27024     try {
27025       (arg1)->AddDirection(arg2);
27026     } CALL_CATCH_EXCEPTION();
27027   }
27028
27029 }
27030
27031
27032 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
27033   unsigned long jresult ;
27034   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27035   size_t result;
27036
27037   arg1 = (Dali::PanGestureDetector *)jarg1;
27038   {
27039     try {
27040       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
27041     } CALL_CATCH_EXCEPTION(0);
27042   }
27043
27044   jresult = (unsigned long)result;
27045   return jresult;
27046 }
27047
27048
27049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
27050   void * jresult ;
27051   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27052   size_t arg2 ;
27053   Dali::PanGestureDetector::AngleThresholdPair result;
27054
27055   arg1 = (Dali::PanGestureDetector *)jarg1;
27056   arg2 = (size_t)jarg2;
27057   {
27058     try {
27059       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
27060     } CALL_CATCH_EXCEPTION(0);
27061   }
27062
27063   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
27064   return jresult;
27065 }
27066
27067
27068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
27069   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27070
27071   arg1 = (Dali::PanGestureDetector *)jarg1;
27072   {
27073     try {
27074       (arg1)->ClearAngles();
27075     } CALL_CATCH_EXCEPTION();
27076   }
27077
27078 }
27079
27080
27081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
27082   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27083   Dali::Radian arg2 ;
27084   Dali::Radian *argp2 ;
27085
27086   arg1 = (Dali::PanGestureDetector *)jarg1;
27087   argp2 = (Dali::Radian *)jarg2;
27088   if (!argp2) {
27089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
27090     return ;
27091   }
27092   arg2 = *argp2;
27093   {
27094     try {
27095       (arg1)->RemoveAngle(arg2);
27096     } CALL_CATCH_EXCEPTION();
27097   }
27098
27099 }
27100
27101
27102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
27103   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27104   Dali::Radian arg2 ;
27105   Dali::Radian *argp2 ;
27106
27107   arg1 = (Dali::PanGestureDetector *)jarg1;
27108   argp2 = (Dali::Radian *)jarg2;
27109   if (!argp2) {
27110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
27111     return ;
27112   }
27113   arg2 = *argp2;
27114   {
27115     try {
27116       (arg1)->RemoveDirection(arg2);
27117     } CALL_CATCH_EXCEPTION();
27118   }
27119
27120 }
27121
27122
27123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
27124   void * jresult ;
27125   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27126   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
27127
27128   arg1 = (Dali::PanGestureDetector *)jarg1;
27129   {
27130     try {
27131       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27132     } CALL_CATCH_EXCEPTION(0);
27133   }
27134
27135   jresult = (void *)result;
27136   return jresult;
27137 }
27138
27139
27140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
27141   Dali::PanGesture *arg1 = 0 ;
27142
27143   arg1 = (Dali::PanGesture *)jarg1;
27144   if (!arg1) {
27145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
27146     return ;
27147   }
27148   {
27149     try {
27150       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
27151     } CALL_CATCH_EXCEPTION();
27152   }
27153
27154 }
27155
27156
27157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
27158   void * jresult ;
27159   Dali::PanGesture *result = 0 ;
27160
27161   {
27162     try {
27163       result = (Dali::PanGesture *)new Dali::PanGesture();
27164     } CALL_CATCH_EXCEPTION(0);
27165   }
27166
27167   jresult = (void *)result;
27168   return jresult;
27169 }
27170
27171
27172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_New(int jarg1) {
27173   void * jresult ;
27174   Dali::GestureState arg1 ;
27175   Dali::PanGesture result;
27176
27177   arg1 = (Dali::GestureState)jarg1;
27178   {
27179     try {
27180       result = DevelPanGesture::New(arg1);
27181     } CALL_CATCH_EXCEPTION(0);
27182   }
27183
27184   jresult = new Dali::PanGesture((const Dali::PanGesture &)result);
27185   return jresult;
27186 }
27187
27188
27189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
27190   void * jresult ;
27191   Dali::PanGesture *arg1 = 0 ;
27192   Dali::PanGesture *result = 0 ;
27193
27194   arg1 = (Dali::PanGesture *)jarg1;
27195   if (!arg1) {
27196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
27197     return 0;
27198   }
27199   {
27200     try {
27201       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
27202     } CALL_CATCH_EXCEPTION(0);
27203   }
27204
27205   jresult = (void *)result;
27206   return jresult;
27207 }
27208
27209
27210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
27211   void * jresult ;
27212   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27213   Dali::PanGesture *arg2 = 0 ;
27214   Dali::PanGesture *result = 0 ;
27215
27216   arg1 = (Dali::PanGesture *)jarg1;
27217   arg2 = (Dali::PanGesture *)jarg2;
27218   if (!arg2) {
27219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
27220     return 0;
27221   }
27222   {
27223     try {
27224       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
27225     } CALL_CATCH_EXCEPTION(0);
27226   }
27227
27228   jresult = (void *)result;
27229   return jresult;
27230 }
27231
27232
27233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
27234   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27235
27236   arg1 = (Dali::PanGesture *)jarg1;
27237   {
27238     try {
27239       delete arg1;
27240     } CALL_CATCH_EXCEPTION();
27241   }
27242
27243 }
27244
27245
27246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
27247   void * jresult ;
27248   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27249   Dali::Vector2 result;
27250
27251   arg1 = (Dali::PanGesture *)jarg1;
27252   {
27253     try {
27254       result = ((Dali::PanGesture const *)arg1)->GetVelocity();
27255     } catch (std::out_of_range& e) {
27256       {
27257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27258       };
27259     } catch (std::exception& e) {
27260       {
27261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27262       };
27263     } catch (Dali::DaliException e) {
27264       {
27265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27266       };
27267     } catch (...) {
27268       {
27269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27270       };
27271     }
27272   }
27273   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
27274   return jresult;
27275 }
27276
27277
27278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
27279   void * jresult ;
27280   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27281   Dali::Vector2 result;
27282
27283   arg1 = (Dali::PanGesture *)jarg1;
27284   {
27285     try {
27286       result = ((Dali::PanGesture const *)arg1)->GetDisplacement();
27287     } catch (std::out_of_range& e) {
27288       {
27289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27290       };
27291     } catch (std::exception& e) {
27292       {
27293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27294       };
27295     } catch (Dali::DaliException e) {
27296       {
27297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27298       };
27299     } catch (...) {
27300       {
27301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27302       };
27303     }
27304   }
27305   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
27306   return jresult;
27307 }
27308
27309
27310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
27311   void * jresult ;
27312   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27313   Dali::Vector2 result;
27314
27315   arg1 = (Dali::PanGesture *)jarg1;
27316   {
27317     try {
27318       result = ((Dali::PanGesture const *)arg1)->GetPosition();
27319     } catch (std::out_of_range& e) {
27320       {
27321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27322       };
27323     } catch (std::exception& e) {
27324       {
27325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27326       };
27327     } catch (Dali::DaliException e) {
27328       {
27329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27330       };
27331     } catch (...) {
27332       {
27333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27334       };
27335     }
27336   }
27337   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
27338   return jresult;
27339 }
27340
27341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
27342   void * jresult ;
27343   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27344   Dali::Vector2 result;
27345
27346   arg1 = (Dali::PanGesture *)jarg1;
27347   {
27348     try {
27349       result = ((Dali::PanGesture const *)arg1)->GetScreenVelocity();
27350     } catch (std::out_of_range& e) {
27351       {
27352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27353       };
27354     } catch (std::exception& e) {
27355       {
27356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27357       };
27358     } catch (Dali::DaliException e) {
27359       {
27360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27361       };
27362     } catch (...) {
27363       {
27364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27365       };
27366     }
27367   }
27368   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
27369   return jresult;
27370 }
27371
27372
27373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
27374   void * jresult ;
27375   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27376   Dali::Vector2 result;
27377
27378   arg1 = (Dali::PanGesture *)jarg1;
27379   {
27380     try {
27381       result = ((Dali::PanGesture const *)arg1)->GetScreenDisplacement();
27382     } catch (std::out_of_range& e) {
27383       {
27384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27385       };
27386     } catch (std::exception& e) {
27387       {
27388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27389       };
27390     } catch (Dali::DaliException e) {
27391       {
27392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27393       };
27394     } catch (...) {
27395       {
27396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27397       };
27398     }
27399   }
27400   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
27401   return jresult;
27402 }
27403
27404
27405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
27406   void * jresult ;
27407   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27408   Dali::Vector2 result;
27409
27410   arg1 = (Dali::PanGesture *)jarg1;
27411   {
27412     try {
27413       result = ((Dali::PanGesture const *)arg1)->GetScreenPosition();
27414     } catch (std::out_of_range& e) {
27415       {
27416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27417       };
27418     } catch (std::exception& e) {
27419       {
27420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27421       };
27422     } catch (Dali::DaliException e) {
27423       {
27424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27425       };
27426     } catch (...) {
27427       {
27428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27429       };
27430     }
27431   }
27432   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
27433   return jresult;
27434 }
27435
27436
27437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
27438   unsigned int jresult ;
27439   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27440   unsigned int result;
27441
27442   arg1 = (Dali::PanGesture *)jarg1;
27443   result = (unsigned int) ((arg1)->GetNumberOfTouches());
27444   jresult = result;
27445   return jresult;
27446 }
27447
27448
27449 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
27450   float jresult ;
27451   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27452   float result;
27453
27454   arg1 = (Dali::PanGesture *)jarg1;
27455   {
27456     try {
27457       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
27458     } CALL_CATCH_EXCEPTION(0);
27459   }
27460
27461   jresult = result;
27462   return jresult;
27463 }
27464
27465
27466 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
27467   float jresult ;
27468   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27469   float result;
27470
27471   arg1 = (Dali::PanGesture *)jarg1;
27472   {
27473     try {
27474       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
27475     } CALL_CATCH_EXCEPTION(0);
27476   }
27477
27478   jresult = result;
27479   return jresult;
27480 }
27481
27482
27483 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
27484   float jresult ;
27485   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27486   float result;
27487
27488   arg1 = (Dali::PanGesture *)jarg1;
27489   {
27490     try {
27491       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
27492     } CALL_CATCH_EXCEPTION(0);
27493   }
27494
27495   jresult = result;
27496   return jresult;
27497 }
27498
27499
27500 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
27501   float jresult ;
27502   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27503   float result;
27504
27505   arg1 = (Dali::PanGesture *)jarg1;
27506   {
27507     try {
27508       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
27509     } CALL_CATCH_EXCEPTION(0);
27510   }
27511
27512   jresult = result;
27513   return jresult;
27514 }
27515
27516
27517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
27518   void * jresult ;
27519   Dali::PinchGestureDetector *result = 0 ;
27520
27521   {
27522     try {
27523       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
27524     } CALL_CATCH_EXCEPTION(0);
27525   }
27526
27527   jresult = (void *)result;
27528   return jresult;
27529 }
27530
27531
27532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
27533   void * jresult ;
27534   Dali::PinchGestureDetector result;
27535
27536   {
27537     try {
27538       result = Dali::PinchGestureDetector::New();
27539     } CALL_CATCH_EXCEPTION(0);
27540   }
27541
27542   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
27543   return jresult;
27544 }
27545
27546
27547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
27548   void * jresult ;
27549   Dali::BaseHandle arg1 ;
27550   Dali::BaseHandle *argp1 ;
27551   Dali::PinchGestureDetector result;
27552
27553   argp1 = (Dali::BaseHandle *)jarg1;
27554   if (!argp1) {
27555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27556     return 0;
27557   }
27558   arg1 = *argp1;
27559   {
27560     try {
27561       result = Dali::PinchGestureDetector::DownCast(arg1);
27562     } CALL_CATCH_EXCEPTION(0);
27563   }
27564
27565   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
27566   return jresult;
27567 }
27568
27569
27570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
27571   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
27572
27573   arg1 = (Dali::PinchGestureDetector *)jarg1;
27574   {
27575     try {
27576       delete arg1;
27577     } CALL_CATCH_EXCEPTION();
27578   }
27579
27580 }
27581
27582
27583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
27584   void * jresult ;
27585   Dali::PinchGestureDetector *arg1 = 0 ;
27586   Dali::PinchGestureDetector *result = 0 ;
27587
27588   arg1 = (Dali::PinchGestureDetector *)jarg1;
27589   if (!arg1) {
27590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
27591     return 0;
27592   }
27593   {
27594     try {
27595       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
27596     } CALL_CATCH_EXCEPTION(0);
27597   }
27598
27599   jresult = (void *)result;
27600   return jresult;
27601 }
27602
27603
27604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
27605   void * jresult ;
27606   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
27607   Dali::PinchGestureDetector *arg2 = 0 ;
27608   Dali::PinchGestureDetector *result = 0 ;
27609
27610   arg1 = (Dali::PinchGestureDetector *)jarg1;
27611   arg2 = (Dali::PinchGestureDetector *)jarg2;
27612   if (!arg2) {
27613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
27614     return 0;
27615   }
27616   {
27617     try {
27618       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
27619     } CALL_CATCH_EXCEPTION(0);
27620   }
27621
27622   jresult = (void *)result;
27623   return jresult;
27624 }
27625
27626
27627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
27628   void * jresult ;
27629   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
27630   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
27631
27632   arg1 = (Dali::PinchGestureDetector *)jarg1;
27633   {
27634     try {
27635       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27636     } CALL_CATCH_EXCEPTION(0);
27637   }
27638
27639   jresult = (void *)result;
27640   return jresult;
27641 }
27642
27643
27644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0() {
27645   void * jresult ;
27646   Dali::PinchGesture *result = 0 ;
27647
27648   {
27649     try {
27650       result = (Dali::PinchGesture *)new Dali::PinchGesture();
27651     } CALL_CATCH_EXCEPTION(0);
27652   }
27653
27654   jresult = (void *)result;
27655   return jresult;
27656 }
27657
27658
27659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_New(int jarg1) {
27660   void * jresult ;
27661   Dali::GestureState arg1 ;
27662   Dali::PinchGesture result;
27663
27664   arg1 = (Dali::GestureState)jarg1;
27665   {
27666     try {
27667       result = DevelPinchGesture::New(arg1);
27668     } CALL_CATCH_EXCEPTION(0);
27669   }
27670
27671   jresult = new Dali::PinchGesture((const Dali::PinchGesture &)result);
27672   return jresult;
27673 }
27674
27675
27676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
27677   void * jresult ;
27678   Dali::PinchGesture *arg1 = 0 ;
27679   Dali::PinchGesture *result = 0 ;
27680
27681   arg1 = (Dali::PinchGesture *)jarg1;
27682   if (!arg1) {
27683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
27684     return 0;
27685   }
27686   {
27687     try {
27688       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
27689     } CALL_CATCH_EXCEPTION(0);
27690   }
27691
27692   jresult = (void *)result;
27693   return jresult;
27694 }
27695
27696
27697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
27698   void * jresult ;
27699   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
27700   Dali::PinchGesture *arg2 = 0 ;
27701   Dali::PinchGesture *result = 0 ;
27702
27703   arg1 = (Dali::PinchGesture *)jarg1;
27704   arg2 = (Dali::PinchGesture *)jarg2;
27705   if (!arg2) {
27706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
27707     return 0;
27708   }
27709   {
27710     try {
27711       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
27712     } CALL_CATCH_EXCEPTION(0);
27713   }
27714
27715   jresult = (void *)result;
27716   return jresult;
27717 }
27718
27719
27720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
27721   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
27722
27723   arg1 = (Dali::PinchGesture *)jarg1;
27724   {
27725     try {
27726       delete arg1;
27727     } CALL_CATCH_EXCEPTION();
27728   }
27729
27730 }
27731
27732
27733 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
27734   float jresult ;
27735   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
27736   float result;
27737
27738   arg1 = (Dali::PinchGesture *)jarg1;
27739   result = (float) ((arg1)->GetScale());
27740   jresult = result;
27741   return jresult;
27742 }
27743
27744
27745 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
27746   float jresult ;
27747   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
27748   float result;
27749
27750   arg1 = (Dali::PinchGesture *)jarg1;
27751   result = (float) ((arg1)->GetSpeed());
27752   jresult = result;
27753   return jresult;
27754 }
27755
27756
27757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
27758   void * jresult ;
27759   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
27760   Dali::Vector2 result;
27761
27762   arg1 = (Dali::PinchGesture *)jarg1;
27763   {
27764     try {
27765       result = ((Dali::PinchGesture const *)arg1)->GetScreenCenterPoint();
27766     } catch (std::out_of_range& e) {
27767       {
27768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27769       };
27770     } catch (std::exception& e) {
27771       {
27772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27773       };
27774     } catch (Dali::DaliException e) {
27775       {
27776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27777       };
27778     } catch (...) {
27779       {
27780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27781       };
27782     }
27783   }
27784   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
27785   return jresult;
27786 }
27787
27788
27789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
27790   void * jresult ;
27791   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
27792   Dali::Vector2 result;
27793
27794   arg1 = (Dali::PinchGesture *)jarg1;
27795   {
27796     try {
27797       result = ((Dali::PinchGesture const *)arg1)->GetLocalCenterPoint();
27798     } catch (std::out_of_range& e) {
27799       {
27800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27801       };
27802     } catch (std::exception& e) {
27803       {
27804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27805       };
27806     } catch (Dali::DaliException e) {
27807       {
27808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27809       };
27810     } catch (...) {
27811       {
27812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27813       };
27814     }
27815   }
27816   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
27817   return jresult;
27818 }
27819
27820
27821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
27822   void * jresult ;
27823   Dali::TapGestureDetector *result = 0 ;
27824
27825   {
27826     try {
27827       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
27828     } CALL_CATCH_EXCEPTION(0);
27829   }
27830
27831   jresult = (void *)result;
27832   return jresult;
27833 }
27834
27835
27836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
27837   void * jresult ;
27838   Dali::TapGestureDetector result;
27839
27840   {
27841     try {
27842       result = Dali::TapGestureDetector::New();
27843     } CALL_CATCH_EXCEPTION(0);
27844   }
27845
27846   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
27847   return jresult;
27848 }
27849
27850
27851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
27852   void * jresult ;
27853   unsigned int arg1 ;
27854   Dali::TapGestureDetector result;
27855
27856   arg1 = (unsigned int)jarg1;
27857   {
27858     try {
27859       result = Dali::TapGestureDetector::New(arg1);
27860     } CALL_CATCH_EXCEPTION(0);
27861   }
27862
27863   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
27864   return jresult;
27865 }
27866
27867
27868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
27869   void * jresult ;
27870   Dali::BaseHandle arg1 ;
27871   Dali::BaseHandle *argp1 ;
27872   Dali::TapGestureDetector result;
27873
27874   argp1 = (Dali::BaseHandle *)jarg1;
27875   if (!argp1) {
27876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27877     return 0;
27878   }
27879   arg1 = *argp1;
27880   {
27881     try {
27882       result = Dali::TapGestureDetector::DownCast(arg1);
27883     } CALL_CATCH_EXCEPTION(0);
27884   }
27885
27886   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
27887   return jresult;
27888 }
27889
27890
27891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
27892   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
27893
27894   arg1 = (Dali::TapGestureDetector *)jarg1;
27895   {
27896     try {
27897       delete arg1;
27898     } CALL_CATCH_EXCEPTION();
27899   }
27900
27901 }
27902
27903
27904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
27905   void * jresult ;
27906   Dali::TapGestureDetector *arg1 = 0 ;
27907   Dali::TapGestureDetector *result = 0 ;
27908
27909   arg1 = (Dali::TapGestureDetector *)jarg1;
27910   if (!arg1) {
27911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
27912     return 0;
27913   }
27914   {
27915     try {
27916       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
27917     } CALL_CATCH_EXCEPTION(0);
27918   }
27919
27920   jresult = (void *)result;
27921   return jresult;
27922 }
27923
27924
27925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
27926   void * jresult ;
27927   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
27928   Dali::TapGestureDetector *arg2 = 0 ;
27929   Dali::TapGestureDetector *result = 0 ;
27930
27931   arg1 = (Dali::TapGestureDetector *)jarg1;
27932   arg2 = (Dali::TapGestureDetector *)jarg2;
27933   if (!arg2) {
27934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
27935     return 0;
27936   }
27937   {
27938     try {
27939       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
27940     } CALL_CATCH_EXCEPTION(0);
27941   }
27942
27943   jresult = (void *)result;
27944   return jresult;
27945 }
27946
27947
27948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
27949   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
27950   unsigned int arg2 ;
27951
27952   arg1 = (Dali::TapGestureDetector *)jarg1;
27953   arg2 = (unsigned int)jarg2;
27954   {
27955     try {
27956       (arg1)->SetMinimumTapsRequired(arg2);
27957     } CALL_CATCH_EXCEPTION();
27958   }
27959
27960 }
27961
27962
27963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
27964   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
27965   unsigned int arg2 ;
27966
27967   arg1 = (Dali::TapGestureDetector *)jarg1;
27968   arg2 = (unsigned int)jarg2;
27969   {
27970     try {
27971       (arg1)->SetMaximumTapsRequired(arg2);
27972     } CALL_CATCH_EXCEPTION();
27973   }
27974
27975 }
27976
27977
27978 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
27979   unsigned int jresult ;
27980   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
27981   unsigned int result;
27982
27983   arg1 = (Dali::TapGestureDetector *)jarg1;
27984   {
27985     try {
27986       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
27987     } CALL_CATCH_EXCEPTION(0);
27988   }
27989
27990   jresult = result;
27991   return jresult;
27992 }
27993
27994
27995 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
27996   unsigned int jresult ;
27997   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
27998   unsigned int result;
27999
28000   arg1 = (Dali::TapGestureDetector *)jarg1;
28001   {
28002     try {
28003       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
28004     } CALL_CATCH_EXCEPTION(0);
28005   }
28006
28007   jresult = result;
28008   return jresult;
28009 }
28010
28011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_ReceiveAllTapEvents(void * tapGestureDetector, bool isReceive) {
28012   Dali::TapGestureDetector *detector = (Dali::TapGestureDetector *) 0 ;
28013
28014   detector = (Dali::TapGestureDetector *)tapGestureDetector;
28015   if (!detector) {
28016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
28017     return;
28018   }
28019   {
28020     try {
28021       (detector)->ReceiveAllTapEvents(isReceive);
28022     } CALL_CATCH_EXCEPTION();
28023   }
28024
28025 }
28026
28027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
28028   void * jresult ;
28029   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
28030   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
28031
28032   arg1 = (Dali::TapGestureDetector *)jarg1;
28033   {
28034     try {
28035       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
28036     } CALL_CATCH_EXCEPTION(0);
28037   }
28038
28039   jresult = (void *)result;
28040   return jresult;
28041 }
28042
28043
28044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
28045   void * jresult ;
28046   Dali::TapGesture *result = 0 ;
28047
28048   {
28049     try {
28050       result = (Dali::TapGesture *)new Dali::TapGesture();
28051     } CALL_CATCH_EXCEPTION(0);
28052   }
28053
28054   jresult = (void *)result;
28055   return jresult;
28056 }
28057
28058
28059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_New(int jarg1) {
28060   void * jresult ;
28061   Dali::GestureState arg1 ;
28062   Dali::TapGesture result;
28063
28064   arg1 = (Dali::GestureState)jarg1;
28065   {
28066     try {
28067       result = DevelTapGesture::New(arg1);
28068     } CALL_CATCH_EXCEPTION(0);
28069   }
28070
28071   jresult = new Dali::TapGesture((const Dali::TapGesture &)result);
28072   return jresult;
28073 }
28074
28075
28076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
28077   void * jresult ;
28078   Dali::TapGesture *arg1 = 0 ;
28079   Dali::TapGesture *result = 0 ;
28080
28081   arg1 = (Dali::TapGesture *)jarg1;
28082   if (!arg1) {
28083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
28084     return 0;
28085   }
28086   {
28087     try {
28088       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
28089     } CALL_CATCH_EXCEPTION(0);
28090   }
28091
28092   jresult = (void *)result;
28093   return jresult;
28094 }
28095
28096
28097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
28098   void * jresult ;
28099   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
28100   Dali::TapGesture *arg2 = 0 ;
28101   Dali::TapGesture *result = 0 ;
28102
28103   arg1 = (Dali::TapGesture *)jarg1;
28104   arg2 = (Dali::TapGesture *)jarg2;
28105   if (!arg2) {
28106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
28107     return 0;
28108   }
28109   {
28110     try {
28111       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
28112     } CALL_CATCH_EXCEPTION(0);
28113   }
28114
28115   jresult = (void *)result;
28116   return jresult;
28117 }
28118
28119
28120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
28121   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
28122
28123   arg1 = (Dali::TapGesture *)jarg1;
28124   {
28125     try {
28126       delete arg1;
28127     } CALL_CATCH_EXCEPTION();
28128   }
28129
28130 }
28131
28132
28133 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
28134   unsigned int jresult ;
28135   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
28136   unsigned int result;
28137
28138   arg1 = (Dali::TapGesture *)jarg1;
28139   result = (unsigned int) ((arg1)->GetNumberOfTaps());
28140   jresult = result;
28141   return jresult;
28142 }
28143
28144 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
28145   unsigned int jresult ;
28146   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
28147   unsigned int result;
28148
28149   arg1 = (Dali::TapGesture *)jarg1;
28150   result = (unsigned int) ((arg1)->GetNumberOfTouches());
28151   jresult = result;
28152   return jresult;
28153 }
28154
28155
28156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
28157   void * jresult ;
28158   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
28159   Dali::Vector2 result;
28160
28161   arg1 = (Dali::TapGesture *)jarg1;
28162   {
28163     try {
28164       result = ((Dali::TapGesture const *)arg1)->GetScreenPoint();
28165     } catch (std::out_of_range& e) {
28166       {
28167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28168       };
28169     } catch (std::exception& e) {
28170       {
28171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28172       };
28173     } catch (Dali::DaliException e) {
28174       {
28175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28176       };
28177     } catch (...) {
28178       {
28179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28180       };
28181     }
28182   }
28183   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28184   return jresult;
28185 }
28186
28187
28188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
28189   void * jresult ;
28190   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
28191   Dali::Vector2 result;
28192
28193   arg1 = (Dali::TapGesture *)jarg1;
28194   {
28195     try {
28196       result = ((Dali::TapGesture const *)arg1)->GetLocalPoint();
28197     } catch (std::out_of_range& e) {
28198       {
28199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28200       };
28201     } catch (std::exception& e) {
28202       {
28203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28204       };
28205     } catch (Dali::DaliException e) {
28206       {
28207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28208       };
28209     } catch (...) {
28210       {
28211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28212       };
28213     }
28214   }
28215   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28216   return jresult;
28217 }
28218
28219
28220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
28221   void * jresult ;
28222   Dali::AlphaFunction *result = 0 ;
28223
28224   {
28225     try {
28226       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
28227     } CALL_CATCH_EXCEPTION(0);
28228   }
28229
28230   jresult = (void *)result;
28231   return jresult;
28232 }
28233
28234
28235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
28236   void * jresult ;
28237   Dali::AlphaFunction::BuiltinFunction arg1 ;
28238   Dali::AlphaFunction *result = 0 ;
28239
28240   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
28241   {
28242     try {
28243       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
28244     } CALL_CATCH_EXCEPTION(0);
28245   }
28246
28247   jresult = (void *)result;
28248   return jresult;
28249 }
28250
28251
28252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
28253   void * jresult ;
28254   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
28255   Dali::AlphaFunction *result = 0 ;
28256
28257   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
28258   {
28259     try {
28260       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
28261     } CALL_CATCH_EXCEPTION(0);
28262   }
28263
28264   jresult = (void *)result;
28265   return jresult;
28266 }
28267
28268
28269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
28270   void * jresult ;
28271   Dali::Vector2 *arg1 = 0 ;
28272   Dali::Vector2 *arg2 = 0 ;
28273   Dali::AlphaFunction *result = 0 ;
28274
28275   arg1 = (Dali::Vector2 *)jarg1;
28276   if (!arg1) {
28277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
28278     return 0;
28279   }
28280   arg2 = (Dali::Vector2 *)jarg2;
28281   if (!arg2) {
28282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
28283     return 0;
28284   }
28285   {
28286     try {
28287       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
28288     } CALL_CATCH_EXCEPTION(0);
28289   }
28290
28291   jresult = (void *)result;
28292   return jresult;
28293 }
28294
28295
28296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
28297   void * jresult ;
28298   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
28299   Dali::Vector4 result;
28300
28301   arg1 = (Dali::AlphaFunction *)jarg1;
28302   {
28303     try {
28304       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
28305     } CALL_CATCH_EXCEPTION(0);
28306   }
28307
28308   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
28309   return jresult;
28310 }
28311
28312
28313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
28314   void * jresult ;
28315   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
28316   Dali::AlphaFunctionPrototype result;
28317
28318   arg1 = (Dali::AlphaFunction *)jarg1;
28319   {
28320     try {
28321       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
28322     } CALL_CATCH_EXCEPTION(0);
28323   }
28324
28325   jresult = (void *)result;
28326   return jresult;
28327 }
28328
28329
28330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
28331   int jresult ;
28332   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
28333   Dali::AlphaFunction::BuiltinFunction result;
28334
28335   arg1 = (Dali::AlphaFunction *)jarg1;
28336   {
28337     try {
28338       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
28339     } CALL_CATCH_EXCEPTION(0);
28340   }
28341
28342   jresult = (int)result;
28343   return jresult;
28344 }
28345
28346
28347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
28348   int jresult ;
28349   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
28350   Dali::AlphaFunction::Mode result;
28351
28352   arg1 = (Dali::AlphaFunction *)jarg1;
28353   {
28354     try {
28355       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
28356     } CALL_CATCH_EXCEPTION(0);
28357   }
28358
28359   jresult = (int)result;
28360   return jresult;
28361 }
28362
28363
28364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
28365   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
28366
28367   arg1 = (Dali::AlphaFunction *)jarg1;
28368   {
28369     try {
28370       delete arg1;
28371     } CALL_CATCH_EXCEPTION();
28372   }
28373
28374 }
28375
28376
28377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
28378   void * jresult ;
28379   Dali::KeyFrames result;
28380
28381   {
28382     try {
28383       result = Dali::KeyFrames::New();
28384     } CALL_CATCH_EXCEPTION(0);
28385   }
28386
28387   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
28388   return jresult;
28389 }
28390
28391
28392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
28393   void * jresult ;
28394   Dali::BaseHandle arg1 ;
28395   Dali::BaseHandle *argp1 ;
28396   Dali::KeyFrames result;
28397
28398   argp1 = (Dali::BaseHandle *)jarg1;
28399   if (!argp1) {
28400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28401     return 0;
28402   }
28403   arg1 = *argp1;
28404   {
28405     try {
28406       result = Dali::KeyFrames::DownCast(arg1);
28407     } CALL_CATCH_EXCEPTION(0);
28408   }
28409
28410   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
28411   return jresult;
28412 }
28413
28414
28415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
28416   void * jresult ;
28417   Dali::KeyFrames *result = 0 ;
28418
28419   {
28420     try {
28421       result = (Dali::KeyFrames *)new Dali::KeyFrames();
28422     } CALL_CATCH_EXCEPTION(0);
28423   }
28424
28425   jresult = (void *)result;
28426   return jresult;
28427 }
28428
28429
28430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
28431   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
28432
28433   arg1 = (Dali::KeyFrames *)jarg1;
28434   {
28435     try {
28436       delete arg1;
28437     } CALL_CATCH_EXCEPTION();
28438   }
28439
28440 }
28441
28442
28443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
28444   void * jresult ;
28445   Dali::KeyFrames *arg1 = 0 ;
28446   Dali::KeyFrames *result = 0 ;
28447
28448   arg1 = (Dali::KeyFrames *)jarg1;
28449   if (!arg1) {
28450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
28451     return 0;
28452   }
28453   {
28454     try {
28455       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
28456     } CALL_CATCH_EXCEPTION(0);
28457   }
28458
28459   jresult = (void *)result;
28460   return jresult;
28461 }
28462
28463
28464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
28465   void * jresult ;
28466   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
28467   Dali::KeyFrames *arg2 = 0 ;
28468   Dali::KeyFrames *result = 0 ;
28469
28470   arg1 = (Dali::KeyFrames *)jarg1;
28471   arg2 = (Dali::KeyFrames *)jarg2;
28472   if (!arg2) {
28473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
28474     return 0;
28475   }
28476   {
28477     try {
28478       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
28479     } CALL_CATCH_EXCEPTION(0);
28480   }
28481
28482   jresult = (void *)result;
28483   return jresult;
28484 }
28485
28486
28487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
28488   int jresult ;
28489   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
28490   Dali::Property::Type result;
28491
28492   arg1 = (Dali::KeyFrames *)jarg1;
28493   {
28494     try {
28495       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
28496     } CALL_CATCH_EXCEPTION(0);
28497   }
28498
28499   jresult = (int)result;
28500   return jresult;
28501 }
28502
28503
28504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
28505   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
28506   float arg2 ;
28507   Dali::Property::Value arg3 ;
28508   Dali::Property::Value *argp3 ;
28509
28510   arg1 = (Dali::KeyFrames *)jarg1;
28511   arg2 = (float)jarg2;
28512   argp3 = (Dali::Property::Value *)jarg3;
28513   if (!argp3) {
28514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
28515     return ;
28516   }
28517   arg3 = *argp3;
28518   {
28519     try {
28520       (arg1)->Add(arg2,arg3);
28521     } CALL_CATCH_EXCEPTION();
28522   }
28523
28524 }
28525
28526
28527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
28528   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
28529   float arg2 ;
28530   Dali::Property::Value arg3 ;
28531   Dali::AlphaFunction arg4 ;
28532   Dali::Property::Value *argp3 ;
28533   Dali::AlphaFunction *argp4 ;
28534
28535   arg1 = (Dali::KeyFrames *)jarg1;
28536   arg2 = (float)jarg2;
28537   argp3 = (Dali::Property::Value *)jarg3;
28538   if (!argp3) {
28539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
28540     return ;
28541   }
28542   arg3 = *argp3;
28543   argp4 = (Dali::AlphaFunction *)jarg4;
28544   if (!argp4) {
28545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
28546     return ;
28547   }
28548   arg4 = *argp4;
28549   {
28550     try {
28551       (arg1)->Add(arg2,arg3,arg4);
28552     } CALL_CATCH_EXCEPTION();
28553   }
28554
28555 }
28556
28557 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyFrames_GetKeyFrameCount(void* keyFrames)
28558 {
28559   return (unsigned int) Dali::DevelKeyFrames::GetKeyFrameCount(*((Dali::KeyFrames*)keyFrames));
28560 }
28561
28562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_GetKeyFrame(void* keyFrames, unsigned int index, float* time, void* value)
28563 {
28564   Dali::DevelKeyFrames::GetKeyFrame(*((Dali::KeyFrames*)keyFrames), (size_t)index, *time, *((Property::Value*)value));
28565 }
28566
28567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
28568   int jresult ;
28569   int result;
28570
28571   result = (int)Dali::Path::Property::POINTS;
28572   jresult = (int)result;
28573   return jresult;
28574 }
28575
28576
28577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
28578   int jresult ;
28579   int result;
28580
28581   result = (int)Dali::Path::Property::CONTROL_POINTS;
28582   jresult = (int)result;
28583   return jresult;
28584 }
28585
28586
28587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
28588   void * jresult ;
28589   Dali::Path::Property *result = 0 ;
28590
28591   {
28592     try {
28593       result = (Dali::Path::Property *)new Dali::Path::Property();
28594     } CALL_CATCH_EXCEPTION(0);
28595   }
28596
28597   jresult = (void *)result;
28598   return jresult;
28599 }
28600
28601
28602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
28603   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
28604
28605   arg1 = (Dali::Path::Property *)jarg1;
28606   {
28607     try {
28608       delete arg1;
28609     } CALL_CATCH_EXCEPTION();
28610   }
28611
28612 }
28613
28614
28615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
28616   void * jresult ;
28617   Dali::Path result;
28618
28619   {
28620     try {
28621       result = Dali::Path::New();
28622     } CALL_CATCH_EXCEPTION(0);
28623   }
28624
28625   jresult = new Dali::Path((const Dali::Path &)result);
28626   return jresult;
28627 }
28628
28629
28630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
28631   void * jresult ;
28632   Dali::BaseHandle arg1 ;
28633   Dali::BaseHandle *argp1 ;
28634   Dali::Path result;
28635
28636   argp1 = (Dali::BaseHandle *)jarg1;
28637   if (!argp1) {
28638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28639     return 0;
28640   }
28641   arg1 = *argp1;
28642   {
28643     try {
28644       result = Dali::Path::DownCast(arg1);
28645     } CALL_CATCH_EXCEPTION(0);
28646   }
28647
28648   jresult = new Dali::Path((const Dali::Path &)result);
28649   return jresult;
28650 }
28651
28652
28653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
28654   void * jresult ;
28655   Dali::Path *result = 0 ;
28656
28657   {
28658     try {
28659       result = (Dali::Path *)new Dali::Path();
28660     } CALL_CATCH_EXCEPTION(0);
28661   }
28662
28663   jresult = (void *)result;
28664   return jresult;
28665 }
28666
28667
28668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
28669   Dali::Path *arg1 = (Dali::Path *) 0 ;
28670
28671   arg1 = (Dali::Path *)jarg1;
28672   {
28673     try {
28674       delete arg1;
28675     } CALL_CATCH_EXCEPTION();
28676   }
28677
28678 }
28679
28680
28681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
28682   void * jresult ;
28683   Dali::Path *arg1 = 0 ;
28684   Dali::Path *result = 0 ;
28685
28686   arg1 = (Dali::Path *)jarg1;
28687   if (!arg1) {
28688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
28689     return 0;
28690   }
28691   {
28692     try {
28693       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
28694     } CALL_CATCH_EXCEPTION(0);
28695   }
28696
28697   jresult = (void *)result;
28698   return jresult;
28699 }
28700
28701
28702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
28703   void * jresult ;
28704   Dali::Path *arg1 = (Dali::Path *) 0 ;
28705   Dali::Path *arg2 = 0 ;
28706   Dali::Path *result = 0 ;
28707
28708   arg1 = (Dali::Path *)jarg1;
28709   arg2 = (Dali::Path *)jarg2;
28710   if (!arg2) {
28711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
28712     return 0;
28713   }
28714   {
28715     try {
28716       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
28717     } CALL_CATCH_EXCEPTION(0);
28718   }
28719
28720   jresult = (void *)result;
28721   return jresult;
28722 }
28723
28724
28725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
28726   Dali::Path *arg1 = (Dali::Path *) 0 ;
28727   Dali::Vector3 *arg2 = 0 ;
28728
28729   arg1 = (Dali::Path *)jarg1;
28730   arg2 = (Dali::Vector3 *)jarg2;
28731   if (!arg2) {
28732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
28733     return ;
28734   }
28735   {
28736     try {
28737       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
28738     } CALL_CATCH_EXCEPTION();
28739   }
28740
28741 }
28742
28743
28744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
28745   Dali::Path *arg1 = (Dali::Path *) 0 ;
28746   Dali::Vector3 *arg2 = 0 ;
28747
28748   arg1 = (Dali::Path *)jarg1;
28749   arg2 = (Dali::Vector3 *)jarg2;
28750   if (!arg2) {
28751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
28752     return ;
28753   }
28754   {
28755     try {
28756       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
28757     } CALL_CATCH_EXCEPTION();
28758   }
28759
28760 }
28761
28762
28763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
28764   Dali::Path *arg1 = (Dali::Path *) 0 ;
28765   float arg2 ;
28766
28767   arg1 = (Dali::Path *)jarg1;
28768   arg2 = (float)jarg2;
28769   {
28770     try {
28771       (arg1)->GenerateControlPoints(arg2);
28772     } CALL_CATCH_EXCEPTION();
28773   }
28774
28775 }
28776
28777
28778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
28779   Dali::Path *arg1 = (Dali::Path *) 0 ;
28780   float arg2 ;
28781   Dali::Vector3 *arg3 = 0 ;
28782   Dali::Vector3 *arg4 = 0 ;
28783
28784   arg1 = (Dali::Path *)jarg1;
28785   arg2 = (float)jarg2;
28786   arg3 = (Dali::Vector3 *)jarg3;
28787   if (!arg3) {
28788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
28789     return ;
28790   }
28791   arg4 = (Dali::Vector3 *)jarg4;
28792   if (!arg4) {
28793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
28794     return ;
28795   }
28796   {
28797     try {
28798       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
28799     } CALL_CATCH_EXCEPTION();
28800   }
28801
28802 }
28803
28804
28805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
28806   void * jresult ;
28807   Dali::Path *arg1 = (Dali::Path *) 0 ;
28808   size_t arg2 ;
28809   Dali::Vector3 *result = 0 ;
28810
28811   arg1 = (Dali::Path *)jarg1;
28812   arg2 = (size_t)jarg2;
28813   {
28814     try {
28815       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
28816     } CALL_CATCH_EXCEPTION(0);
28817   }
28818
28819   jresult = (void *)result;
28820   return jresult;
28821 }
28822
28823
28824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
28825   void * jresult ;
28826   Dali::Path *arg1 = (Dali::Path *) 0 ;
28827   size_t arg2 ;
28828   Dali::Vector3 *result = 0 ;
28829
28830   arg1 = (Dali::Path *)jarg1;
28831   arg2 = (size_t)jarg2;
28832   {
28833     try {
28834       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
28835     } CALL_CATCH_EXCEPTION(0);
28836   }
28837
28838   jresult = (void *)result;
28839   return jresult;
28840 }
28841
28842
28843 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
28844   unsigned long jresult ;
28845   Dali::Path *arg1 = (Dali::Path *) 0 ;
28846   size_t result;
28847
28848   arg1 = (Dali::Path *)jarg1;
28849   {
28850     try {
28851       result = ((Dali::Path const *)arg1)->GetPointCount();
28852     } CALL_CATCH_EXCEPTION(0);
28853   }
28854
28855   jresult = (unsigned long)result;
28856   return jresult;
28857 }
28858
28859
28860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
28861   void * jresult ;
28862   float arg1 ;
28863   Dali::TimePeriod *result = 0 ;
28864
28865   arg1 = (float)jarg1;
28866   {
28867     try {
28868       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
28869     } CALL_CATCH_EXCEPTION(0);
28870   }
28871
28872   jresult = (void *)result;
28873   return jresult;
28874 }
28875
28876
28877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
28878   void * jresult ;
28879   float arg1 ;
28880   float arg2 ;
28881   Dali::TimePeriod *result = 0 ;
28882
28883   arg1 = (float)jarg1;
28884   arg2 = (float)jarg2;
28885   {
28886     try {
28887       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
28888     } CALL_CATCH_EXCEPTION(0);
28889   }
28890
28891   jresult = (void *)result;
28892   return jresult;
28893 }
28894
28895
28896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
28897   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
28898
28899   arg1 = (Dali::TimePeriod *)jarg1;
28900   {
28901     try {
28902       delete arg1;
28903     } CALL_CATCH_EXCEPTION();
28904   }
28905
28906 }
28907
28908
28909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
28910   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
28911   float arg2 ;
28912
28913   arg1 = (Dali::TimePeriod *)jarg1;
28914   arg2 = (float)jarg2;
28915   if (arg1) (arg1)->delaySeconds = arg2;
28916 }
28917
28918
28919 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
28920   float jresult ;
28921   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
28922   float result;
28923
28924   arg1 = (Dali::TimePeriod *)jarg1;
28925   result = (float) ((arg1)->delaySeconds);
28926   jresult = result;
28927   return jresult;
28928 }
28929
28930
28931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
28932   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
28933   float arg2 ;
28934
28935   arg1 = (Dali::TimePeriod *)jarg1;
28936   arg2 = (float)jarg2;
28937   if (arg1) (arg1)->durationSeconds = arg2;
28938 }
28939
28940
28941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
28942   float jresult ;
28943   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
28944   float result;
28945
28946   arg1 = (Dali::TimePeriod *)jarg1;
28947   result = (float) ((arg1)->durationSeconds);
28948   jresult = result;
28949   return jresult;
28950 }
28951
28952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
28953   int jresult ;
28954   int result;
28955
28956   result = (int)Dali::LinearConstrainer::Property::VALUE;
28957   jresult = (int)result;
28958   return jresult;
28959 }
28960
28961
28962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
28963   int jresult ;
28964   int result;
28965
28966   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
28967   jresult = (int)result;
28968   return jresult;
28969 }
28970
28971
28972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
28973   void * jresult ;
28974   Dali::LinearConstrainer::Property *result = 0 ;
28975
28976   {
28977     try {
28978       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
28979     } CALL_CATCH_EXCEPTION(0);
28980   }
28981
28982   jresult = (void *)result;
28983   return jresult;
28984 }
28985
28986
28987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
28988   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
28989
28990   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
28991   {
28992     try {
28993       delete arg1;
28994     } CALL_CATCH_EXCEPTION();
28995   }
28996
28997 }
28998
28999
29000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
29001   void * jresult ;
29002   Dali::LinearConstrainer result;
29003
29004   {
29005     try {
29006       result = Dali::LinearConstrainer::New();
29007     } CALL_CATCH_EXCEPTION(0);
29008   }
29009
29010   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
29011   return jresult;
29012 }
29013
29014
29015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
29016   void * jresult ;
29017   Dali::BaseHandle arg1 ;
29018   Dali::BaseHandle *argp1 ;
29019   Dali::LinearConstrainer result;
29020
29021   argp1 = (Dali::BaseHandle *)jarg1;
29022   if (!argp1) {
29023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29024     return 0;
29025   }
29026   arg1 = *argp1;
29027   {
29028     try {
29029       result = Dali::LinearConstrainer::DownCast(arg1);
29030     } CALL_CATCH_EXCEPTION(0);
29031   }
29032
29033   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
29034   return jresult;
29035 }
29036
29037
29038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
29039   void * jresult ;
29040   Dali::LinearConstrainer *result = 0 ;
29041
29042   {
29043     try {
29044       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
29045     } CALL_CATCH_EXCEPTION(0);
29046   }
29047
29048   jresult = (void *)result;
29049   return jresult;
29050 }
29051
29052
29053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
29054   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
29055
29056   arg1 = (Dali::LinearConstrainer *)jarg1;
29057   {
29058     try {
29059       delete arg1;
29060     } CALL_CATCH_EXCEPTION();
29061   }
29062
29063 }
29064
29065
29066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
29067   void * jresult ;
29068   Dali::LinearConstrainer *arg1 = 0 ;
29069   Dali::LinearConstrainer *result = 0 ;
29070
29071   arg1 = (Dali::LinearConstrainer *)jarg1;
29072   if (!arg1) {
29073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
29074     return 0;
29075   }
29076   {
29077     try {
29078       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
29079     } CALL_CATCH_EXCEPTION(0);
29080   }
29081
29082   jresult = (void *)result;
29083   return jresult;
29084 }
29085
29086
29087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
29088   void * jresult ;
29089   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
29090   Dali::LinearConstrainer *arg2 = 0 ;
29091   Dali::LinearConstrainer *result = 0 ;
29092
29093   arg1 = (Dali::LinearConstrainer *)jarg1;
29094   arg2 = (Dali::LinearConstrainer *)jarg2;
29095   if (!arg2) {
29096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
29097     return 0;
29098   }
29099   {
29100     try {
29101       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
29102     } CALL_CATCH_EXCEPTION(0);
29103   }
29104
29105   jresult = (void *)result;
29106   return jresult;
29107 }
29108
29109
29110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
29111   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
29112   SwigValueWrapper< Dali::Property > arg2 ;
29113   SwigValueWrapper< Dali::Property > arg3 ;
29114   Dali::Vector2 *arg4 = 0 ;
29115   Dali::Vector2 *arg5 = 0 ;
29116   Dali::Property *argp2 ;
29117   Dali::Property *argp3 ;
29118
29119   arg1 = (Dali::LinearConstrainer *)jarg1;
29120   argp2 = (Dali::Property *)jarg2;
29121   if (!argp2) {
29122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
29123     return ;
29124   }
29125   arg2 = *argp2;
29126   argp3 = (Dali::Property *)jarg3;
29127   if (!argp3) {
29128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
29129     return ;
29130   }
29131   arg3 = *argp3;
29132   arg4 = (Dali::Vector2 *)jarg4;
29133   if (!arg4) {
29134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29135     return ;
29136   }
29137   arg5 = (Dali::Vector2 *)jarg5;
29138   if (!arg5) {
29139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29140     return ;
29141   }
29142   {
29143     try {
29144       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
29145     } CALL_CATCH_EXCEPTION();
29146   }
29147
29148 }
29149
29150
29151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
29152   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
29153   SwigValueWrapper< Dali::Property > arg2 ;
29154   SwigValueWrapper< Dali::Property > arg3 ;
29155   Dali::Vector2 *arg4 = 0 ;
29156   Dali::Property *argp2 ;
29157   Dali::Property *argp3 ;
29158
29159   arg1 = (Dali::LinearConstrainer *)jarg1;
29160   argp2 = (Dali::Property *)jarg2;
29161   if (!argp2) {
29162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
29163     return ;
29164   }
29165   arg2 = *argp2;
29166   argp3 = (Dali::Property *)jarg3;
29167   if (!argp3) {
29168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
29169     return ;
29170   }
29171   arg3 = *argp3;
29172   arg4 = (Dali::Vector2 *)jarg4;
29173   if (!arg4) {
29174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29175     return ;
29176   }
29177   {
29178     try {
29179       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
29180     } CALL_CATCH_EXCEPTION();
29181   }
29182
29183 }
29184
29185
29186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
29187   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
29188   Dali::Handle *arg2 = 0 ;
29189
29190   arg1 = (Dali::LinearConstrainer *)jarg1;
29191   arg2 = (Dali::Handle *)jarg2;
29192   if (!arg2) {
29193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
29194     return ;
29195   }
29196   {
29197     try {
29198       (arg1)->Remove(*arg2);
29199     } CALL_CATCH_EXCEPTION();
29200   }
29201
29202 }
29203
29204
29205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
29206   int jresult ;
29207   int result;
29208
29209   result = (int)Dali::PathConstrainer::Property::FORWARD;
29210   jresult = (int)result;
29211   return jresult;
29212 }
29213
29214
29215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
29216   int jresult ;
29217   int result;
29218
29219   result = (int)Dali::PathConstrainer::Property::POINTS;
29220   jresult = (int)result;
29221   return jresult;
29222 }
29223
29224
29225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
29226   int jresult ;
29227   int result;
29228
29229   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
29230   jresult = (int)result;
29231   return jresult;
29232 }
29233
29234
29235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
29236   void * jresult ;
29237   Dali::PathConstrainer::Property *result = 0 ;
29238
29239   {
29240     try {
29241       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
29242     } CALL_CATCH_EXCEPTION(0);
29243   }
29244
29245   jresult = (void *)result;
29246   return jresult;
29247 }
29248
29249
29250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
29251   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
29252
29253   arg1 = (Dali::PathConstrainer::Property *)jarg1;
29254   {
29255     try {
29256       delete arg1;
29257     } CALL_CATCH_EXCEPTION();
29258   }
29259
29260 }
29261
29262
29263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
29264   void * jresult ;
29265   Dali::PathConstrainer result;
29266
29267   {
29268     try {
29269       result = Dali::PathConstrainer::New();
29270     } CALL_CATCH_EXCEPTION(0);
29271   }
29272
29273   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
29274   return jresult;
29275 }
29276
29277
29278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
29279   void * jresult ;
29280   Dali::BaseHandle arg1 ;
29281   Dali::BaseHandle *argp1 ;
29282   Dali::PathConstrainer result;
29283
29284   argp1 = (Dali::BaseHandle *)jarg1;
29285   if (!argp1) {
29286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29287     return 0;
29288   }
29289   arg1 = *argp1;
29290   {
29291     try {
29292       result = Dali::PathConstrainer::DownCast(arg1);
29293     } CALL_CATCH_EXCEPTION(0);
29294   }
29295
29296   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
29297   return jresult;
29298 }
29299
29300
29301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
29302   void * jresult ;
29303   Dali::PathConstrainer *result = 0 ;
29304
29305   {
29306     try {
29307       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
29308     } CALL_CATCH_EXCEPTION(0);
29309   }
29310
29311   jresult = (void *)result;
29312   return jresult;
29313 }
29314
29315
29316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
29317   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
29318
29319   arg1 = (Dali::PathConstrainer *)jarg1;
29320   {
29321     try {
29322       delete arg1;
29323     } CALL_CATCH_EXCEPTION();
29324   }
29325
29326 }
29327
29328
29329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
29330   void * jresult ;
29331   Dali::PathConstrainer *arg1 = 0 ;
29332   Dali::PathConstrainer *result = 0 ;
29333
29334   arg1 = (Dali::PathConstrainer *)jarg1;
29335   if (!arg1) {
29336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
29337     return 0;
29338   }
29339   {
29340     try {
29341       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
29342     } CALL_CATCH_EXCEPTION(0);
29343   }
29344
29345   jresult = (void *)result;
29346   return jresult;
29347 }
29348
29349
29350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
29351   void * jresult ;
29352   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
29353   Dali::PathConstrainer *arg2 = 0 ;
29354   Dali::PathConstrainer *result = 0 ;
29355
29356   arg1 = (Dali::PathConstrainer *)jarg1;
29357   arg2 = (Dali::PathConstrainer *)jarg2;
29358   if (!arg2) {
29359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
29360     return 0;
29361   }
29362   {
29363     try {
29364       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
29365     } CALL_CATCH_EXCEPTION(0);
29366   }
29367
29368   jresult = (void *)result;
29369   return jresult;
29370 }
29371
29372
29373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
29374   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
29375   SwigValueWrapper< Dali::Property > arg2 ;
29376   SwigValueWrapper< Dali::Property > arg3 ;
29377   Dali::Vector2 *arg4 = 0 ;
29378   Dali::Vector2 *arg5 = 0 ;
29379   Dali::Property *argp2 ;
29380   Dali::Property *argp3 ;
29381
29382   arg1 = (Dali::PathConstrainer *)jarg1;
29383   argp2 = (Dali::Property *)jarg2;
29384   if (!argp2) {
29385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
29386     return ;
29387   }
29388   arg2 = *argp2;
29389   argp3 = (Dali::Property *)jarg3;
29390   if (!argp3) {
29391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
29392     return ;
29393   }
29394   arg3 = *argp3;
29395   arg4 = (Dali::Vector2 *)jarg4;
29396   if (!arg4) {
29397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29398     return ;
29399   }
29400   arg5 = (Dali::Vector2 *)jarg5;
29401   if (!arg5) {
29402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29403     return ;
29404   }
29405   {
29406     try {
29407       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
29408     } CALL_CATCH_EXCEPTION();
29409   }
29410
29411 }
29412
29413
29414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
29415   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
29416   SwigValueWrapper< Dali::Property > arg2 ;
29417   SwigValueWrapper< Dali::Property > arg3 ;
29418   Dali::Vector2 *arg4 = 0 ;
29419   Dali::Property *argp2 ;
29420   Dali::Property *argp3 ;
29421
29422   arg1 = (Dali::PathConstrainer *)jarg1;
29423   argp2 = (Dali::Property *)jarg2;
29424   if (!argp2) {
29425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
29426     return ;
29427   }
29428   arg2 = *argp2;
29429   argp3 = (Dali::Property *)jarg3;
29430   if (!argp3) {
29431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
29432     return ;
29433   }
29434   arg3 = *argp3;
29435   arg4 = (Dali::Vector2 *)jarg4;
29436   if (!arg4) {
29437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29438     return ;
29439   }
29440   {
29441     try {
29442       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
29443     } CALL_CATCH_EXCEPTION();
29444   }
29445
29446 }
29447
29448
29449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
29450   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
29451   Dali::Handle *arg2 = 0 ;
29452
29453   arg1 = (Dali::PathConstrainer *)jarg1;
29454   arg2 = (Dali::Handle *)jarg2;
29455   if (!arg2) {
29456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
29457     return ;
29458   }
29459   {
29460     try {
29461       (arg1)->Remove(*arg2);
29462     } CALL_CATCH_EXCEPTION();
29463   }
29464
29465 }
29466
29467
29468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
29469   int jresult ;
29470   Dali::FittingMode::Type result;
29471
29472   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
29473   jresult = (int)result;
29474   return jresult;
29475 }
29476
29477
29478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
29479   int jresult ;
29480   Dali::SamplingMode::Type result;
29481
29482   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
29483   jresult = (int)result;
29484   return jresult;
29485 }
29486
29487
29488 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageInterface_CreateResource(void * jarg1) {
29489   bool jresult ;
29490   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
29491   bool result;
29492
29493   arg1 = (Dali::NativeImageInterface *)jarg1;
29494   {
29495     try {
29496       result = (bool)(arg1)->CreateResource();
29497     } CALL_CATCH_EXCEPTION(0);
29498   }
29499
29500   jresult = result;
29501   return jresult;
29502 }
29503
29504
29505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_DestroyResource(void * jarg1) {
29506   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
29507
29508   arg1 = (Dali::NativeImageInterface *)jarg1;
29509   {
29510     try {
29511       (arg1)->DestroyResource();
29512     } CALL_CATCH_EXCEPTION();
29513   }
29514
29515 }
29516
29517
29518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
29519   unsigned int jresult ;
29520   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
29521   unsigned int result;
29522
29523   arg1 = (Dali::NativeImageInterface *)jarg1;
29524   {
29525     try {
29526       result = (unsigned int)(arg1)->TargetTexture();
29527     } CALL_CATCH_EXCEPTION(0);
29528   }
29529
29530   jresult = result;
29531   return jresult;
29532 }
29533
29534
29535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
29536   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
29537
29538   arg1 = (Dali::NativeImageInterface *)jarg1;
29539   {
29540     try {
29541       (arg1)->PrepareTexture();
29542     } CALL_CATCH_EXCEPTION();
29543   }
29544
29545 }
29546
29547
29548 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
29549   unsigned int jresult ;
29550   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
29551   unsigned int result;
29552
29553   arg1 = (Dali::NativeImageInterface *)jarg1;
29554   {
29555     try {
29556       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
29557     } CALL_CATCH_EXCEPTION(0);
29558   }
29559
29560   jresult = result;
29561   return jresult;
29562 }
29563
29564
29565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
29566   unsigned int jresult ;
29567   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
29568   unsigned int result;
29569
29570   arg1 = (Dali::NativeImageInterface *)jarg1;
29571   {
29572     try {
29573       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
29574     } CALL_CATCH_EXCEPTION(0);
29575   }
29576
29577   jresult = result;
29578   return jresult;
29579 }
29580
29581
29582 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
29583   bool jresult ;
29584   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
29585   bool result;
29586
29587   arg1 = (Dali::NativeImageInterface *)jarg1;
29588   {
29589     try {
29590       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
29591     } CALL_CATCH_EXCEPTION(0);
29592   }
29593
29594   jresult = result;
29595   return jresult;
29596 }
29597
29598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
29599   int jresult ;
29600   int result;
29601
29602   result = (int)Dali::CameraActor::Property::TYPE;
29603   jresult = (int)result;
29604   return jresult;
29605 }
29606
29607
29608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
29609   int jresult ;
29610   int result;
29611
29612   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
29613   jresult = (int)result;
29614   return jresult;
29615 }
29616
29617
29618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
29619   int jresult ;
29620   int result;
29621
29622   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
29623   jresult = (int)result;
29624   return jresult;
29625 }
29626
29627
29628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
29629   int jresult ;
29630   int result;
29631
29632   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
29633   jresult = (int)result;
29634   return jresult;
29635 }
29636
29637
29638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
29639   int jresult ;
29640   int result;
29641
29642   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
29643   jresult = (int)result;
29644   return jresult;
29645 }
29646
29647
29648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
29649   int jresult ;
29650   int result;
29651
29652   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
29653   jresult = (int)result;
29654   return jresult;
29655 }
29656
29657
29658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
29659   int jresult ;
29660   int result;
29661
29662   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
29663   jresult = (int)result;
29664   return jresult;
29665 }
29666
29667
29668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
29669   int jresult ;
29670   int result;
29671
29672   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
29673   jresult = (int)result;
29674   return jresult;
29675 }
29676
29677
29678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
29679   int jresult ;
29680   int result;
29681
29682   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
29683   jresult = (int)result;
29684   return jresult;
29685 }
29686
29687
29688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
29689   int jresult ;
29690   int result;
29691
29692   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
29693   jresult = (int)result;
29694   return jresult;
29695 }
29696
29697
29698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
29699   int jresult ;
29700   int result;
29701
29702   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
29703   jresult = (int)result;
29704   return jresult;
29705 }
29706
29707
29708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
29709   int jresult ;
29710   int result;
29711
29712   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
29713   jresult = (int)result;
29714   return jresult;
29715 }
29716
29717
29718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
29719   int jresult ;
29720   int result;
29721
29722   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
29723   jresult = (int)result;
29724   return jresult;
29725 }
29726
29727
29728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
29729   int jresult ;
29730   int result;
29731
29732   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
29733   jresult = (int)result;
29734   return jresult;
29735 }
29736
29737
29738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ORTHOGRAPHIC_SIZE_get() {
29739   int jresult ;
29740   int result;
29741
29742   result = (int)Dali::DevelCameraActor::Property::ORTHOGRAPHIC_SIZE;
29743   jresult = (int)result;
29744   return jresult;
29745 }
29746
29747
29748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_DIRECTION_get() {
29749   int jresult ;
29750   int result;
29751
29752   result = (int)Dali::DevelCameraActor::Property::PROJECTION_DIRECTION;
29753   jresult = (int)result;
29754   return jresult;
29755 }
29756
29757
29758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
29759   void * jresult ;
29760   Dali::CameraActor::Property *result = 0 ;
29761
29762   {
29763     try {
29764       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
29765     } CALL_CATCH_EXCEPTION(0);
29766   }
29767
29768   jresult = (void *)result;
29769   return jresult;
29770 }
29771
29772
29773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
29774   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
29775
29776   arg1 = (Dali::CameraActor::Property *)jarg1;
29777   {
29778     try {
29779       delete arg1;
29780     } CALL_CATCH_EXCEPTION();
29781   }
29782
29783 }
29784
29785
29786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
29787   void * jresult ;
29788   Dali::CameraActor *result = 0 ;
29789
29790   {
29791     try {
29792       result = (Dali::CameraActor *)new Dali::CameraActor();
29793     } CALL_CATCH_EXCEPTION(0);
29794   }
29795
29796   jresult = (void *)result;
29797   return jresult;
29798 }
29799
29800
29801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
29802   void * jresult ;
29803   Dali::CameraActor result;
29804
29805   {
29806     try {
29807       result = Dali::CameraActor::New();
29808     } CALL_CATCH_EXCEPTION(0);
29809   }
29810
29811   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
29812   return jresult;
29813 }
29814
29815
29816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
29817   void * jresult ;
29818   Dali::Size *arg1 = 0 ;
29819   Dali::CameraActor result;
29820
29821   arg1 = (Dali::Size *)jarg1;
29822   if (!arg1) {
29823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
29824     return 0;
29825   }
29826   {
29827     try {
29828       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
29829     } CALL_CATCH_EXCEPTION(0);
29830   }
29831
29832   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
29833   return jresult;
29834 }
29835
29836
29837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New3DCamera() {
29838   void * jresult ;
29839   Dali::CameraActor result;
29840
29841   {
29842     try {
29843       result = Dali::CameraActor::New3DCamera();
29844     } CALL_CATCH_EXCEPTION(0);
29845   }
29846
29847   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
29848   return jresult;
29849 }
29850
29851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
29852   void * jresult ;
29853   Dali::BaseHandle arg1 ;
29854   Dali::BaseHandle *argp1 ;
29855   Dali::CameraActor result;
29856
29857   argp1 = (Dali::BaseHandle *)jarg1;
29858   if (!argp1) {
29859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29860     return 0;
29861   }
29862   arg1 = *argp1;
29863   {
29864     try {
29865       result = Dali::CameraActor::DownCast(arg1);
29866     } CALL_CATCH_EXCEPTION(0);
29867   }
29868
29869   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
29870   return jresult;
29871 }
29872
29873
29874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
29875   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29876
29877   arg1 = (Dali::CameraActor *)jarg1;
29878   {
29879     try {
29880       delete arg1;
29881     } CALL_CATCH_EXCEPTION();
29882   }
29883
29884 }
29885
29886
29887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
29888   void * jresult ;
29889   Dali::CameraActor *arg1 = 0 ;
29890   Dali::CameraActor *result = 0 ;
29891
29892   arg1 = (Dali::CameraActor *)jarg1;
29893   if (!arg1) {
29894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
29895     return 0;
29896   }
29897   {
29898     try {
29899       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
29900     } CALL_CATCH_EXCEPTION(0);
29901   }
29902
29903   jresult = (void *)result;
29904   return jresult;
29905 }
29906
29907
29908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
29909   void * jresult ;
29910   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29911   Dali::CameraActor *arg2 = 0 ;
29912   Dali::CameraActor *result = 0 ;
29913
29914   arg1 = (Dali::CameraActor *)jarg1;
29915   arg2 = (Dali::CameraActor *)jarg2;
29916   if (!arg2) {
29917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
29918     return 0;
29919   }
29920   {
29921     try {
29922       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
29923     } CALL_CATCH_EXCEPTION(0);
29924   }
29925
29926   jresult = (void *)result;
29927   return jresult;
29928 }
29929
29930
29931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
29932   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29933   Dali::Camera::Type arg2 ;
29934
29935   arg1 = (Dali::CameraActor *)jarg1;
29936   arg2 = (Dali::Camera::Type)jarg2;
29937   {
29938     try {
29939       (arg1)->SetType(arg2);
29940     } CALL_CATCH_EXCEPTION();
29941   }
29942
29943 }
29944
29945
29946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
29947   int jresult ;
29948   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29949   Dali::Camera::Type result;
29950
29951   arg1 = (Dali::CameraActor *)jarg1;
29952   {
29953     try {
29954       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
29955     } CALL_CATCH_EXCEPTION(0);
29956   }
29957
29958   jresult = (int)result;
29959   return jresult;
29960 }
29961
29962
29963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
29964   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29965   Dali::Camera::ProjectionMode arg2 ;
29966
29967   arg1 = (Dali::CameraActor *)jarg1;
29968   arg2 = (Dali::Camera::ProjectionMode)jarg2;
29969   {
29970     try {
29971       (arg1)->SetProjectionMode(arg2);
29972     } CALL_CATCH_EXCEPTION();
29973   }
29974
29975 }
29976
29977
29978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
29979   int jresult ;
29980   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29981   Dali::Camera::ProjectionMode result;
29982
29983   arg1 = (Dali::CameraActor *)jarg1;
29984   {
29985     try {
29986       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
29987     } CALL_CATCH_EXCEPTION(0);
29988   }
29989
29990   jresult = (int)result;
29991   return jresult;
29992 }
29993
29994
29995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
29996   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29997   float arg2 ;
29998
29999   arg1 = (Dali::CameraActor *)jarg1;
30000   arg2 = (float)jarg2;
30001   {
30002     try {
30003       (arg1)->SetFieldOfView(arg2);
30004     } CALL_CATCH_EXCEPTION();
30005   }
30006
30007 }
30008
30009
30010 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
30011   float jresult ;
30012   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30013   float result;
30014
30015   arg1 = (Dali::CameraActor *)jarg1;
30016   {
30017     try {
30018       result = (float)(arg1)->GetFieldOfView();
30019     } CALL_CATCH_EXCEPTION(0);
30020   }
30021
30022   jresult = result;
30023   return jresult;
30024 }
30025
30026
30027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
30028   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30029   float arg2 ;
30030
30031   arg1 = (Dali::CameraActor *)jarg1;
30032   arg2 = (float)jarg2;
30033   {
30034     try {
30035       (arg1)->SetAspectRatio(arg2);
30036     } CALL_CATCH_EXCEPTION();
30037   }
30038
30039 }
30040
30041
30042 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
30043   float jresult ;
30044   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30045   float result;
30046
30047   arg1 = (Dali::CameraActor *)jarg1;
30048   {
30049     try {
30050       result = (float)(arg1)->GetAspectRatio();
30051     } CALL_CATCH_EXCEPTION(0);
30052   }
30053
30054   jresult = result;
30055   return jresult;
30056 }
30057
30058
30059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
30060   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30061   float arg2 ;
30062
30063   arg1 = (Dali::CameraActor *)jarg1;
30064   arg2 = (float)jarg2;
30065   {
30066     try {
30067       (arg1)->SetNearClippingPlane(arg2);
30068     } CALL_CATCH_EXCEPTION();
30069   }
30070
30071 }
30072
30073
30074 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
30075   float jresult ;
30076   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30077   float result;
30078
30079   arg1 = (Dali::CameraActor *)jarg1;
30080   {
30081     try {
30082       result = (float)(arg1)->GetNearClippingPlane();
30083     } CALL_CATCH_EXCEPTION(0);
30084   }
30085
30086   jresult = result;
30087   return jresult;
30088 }
30089
30090
30091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
30092   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30093   float arg2 ;
30094
30095   arg1 = (Dali::CameraActor *)jarg1;
30096   arg2 = (float)jarg2;
30097   {
30098     try {
30099       (arg1)->SetFarClippingPlane(arg2);
30100     } CALL_CATCH_EXCEPTION();
30101   }
30102
30103 }
30104
30105
30106 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
30107   float jresult ;
30108   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30109   float result;
30110
30111   arg1 = (Dali::CameraActor *)jarg1;
30112   {
30113     try {
30114       result = (float)(arg1)->GetFarClippingPlane();
30115     } CALL_CATCH_EXCEPTION(0);
30116   }
30117
30118   jresult = result;
30119   return jresult;
30120 }
30121
30122
30123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
30124   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30125   Dali::Vector3 *arg2 = 0 ;
30126
30127   arg1 = (Dali::CameraActor *)jarg1;
30128   arg2 = (Dali::Vector3 *)jarg2;
30129   if (!arg2) {
30130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30131     return ;
30132   }
30133   {
30134     try {
30135       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
30136     } CALL_CATCH_EXCEPTION();
30137   }
30138
30139 }
30140
30141
30142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
30143   void * jresult ;
30144   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30145   Dali::Vector3 result;
30146
30147   arg1 = (Dali::CameraActor *)jarg1;
30148   {
30149     try {
30150       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
30151     } CALL_CATCH_EXCEPTION(0);
30152   }
30153
30154   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30155   return jresult;
30156 }
30157
30158
30159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, bool jarg2) {
30160   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30161   bool arg2 ;
30162
30163   arg1 = (Dali::CameraActor *)jarg1;
30164   arg2 = jarg2 ? true : false;
30165   {
30166     try {
30167       (arg1)->SetInvertYAxis(arg2);
30168     } CALL_CATCH_EXCEPTION();
30169   }
30170
30171 }
30172
30173
30174 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
30175   bool jresult ;
30176   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30177   bool result;
30178
30179   arg1 = (Dali::CameraActor *)jarg1;
30180   {
30181     try {
30182       result = (bool)(arg1)->GetInvertYAxis();
30183     } CALL_CATCH_EXCEPTION(0);
30184   }
30185
30186   jresult = result;
30187   return jresult;
30188 }
30189
30190
30191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
30192   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30193   Dali::Size *arg2 = 0 ;
30194
30195   arg1 = (Dali::CameraActor *)jarg1;
30196   arg2 = (Dali::Size *)jarg2;
30197   if (!arg2) {
30198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
30199     return ;
30200   }
30201   {
30202     try {
30203       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
30204     } CALL_CATCH_EXCEPTION();
30205   }
30206
30207 }
30208
30209
30210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
30211   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30212   Dali::Size *arg2 = 0 ;
30213
30214   arg1 = (Dali::CameraActor *)jarg1;
30215   arg2 = (Dali::Size *)jarg2;
30216   if (!arg2) {
30217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
30218     return ;
30219   }
30220   {
30221     try {
30222       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
30223     } CALL_CATCH_EXCEPTION();
30224   }
30225
30226 }
30227
30228
30229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
30230   void * jresult ;
30231   std::pair< std::string,Dali::Property::Value > *result = 0 ;
30232
30233   {
30234     try {
30235       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
30236     } CALL_CATCH_EXCEPTION(0);
30237   }
30238
30239   jresult = (void *)result;
30240   return jresult;
30241 }
30242
30243
30244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
30245   void * jresult ;
30246   std::string arg1 ;
30247   Dali::Property::Value arg2 ;
30248   Dali::Property::Value *argp2 ;
30249   std::pair< std::string,Dali::Property::Value > *result = 0 ;
30250
30251   if (!jarg1) {
30252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30253     return 0;
30254   }
30255   (&arg1)->assign(jarg1);
30256   argp2 = (Dali::Property::Value *)jarg2;
30257   if (!argp2) {
30258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
30259     return 0;
30260   }
30261   arg2 = *argp2;
30262   {
30263     try {
30264       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
30265     } CALL_CATCH_EXCEPTION(0);
30266   }
30267
30268   jresult = (void *)result;
30269   return jresult;
30270 }
30271
30272
30273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
30274   void * jresult ;
30275   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
30276   std::pair< std::string,Dali::Property::Value > *result = 0 ;
30277
30278   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
30279   if (!arg1) {
30280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
30281     return 0;
30282   }
30283   {
30284     try {
30285       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);
30286     } CALL_CATCH_EXCEPTION(0);
30287   }
30288
30289   jresult = (void *)result;
30290   return jresult;
30291 }
30292
30293
30294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
30295   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
30296   std::string *arg2 = 0 ;
30297
30298   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
30299   if (!jarg2) {
30300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30301     return ;
30302   }
30303   std::string arg2_str(jarg2);
30304   arg2 = &arg2_str;
30305   if (arg1) (arg1)->first = *arg2;
30306
30307   //argout typemap for const std::string&
30308
30309 }
30310
30311
30312 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
30313   char * jresult ;
30314   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
30315   std::string *result = 0 ;
30316
30317   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
30318   result = (std::string *) & ((arg1)->first);
30319   jresult = SWIG_csharp_string_callback(result->c_str());
30320   return jresult;
30321 }
30322
30323
30324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
30325   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
30326   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
30327
30328   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
30329   arg2 = (Dali::Property::Value *)jarg2;
30330   if (arg1) (arg1)->second = *arg2;
30331 }
30332
30333
30334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
30335   void * jresult ;
30336   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
30337   Dali::Property::Value *result = 0 ;
30338
30339   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
30340   result = (Dali::Property::Value *)& ((arg1)->second);
30341   jresult = (void *)result;
30342   return jresult;
30343 }
30344
30345
30346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
30347   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
30348
30349   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
30350   {
30351     try {
30352       delete arg1;
30353     } CALL_CATCH_EXCEPTION();
30354   }
30355
30356 }
30357
30358
30359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
30360   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30361
30362   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30363   {
30364     try {
30365       (arg1)->clear();
30366     } CALL_CATCH_EXCEPTION();
30367   }
30368
30369 }
30370
30371
30372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
30373   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30374   Dali::TouchPoint *arg2 = 0 ;
30375
30376   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30377   arg2 = (Dali::TouchPoint *)jarg2;
30378   if (!arg2) {
30379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
30380     return ;
30381   }
30382   {
30383     try {
30384       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
30385     } CALL_CATCH_EXCEPTION();
30386   }
30387
30388 }
30389
30390
30391 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
30392   unsigned long jresult ;
30393   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30394   std::vector< Dali::TouchPoint >::size_type result;
30395
30396   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30397   {
30398     try {
30399       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
30400     } CALL_CATCH_EXCEPTION(0);
30401   }
30402
30403   jresult = (unsigned long)result;
30404   return jresult;
30405 }
30406
30407
30408 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
30409   unsigned long jresult ;
30410   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30411   std::vector< Dali::TouchPoint >::size_type result;
30412
30413   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30414   {
30415     try {
30416       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
30417     } CALL_CATCH_EXCEPTION(0);
30418   }
30419
30420   jresult = (unsigned long)result;
30421   return jresult;
30422 }
30423
30424
30425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
30426   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30427   std::vector< Dali::TouchPoint >::size_type arg2 ;
30428
30429   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30430   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
30431   {
30432     try {
30433       (arg1)->reserve(arg2);
30434     } CALL_CATCH_EXCEPTION();
30435   }
30436
30437 }
30438
30439
30440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
30441   void * jresult ;
30442   std::vector< Dali::TouchPoint > *result = 0 ;
30443
30444   {
30445     try {
30446       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
30447     } CALL_CATCH_EXCEPTION(0);
30448   }
30449
30450   jresult = (void *)result;
30451   return jresult;
30452 }
30453
30454
30455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
30456   void * jresult ;
30457   std::vector< Dali::TouchPoint > *arg1 = 0 ;
30458   std::vector< Dali::TouchPoint > *result = 0 ;
30459
30460   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30461   if (!arg1) {
30462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
30463     return 0;
30464   }
30465   {
30466     try {
30467       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
30468     } CALL_CATCH_EXCEPTION(0);
30469   }
30470
30471   jresult = (void *)result;
30472   return jresult;
30473 }
30474
30475
30476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
30477   void * jresult ;
30478   int arg1 ;
30479   std::vector< Dali::TouchPoint > *result = 0 ;
30480
30481   arg1 = (int)jarg1;
30482   {
30483     try {
30484       try {
30485         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
30486       }
30487       catch(std::out_of_range &_e) {
30488         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
30489         return 0;
30490       }
30491
30492     } CALL_CATCH_EXCEPTION(0);
30493   }
30494
30495   jresult = (void *)result;
30496   return jresult;
30497 }
30498
30499
30500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
30501   void * jresult ;
30502   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30503   int arg2 ;
30504   SwigValueWrapper< Dali::TouchPoint > result;
30505
30506   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30507   arg2 = (int)jarg2;
30508   {
30509     try {
30510       try {
30511         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
30512       }
30513       catch(std::out_of_range &_e) {
30514         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
30515         return 0;
30516       }
30517
30518     } CALL_CATCH_EXCEPTION(0);
30519   }
30520
30521   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
30522   return jresult;
30523 }
30524
30525
30526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
30527   void * jresult ;
30528   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30529   int arg2 ;
30530   Dali::TouchPoint *result = 0 ;
30531
30532   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30533   arg2 = (int)jarg2;
30534   {
30535     try {
30536       try {
30537         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
30538       }
30539       catch(std::out_of_range &_e) {
30540         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
30541         return 0;
30542       }
30543
30544     } CALL_CATCH_EXCEPTION(0);
30545   }
30546
30547   jresult = (void *)result;
30548   return jresult;
30549 }
30550
30551
30552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
30553   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30554   int arg2 ;
30555   Dali::TouchPoint *arg3 = 0 ;
30556
30557   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30558   arg2 = (int)jarg2;
30559   arg3 = (Dali::TouchPoint *)jarg3;
30560   if (!arg3) {
30561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
30562     return ;
30563   }
30564   {
30565     try {
30566       try {
30567         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
30568       }
30569       catch(std::out_of_range &_e) {
30570         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
30571         return ;
30572       }
30573
30574     } CALL_CATCH_EXCEPTION();
30575   }
30576
30577 }
30578
30579
30580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
30581   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30582   std::vector< Dali::TouchPoint > *arg2 = 0 ;
30583
30584   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30585   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
30586   if (!arg2) {
30587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
30588     return ;
30589   }
30590   {
30591     try {
30592       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
30593     } CALL_CATCH_EXCEPTION();
30594   }
30595
30596 }
30597
30598
30599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
30600   void * jresult ;
30601   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30602   int arg2 ;
30603   int arg3 ;
30604   std::vector< Dali::TouchPoint > *result = 0 ;
30605
30606   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30607   arg2 = (int)jarg2;
30608   arg3 = (int)jarg3;
30609   {
30610     try {
30611       try {
30612         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
30613       }
30614       catch(std::out_of_range &_e) {
30615         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
30616         return 0;
30617       }
30618       catch(std::invalid_argument &_e) {
30619         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
30620         return 0;
30621       }
30622
30623     } CALL_CATCH_EXCEPTION(0);
30624   }
30625
30626   jresult = (void *)result;
30627   return jresult;
30628 }
30629
30630
30631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
30632   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30633   int arg2 ;
30634   Dali::TouchPoint *arg3 = 0 ;
30635
30636   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30637   arg2 = (int)jarg2;
30638   arg3 = (Dali::TouchPoint *)jarg3;
30639   if (!arg3) {
30640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
30641     return ;
30642   }
30643   {
30644     try {
30645       try {
30646         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
30647       }
30648       catch(std::out_of_range &_e) {
30649         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
30650         return ;
30651       }
30652
30653     } CALL_CATCH_EXCEPTION();
30654   }
30655
30656 }
30657
30658
30659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
30660   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30661   int arg2 ;
30662   std::vector< Dali::TouchPoint > *arg3 = 0 ;
30663
30664   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30665   arg2 = (int)jarg2;
30666   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
30667   if (!arg3) {
30668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
30669     return ;
30670   }
30671   {
30672     try {
30673       try {
30674         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
30675       }
30676       catch(std::out_of_range &_e) {
30677         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
30678         return ;
30679       }
30680
30681     } CALL_CATCH_EXCEPTION();
30682   }
30683
30684 }
30685
30686
30687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
30688   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30689   int arg2 ;
30690
30691   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30692   arg2 = (int)jarg2;
30693   {
30694     try {
30695       try {
30696         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
30697       }
30698       catch(std::out_of_range &_e) {
30699         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
30700         return ;
30701       }
30702
30703     } CALL_CATCH_EXCEPTION();
30704   }
30705
30706 }
30707
30708
30709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
30710   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30711   int arg2 ;
30712   int arg3 ;
30713
30714   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30715   arg2 = (int)jarg2;
30716   arg3 = (int)jarg3;
30717   {
30718     try {
30719       try {
30720         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
30721       }
30722       catch(std::out_of_range &_e) {
30723         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
30724         return ;
30725       }
30726       catch(std::invalid_argument &_e) {
30727         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
30728         return ;
30729       }
30730
30731     } CALL_CATCH_EXCEPTION();
30732   }
30733
30734 }
30735
30736
30737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
30738   void * jresult ;
30739   Dali::TouchPoint *arg1 = 0 ;
30740   int arg2 ;
30741   std::vector< Dali::TouchPoint > *result = 0 ;
30742
30743   arg1 = (Dali::TouchPoint *)jarg1;
30744   if (!arg1) {
30745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
30746     return 0;
30747   }
30748   arg2 = (int)jarg2;
30749   {
30750     try {
30751       try {
30752         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
30753       }
30754       catch(std::out_of_range &_e) {
30755         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
30756         return 0;
30757       }
30758
30759     } CALL_CATCH_EXCEPTION(0);
30760   }
30761
30762   jresult = (void *)result;
30763   return jresult;
30764 }
30765
30766
30767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
30768   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30769
30770   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30771   {
30772     try {
30773       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
30774     } CALL_CATCH_EXCEPTION();
30775   }
30776
30777 }
30778
30779
30780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
30781   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30782   int arg2 ;
30783   int arg3 ;
30784
30785   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30786   arg2 = (int)jarg2;
30787   arg3 = (int)jarg3;
30788   {
30789     try {
30790       try {
30791         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
30792       }
30793       catch(std::out_of_range &_e) {
30794         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
30795         return ;
30796       }
30797       catch(std::invalid_argument &_e) {
30798         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
30799         return ;
30800       }
30801
30802     } CALL_CATCH_EXCEPTION();
30803   }
30804
30805 }
30806
30807
30808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
30809   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30810   int arg2 ;
30811   std::vector< Dali::TouchPoint > *arg3 = 0 ;
30812
30813   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30814   arg2 = (int)jarg2;
30815   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
30816   if (!arg3) {
30817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
30818     return ;
30819   }
30820   {
30821     try {
30822       try {
30823         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
30824       }
30825       catch(std::out_of_range &_e) {
30826         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
30827         return ;
30828       }
30829
30830     } CALL_CATCH_EXCEPTION();
30831   }
30832
30833 }
30834
30835
30836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
30837   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30838
30839   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30840   {
30841     try {
30842       delete arg1;
30843     } CALL_CATCH_EXCEPTION();
30844   }
30845
30846 }
30847
30848
30849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
30850   void * jresult ;
30851   Dali::Rect< int > *result = 0 ;
30852
30853   {
30854     try {
30855       result = (Dali::Rect< int > *)new Dali::Rect< int >();
30856     } CALL_CATCH_EXCEPTION(0);
30857   }
30858
30859   jresult = (void *)result;
30860   return jresult;
30861 }
30862
30863
30864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
30865   void * jresult ;
30866   int arg1 ;
30867   int arg2 ;
30868   int arg3 ;
30869   int arg4 ;
30870   Dali::Rect< int > *result = 0 ;
30871
30872   arg1 = (int)jarg1;
30873   arg2 = (int)jarg2;
30874   arg3 = (int)jarg3;
30875   arg4 = (int)jarg4;
30876   {
30877     try {
30878       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
30879     } CALL_CATCH_EXCEPTION(0);
30880   }
30881
30882   jresult = (void *)result;
30883   return jresult;
30884 }
30885
30886
30887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
30888   void * jresult ;
30889   Dali::Rect< int > *arg1 = 0 ;
30890   Dali::Rect< int > *result = 0 ;
30891
30892   arg1 = (Dali::Rect< int > *)jarg1;
30893   if (!arg1) {
30894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
30895     return 0;
30896   }
30897   {
30898     try {
30899       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
30900     } CALL_CATCH_EXCEPTION(0);
30901   }
30902
30903   jresult = (void *)result;
30904   return jresult;
30905 }
30906
30907
30908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
30909   void * jresult ;
30910   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30911   Dali::Rect< int > *arg2 = 0 ;
30912   Dali::Rect< int > *result = 0 ;
30913
30914   arg1 = (Dali::Rect< int > *)jarg1;
30915   arg2 = (Dali::Rect< int > *)jarg2;
30916   if (!arg2) {
30917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
30918     return 0;
30919   }
30920   {
30921     try {
30922       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
30923     } CALL_CATCH_EXCEPTION(0);
30924   }
30925
30926   jresult = (void *)result;
30927   return jresult;
30928 }
30929
30930
30931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
30932   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30933   int arg2 ;
30934   int arg3 ;
30935   int arg4 ;
30936   int arg5 ;
30937
30938   arg1 = (Dali::Rect< int > *)jarg1;
30939   arg2 = (int)jarg2;
30940   arg3 = (int)jarg3;
30941   arg4 = (int)jarg4;
30942   arg5 = (int)jarg5;
30943   {
30944     try {
30945       (arg1)->Set(arg2,arg3,arg4,arg5);
30946     } CALL_CATCH_EXCEPTION();
30947   }
30948
30949 }
30950
30951
30952 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
30953   bool jresult ;
30954   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30955   bool result;
30956
30957   arg1 = (Dali::Rect< int > *)jarg1;
30958   {
30959     try {
30960       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
30961     } CALL_CATCH_EXCEPTION(0);
30962   }
30963
30964   jresult = result;
30965   return jresult;
30966 }
30967
30968
30969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
30970   int jresult ;
30971   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30972   int result;
30973
30974   arg1 = (Dali::Rect< int > *)jarg1;
30975   {
30976     try {
30977       result = (int)((Dali::Rect< int > const *)arg1)->Left();
30978     } CALL_CATCH_EXCEPTION(0);
30979   }
30980
30981   jresult = result;
30982   return jresult;
30983 }
30984
30985
30986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
30987   int jresult ;
30988   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30989   int result;
30990
30991   arg1 = (Dali::Rect< int > *)jarg1;
30992   {
30993     try {
30994       result = (int)((Dali::Rect< int > const *)arg1)->Right();
30995     } CALL_CATCH_EXCEPTION(0);
30996   }
30997
30998   jresult = result;
30999   return jresult;
31000 }
31001
31002
31003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
31004   int jresult ;
31005   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31006   int result;
31007
31008   arg1 = (Dali::Rect< int > *)jarg1;
31009   {
31010     try {
31011       result = (int)((Dali::Rect< int > const *)arg1)->Top();
31012     } CALL_CATCH_EXCEPTION(0);
31013   }
31014
31015   jresult = result;
31016   return jresult;
31017 }
31018
31019
31020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
31021   int jresult ;
31022   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31023   int result;
31024
31025   arg1 = (Dali::Rect< int > *)jarg1;
31026   {
31027     try {
31028       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
31029     } CALL_CATCH_EXCEPTION(0);
31030   }
31031
31032   jresult = result;
31033   return jresult;
31034 }
31035
31036
31037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
31038   int jresult ;
31039   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31040   int result;
31041
31042   arg1 = (Dali::Rect< int > *)jarg1;
31043   {
31044     try {
31045       result = (int)((Dali::Rect< int > const *)arg1)->Area();
31046     } CALL_CATCH_EXCEPTION(0);
31047   }
31048
31049   jresult = result;
31050   return jresult;
31051 }
31052
31053
31054 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
31055   bool jresult ;
31056   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31057   Dali::Rect< int > *arg2 = 0 ;
31058   bool result;
31059
31060   arg1 = (Dali::Rect< int > *)jarg1;
31061   arg2 = (Dali::Rect< int > *)jarg2;
31062   if (!arg2) {
31063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
31064     return 0;
31065   }
31066   {
31067     try {
31068       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
31069     } CALL_CATCH_EXCEPTION(0);
31070   }
31071
31072   jresult = result;
31073   return jresult;
31074 }
31075
31076
31077 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
31078   bool jresult ;
31079   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31080   Dali::Rect< int > *arg2 = 0 ;
31081   bool result;
31082
31083   arg1 = (Dali::Rect< int > *)jarg1;
31084   arg2 = (Dali::Rect< int > *)jarg2;
31085   if (!arg2) {
31086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
31087     return 0;
31088   }
31089   {
31090     try {
31091       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
31092     } CALL_CATCH_EXCEPTION(0);
31093   }
31094
31095   jresult = result;
31096   return jresult;
31097 }
31098
31099
31100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
31101   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31102   int arg2 ;
31103
31104   arg1 = (Dali::Rect< int > *)jarg1;
31105   arg2 = (int)jarg2;
31106   if (arg1) (arg1)->x = arg2;
31107 }
31108
31109
31110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
31111   int jresult ;
31112   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31113   int result;
31114
31115   arg1 = (Dali::Rect< int > *)jarg1;
31116   result = (int) ((arg1)->x);
31117   jresult = result;
31118   return jresult;
31119 }
31120
31121
31122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
31123   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31124   int arg2 ;
31125
31126   arg1 = (Dali::Rect< int > *)jarg1;
31127   arg2 = (int)jarg2;
31128   if (arg1) (arg1)->left = arg2;
31129 }
31130
31131
31132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
31133   int jresult ;
31134   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31135   int result;
31136
31137   arg1 = (Dali::Rect< int > *)jarg1;
31138   result = (int) ((arg1)->left);
31139   jresult = result;
31140   return jresult;
31141 }
31142
31143
31144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
31145   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31146   int arg2 ;
31147
31148   arg1 = (Dali::Rect< int > *)jarg1;
31149   arg2 = (int)jarg2;
31150   if (arg1) (arg1)->y = arg2;
31151 }
31152
31153
31154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
31155   int jresult ;
31156   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31157   int result;
31158
31159   arg1 = (Dali::Rect< int > *)jarg1;
31160   result = (int) ((arg1)->y);
31161   jresult = result;
31162   return jresult;
31163 }
31164
31165
31166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
31167   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31168   int arg2 ;
31169
31170   arg1 = (Dali::Rect< int > *)jarg1;
31171   arg2 = (int)jarg2;
31172   if (arg1) (arg1)->right = arg2;
31173 }
31174
31175
31176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
31177   int jresult ;
31178   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31179   int result;
31180
31181   arg1 = (Dali::Rect< int > *)jarg1;
31182   result = (int) ((arg1)->right);
31183   jresult = result;
31184   return jresult;
31185 }
31186
31187
31188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
31189   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31190   int arg2 ;
31191
31192   arg1 = (Dali::Rect< int > *)jarg1;
31193   arg2 = (int)jarg2;
31194   if (arg1) (arg1)->width = arg2;
31195 }
31196
31197
31198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
31199   int jresult ;
31200   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31201   int result;
31202
31203   arg1 = (Dali::Rect< int > *)jarg1;
31204   result = (int) ((arg1)->width);
31205   jresult = result;
31206   return jresult;
31207 }
31208
31209
31210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
31211   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31212   int arg2 ;
31213
31214   arg1 = (Dali::Rect< int > *)jarg1;
31215   arg2 = (int)jarg2;
31216   if (arg1) (arg1)->bottom = arg2;
31217 }
31218
31219
31220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
31221   int jresult ;
31222   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31223   int result;
31224
31225   arg1 = (Dali::Rect< int > *)jarg1;
31226   result = (int) ((arg1)->bottom);
31227   jresult = result;
31228   return jresult;
31229 }
31230
31231
31232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
31233   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31234   int arg2 ;
31235
31236   arg1 = (Dali::Rect< int > *)jarg1;
31237   arg2 = (int)jarg2;
31238   if (arg1) (arg1)->height = arg2;
31239 }
31240
31241
31242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
31243   int jresult ;
31244   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31245   int result;
31246
31247   arg1 = (Dali::Rect< int > *)jarg1;
31248   result = (int) ((arg1)->height);
31249   jresult = result;
31250   return jresult;
31251 }
31252
31253
31254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
31255   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31256   int arg2 ;
31257
31258   arg1 = (Dali::Rect< int > *)jarg1;
31259   arg2 = (int)jarg2;
31260   if (arg1) (arg1)->top = arg2;
31261 }
31262
31263
31264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
31265   int jresult ;
31266   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31267   int result;
31268
31269   arg1 = (Dali::Rect< int > *)jarg1;
31270   result = (int) ((arg1)->top);
31271   jresult = result;
31272   return jresult;
31273 }
31274
31275
31276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
31277   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31278
31279   arg1 = (Dali::Rect< int > *)jarg1;
31280   {
31281     try {
31282       delete arg1;
31283     } CALL_CATCH_EXCEPTION();
31284   }
31285
31286 }
31287
31288
31289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
31290   void * jresult ;
31291   Dali::Rect< float > *result = 0 ;
31292
31293   {
31294     try {
31295       result = (Dali::Rect< float > *)new Dali::Rect< float >();
31296     } CALL_CATCH_EXCEPTION(0);
31297   }
31298
31299   jresult = (void *)result;
31300   return jresult;
31301 }
31302
31303
31304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
31305   void * jresult ;
31306   float arg1 ;
31307   float arg2 ;
31308   float arg3 ;
31309   float arg4 ;
31310   Dali::Rect< float > *result = 0 ;
31311
31312   arg1 = (float)jarg1;
31313   arg2 = (float)jarg2;
31314   arg3 = (float)jarg4;
31315   arg4 = (float)jarg3;
31316   {
31317     try {
31318       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
31319     } CALL_CATCH_EXCEPTION(0);
31320   }
31321
31322   jresult = (void *)result;
31323   return jresult;
31324 }
31325
31326
31327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
31328   void * jresult ;
31329   Dali::Rect< float > *arg1 = 0 ;
31330   Dali::Rect< float > *result = 0 ;
31331
31332   arg1 = (Dali::Rect< float > *)jarg1;
31333   if (!arg1) {
31334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
31335     return 0;
31336   }
31337   {
31338     try {
31339       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
31340     } CALL_CATCH_EXCEPTION(0);
31341   }
31342
31343   jresult = (void *)result;
31344   return jresult;
31345 }
31346
31347
31348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
31349   void * jresult ;
31350   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31351   Dali::Rect< float > *arg2 = 0 ;
31352   Dali::Rect< float > *result = 0 ;
31353
31354   arg1 = (Dali::Rect< float > *)jarg1;
31355   arg2 = (Dali::Rect< float > *)jarg2;
31356   if (!arg2) {
31357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
31358     return 0;
31359   }
31360   {
31361     try {
31362       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
31363     } CALL_CATCH_EXCEPTION(0);
31364   }
31365
31366   jresult = (void *)result;
31367   return jresult;
31368 }
31369
31370
31371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
31372   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31373   float arg2 ;
31374   float arg3 ;
31375   float arg4 ;
31376   float arg5 ;
31377
31378   arg1 = (Dali::Rect< float > *)jarg1;
31379   arg2 = (float)jarg2;
31380   arg3 = (float)jarg3;
31381   arg4 = (float)jarg5;
31382   arg5 = (float)jarg4;
31383   {
31384     try {
31385       (arg1)->Set(arg2,arg3,arg4,arg5);
31386     } CALL_CATCH_EXCEPTION();
31387   }
31388
31389 }
31390
31391
31392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
31393   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31394   float arg2 ;
31395
31396   arg1 = (Dali::Rect< float > *)jarg1;
31397   arg2 = (float)jarg2;
31398   if (arg1) (arg1)->left = arg2;
31399 }
31400
31401
31402 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
31403   float jresult ;
31404   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31405   float result;
31406
31407   arg1 = (Dali::Rect< float > *)jarg1;
31408   result = (float) ((arg1)->left);
31409   jresult = result;
31410   return jresult;
31411 }
31412
31413
31414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
31415   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31416   float arg2 ;
31417
31418   arg1 = (Dali::Rect< float > *)jarg1;
31419   arg2 = (float)jarg2;
31420   if (arg1) (arg1)->left = arg2;
31421 }
31422
31423
31424 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
31425   float jresult ;
31426   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31427   float result;
31428
31429   arg1 = (Dali::Rect< float > *)jarg1;
31430   result = (float) ((arg1)->left);
31431   jresult = result;
31432   return jresult;
31433 }
31434
31435
31436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
31437   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31438   float arg2 ;
31439
31440   arg1 = (Dali::Rect< float > *)jarg1;
31441   arg2 = (float)jarg2;
31442   if (arg1) (arg1)->right = arg2;
31443 }
31444
31445
31446 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
31447   float jresult ;
31448   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31449   float result;
31450
31451   arg1 = (Dali::Rect< float > *)jarg1;
31452   result = (float) ((arg1)->right);
31453   jresult = result;
31454   return jresult;
31455 }
31456
31457
31458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
31459   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31460   float arg2 ;
31461
31462   arg1 = (Dali::Rect< float > *)jarg1;
31463   arg2 = (float)jarg2;
31464   if (arg1) (arg1)->right = arg2;
31465 }
31466
31467
31468 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
31469   float jresult ;
31470   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31471   float result;
31472
31473   arg1 = (Dali::Rect< float > *)jarg1;
31474   result = (float) ((arg1)->right);
31475   jresult = result;
31476   return jresult;
31477 }
31478
31479
31480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
31481   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31482   float arg2 ;
31483
31484   arg1 = (Dali::Rect< float > *)jarg1;
31485   arg2 = (float)jarg2;
31486   if (arg1) (arg1)->bottom = arg2;
31487 }
31488
31489
31490 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
31491   float jresult ;
31492   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31493   float result;
31494
31495   arg1 = (Dali::Rect< float > *)jarg1;
31496   result = (float) ((arg1)->bottom);
31497   jresult = result;
31498   return jresult;
31499 }
31500
31501
31502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
31503   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31504   float arg2 ;
31505
31506   arg1 = (Dali::Rect< float > *)jarg1;
31507   arg2 = (float)jarg2;
31508   if (arg1) (arg1)->top = arg2;
31509 }
31510
31511
31512 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
31513   float jresult ;
31514   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31515   float result;
31516
31517   arg1 = (Dali::Rect< float > *)jarg1;
31518   result = (float) ((arg1)->top);
31519   jresult = result;
31520   return jresult;
31521 }
31522
31523
31524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
31525   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31526
31527   arg1 = (Dali::Rect< float > *)jarg1;
31528   {
31529     try {
31530       delete arg1;
31531     } CALL_CATCH_EXCEPTION();
31532   }
31533
31534 }
31535
31536
31537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
31538   int jresult ;
31539   int result;
31540
31541   result = (int)Dali::Vector< int >::BaseType;
31542   jresult = (int)result;
31543   return jresult;
31544 }
31545
31546
31547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
31548   void * jresult ;
31549   Dali::Vector< int > *result = 0 ;
31550
31551   {
31552     try {
31553       result = (Dali::Vector< int > *)new Dali::Vector< int >();
31554     } CALL_CATCH_EXCEPTION(0);
31555   }
31556
31557   jresult = (void *)result;
31558   return jresult;
31559 }
31560
31561
31562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
31563   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31564
31565   arg1 = (Dali::Vector< int > *)jarg1;
31566   {
31567     try {
31568       delete arg1;
31569     } CALL_CATCH_EXCEPTION();
31570   }
31571
31572 }
31573
31574
31575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
31576   void * jresult ;
31577   Dali::Vector< int > *arg1 = 0 ;
31578   Dali::Vector< int > *result = 0 ;
31579
31580   arg1 = (Dali::Vector< int > *)jarg1;
31581   if (!arg1) {
31582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
31583     return 0;
31584   }
31585   {
31586     try {
31587       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
31588     } CALL_CATCH_EXCEPTION(0);
31589   }
31590
31591   jresult = (void *)result;
31592   return jresult;
31593 }
31594
31595
31596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
31597   void * jresult ;
31598   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31599   Dali::Vector< int > *arg2 = 0 ;
31600   Dali::Vector< int > *result = 0 ;
31601
31602   arg1 = (Dali::Vector< int > *)jarg1;
31603   arg2 = (Dali::Vector< int > *)jarg2;
31604   if (!arg2) {
31605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
31606     return 0;
31607   }
31608   {
31609     try {
31610       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
31611     } CALL_CATCH_EXCEPTION(0);
31612   }
31613
31614   jresult = (void *)result;
31615   return jresult;
31616 }
31617
31618
31619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
31620   void * jresult ;
31621   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31622   Dali::Vector< int >::Iterator result;
31623
31624   arg1 = (Dali::Vector< int > *)jarg1;
31625   {
31626     try {
31627       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
31628     } CALL_CATCH_EXCEPTION(0);
31629   }
31630
31631   jresult = (void *)result;
31632   return jresult;
31633 }
31634
31635
31636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
31637   void * jresult ;
31638   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31639   Dali::Vector< int >::Iterator result;
31640
31641   arg1 = (Dali::Vector< int > *)jarg1;
31642   {
31643     try {
31644       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
31645     } CALL_CATCH_EXCEPTION(0);
31646   }
31647
31648   jresult = (void *)result;
31649   return jresult;
31650 }
31651
31652
31653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
31654   void * jresult ;
31655   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31656   Dali::Vector< int >::SizeType arg2 ;
31657   Dali::Vector< int >::ItemType *result = 0 ;
31658
31659   arg1 = (Dali::Vector< int > *)jarg1;
31660   arg2 = (Dali::Vector< int >::SizeType)jarg2;
31661   {
31662     try {
31663       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
31664     } CALL_CATCH_EXCEPTION(0);
31665   }
31666
31667   jresult = (void *)result;
31668   return jresult;
31669 }
31670
31671
31672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
31673   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31674   Dali::Vector< int >::ItemType *arg2 = 0 ;
31675   Dali::Vector< int >::ItemType temp2 ;
31676
31677   arg1 = (Dali::Vector< int > *)jarg1;
31678   temp2 = (Dali::Vector< int >::ItemType)jarg2;
31679   arg2 = &temp2;
31680   {
31681     try {
31682       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
31683     } CALL_CATCH_EXCEPTION();
31684   }
31685
31686 }
31687
31688
31689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
31690   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31691   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
31692   Dali::Vector< int >::ItemType *arg3 = 0 ;
31693   Dali::Vector< int >::ItemType temp3 ;
31694
31695   arg1 = (Dali::Vector< int > *)jarg1;
31696   arg2 = (Dali::Vector< int >::Iterator)jarg2;
31697   temp3 = (Dali::Vector< int >::ItemType)jarg3;
31698   arg3 = &temp3;
31699   {
31700     try {
31701       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
31702     } CALL_CATCH_EXCEPTION();
31703   }
31704
31705 }
31706
31707
31708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
31709   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31710   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
31711   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
31712   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
31713
31714   arg1 = (Dali::Vector< int > *)jarg1;
31715   arg2 = (Dali::Vector< int >::Iterator)jarg2;
31716   arg3 = (Dali::Vector< int >::Iterator)jarg3;
31717   arg4 = (Dali::Vector< int >::Iterator)jarg4;
31718   {
31719     try {
31720       (arg1)->Insert(arg2,arg3,arg4);
31721     } CALL_CATCH_EXCEPTION();
31722   }
31723
31724 }
31725
31726
31727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
31728   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31729   Dali::Vector< int >::SizeType arg2 ;
31730
31731   arg1 = (Dali::Vector< int > *)jarg1;
31732   arg2 = (Dali::Vector< int >::SizeType)jarg2;
31733   {
31734     try {
31735       (arg1)->Reserve(arg2);
31736     } CALL_CATCH_EXCEPTION();
31737   }
31738
31739 }
31740
31741
31742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
31743   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31744   Dali::Vector< int >::SizeType arg2 ;
31745
31746   arg1 = (Dali::Vector< int > *)jarg1;
31747   arg2 = (Dali::Vector< int >::SizeType)jarg2;
31748   {
31749     try {
31750       (arg1)->Resize(arg2);
31751     } CALL_CATCH_EXCEPTION();
31752   }
31753
31754 }
31755
31756
31757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
31758   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31759   Dali::Vector< int >::SizeType arg2 ;
31760   Dali::Vector< int >::ItemType *arg3 = 0 ;
31761   Dali::Vector< int >::ItemType temp3 ;
31762
31763   arg1 = (Dali::Vector< int > *)jarg1;
31764   arg2 = (Dali::Vector< int >::SizeType)jarg2;
31765   temp3 = (Dali::Vector< int >::ItemType)jarg3;
31766   arg3 = &temp3;
31767   {
31768     try {
31769       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
31770     } CALL_CATCH_EXCEPTION();
31771   }
31772
31773 }
31774
31775
31776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
31777   void * jresult ;
31778   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31779   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
31780   Dali::Vector< int >::Iterator result;
31781
31782   arg1 = (Dali::Vector< int > *)jarg1;
31783   arg2 = (Dali::Vector< int >::Iterator)jarg2;
31784   {
31785     try {
31786       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
31787     } CALL_CATCH_EXCEPTION(0);
31788   }
31789
31790   jresult = (void *)result;
31791   return jresult;
31792 }
31793
31794
31795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
31796   void * jresult ;
31797   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31798   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
31799   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
31800   Dali::Vector< int >::Iterator result;
31801
31802   arg1 = (Dali::Vector< int > *)jarg1;
31803   arg2 = (Dali::Vector< int >::Iterator)jarg2;
31804   arg3 = (Dali::Vector< int >::Iterator)jarg3;
31805   {
31806     try {
31807       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
31808     } CALL_CATCH_EXCEPTION(0);
31809   }
31810
31811   jresult = (void *)result;
31812   return jresult;
31813 }
31814
31815
31816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
31817   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31818   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
31819
31820   arg1 = (Dali::Vector< int > *)jarg1;
31821   arg2 = (Dali::Vector< int >::Iterator)jarg2;
31822   {
31823     try {
31824       (arg1)->Remove(arg2);
31825     } CALL_CATCH_EXCEPTION();
31826   }
31827
31828 }
31829
31830
31831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
31832   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31833   Dali::Vector< int > *arg2 = 0 ;
31834
31835   arg1 = (Dali::Vector< int > *)jarg1;
31836   arg2 = (Dali::Vector< int > *)jarg2;
31837   if (!arg2) {
31838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
31839     return ;
31840   }
31841   {
31842     try {
31843       (arg1)->Swap(*arg2);
31844     } CALL_CATCH_EXCEPTION();
31845   }
31846
31847 }
31848
31849
31850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
31851   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31852
31853   arg1 = (Dali::Vector< int > *)jarg1;
31854   {
31855     try {
31856       (arg1)->Clear();
31857     } CALL_CATCH_EXCEPTION();
31858   }
31859
31860 }
31861
31862
31863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
31864   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
31865
31866   arg1 = (Dali::Vector< int > *)jarg1;
31867   {
31868     try {
31869       (arg1)->Release();
31870     } CALL_CATCH_EXCEPTION();
31871   }
31872
31873 }
31874
31875
31876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
31877   int jresult ;
31878   int result;
31879
31880   result = (int)Dali::Vector< float >::BaseType;
31881   jresult = (int)result;
31882   return jresult;
31883 }
31884
31885
31886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
31887   void * jresult ;
31888   Dali::Vector< float > *result = 0 ;
31889
31890   {
31891     try {
31892       result = (Dali::Vector< float > *)new Dali::Vector< float >();
31893     } CALL_CATCH_EXCEPTION(0);
31894   }
31895
31896   jresult = (void *)result;
31897   return jresult;
31898 }
31899
31900
31901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
31902   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31903
31904   arg1 = (Dali::Vector< float > *)jarg1;
31905   {
31906     try {
31907       delete arg1;
31908     } CALL_CATCH_EXCEPTION();
31909   }
31910
31911 }
31912
31913
31914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
31915   void * jresult ;
31916   Dali::Vector< float > *arg1 = 0 ;
31917   Dali::Vector< float > *result = 0 ;
31918
31919   arg1 = (Dali::Vector< float > *)jarg1;
31920   if (!arg1) {
31921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
31922     return 0;
31923   }
31924   {
31925     try {
31926       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
31927     } CALL_CATCH_EXCEPTION(0);
31928   }
31929
31930   jresult = (void *)result;
31931   return jresult;
31932 }
31933
31934
31935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
31936   void * jresult ;
31937   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31938   Dali::Vector< float > *arg2 = 0 ;
31939   Dali::Vector< float > *result = 0 ;
31940
31941   arg1 = (Dali::Vector< float > *)jarg1;
31942   arg2 = (Dali::Vector< float > *)jarg2;
31943   if (!arg2) {
31944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
31945     return 0;
31946   }
31947   {
31948     try {
31949       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
31950     } CALL_CATCH_EXCEPTION(0);
31951   }
31952
31953   jresult = (void *)result;
31954   return jresult;
31955 }
31956
31957
31958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
31959   void * jresult ;
31960   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31961   Dali::Vector< float >::Iterator result;
31962
31963   arg1 = (Dali::Vector< float > *)jarg1;
31964   {
31965     try {
31966       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
31967     } CALL_CATCH_EXCEPTION(0);
31968   }
31969
31970   jresult = (void *)result;
31971   return jresult;
31972 }
31973
31974
31975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
31976   void * jresult ;
31977   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31978   Dali::Vector< float >::Iterator result;
31979
31980   arg1 = (Dali::Vector< float > *)jarg1;
31981   {
31982     try {
31983       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
31984     } CALL_CATCH_EXCEPTION(0);
31985   }
31986
31987   jresult = (void *)result;
31988   return jresult;
31989 }
31990
31991
31992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
31993   void * jresult ;
31994   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31995   Dali::Vector< float >::SizeType arg2 ;
31996   Dali::Vector< float >::ItemType *result = 0 ;
31997
31998   arg1 = (Dali::Vector< float > *)jarg1;
31999   arg2 = (Dali::Vector< float >::SizeType)jarg2;
32000   {
32001     try {
32002       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
32003     } CALL_CATCH_EXCEPTION(0);
32004   }
32005
32006   jresult = (void *)result;
32007   return jresult;
32008 }
32009
32010
32011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
32012   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32013   Dali::Vector< float >::ItemType *arg2 = 0 ;
32014   Dali::Vector< float >::ItemType temp2 ;
32015
32016   arg1 = (Dali::Vector< float > *)jarg1;
32017   temp2 = (Dali::Vector< float >::ItemType)jarg2;
32018   arg2 = &temp2;
32019   {
32020     try {
32021       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
32022     } CALL_CATCH_EXCEPTION();
32023   }
32024
32025 }
32026
32027
32028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
32029   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32030   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
32031   Dali::Vector< float >::ItemType *arg3 = 0 ;
32032   Dali::Vector< float >::ItemType temp3 ;
32033
32034   arg1 = (Dali::Vector< float > *)jarg1;
32035   arg2 = (Dali::Vector< float >::Iterator)jarg2;
32036   temp3 = (Dali::Vector< float >::ItemType)jarg3;
32037   arg3 = &temp3;
32038   {
32039     try {
32040       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
32041     } CALL_CATCH_EXCEPTION();
32042   }
32043
32044 }
32045
32046
32047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
32048   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32049   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
32050   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
32051   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
32052
32053   arg1 = (Dali::Vector< float > *)jarg1;
32054   arg2 = (Dali::Vector< float >::Iterator)jarg2;
32055   arg3 = (Dali::Vector< float >::Iterator)jarg3;
32056   arg4 = (Dali::Vector< float >::Iterator)jarg4;
32057   {
32058     try {
32059       (arg1)->Insert(arg2,arg3,arg4);
32060     } CALL_CATCH_EXCEPTION();
32061   }
32062
32063 }
32064
32065
32066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
32067   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32068   Dali::Vector< float >::SizeType arg2 ;
32069
32070   arg1 = (Dali::Vector< float > *)jarg1;
32071   arg2 = (Dali::Vector< float >::SizeType)jarg2;
32072   {
32073     try {
32074       (arg1)->Reserve(arg2);
32075     } CALL_CATCH_EXCEPTION();
32076   }
32077
32078 }
32079
32080 //// ========================= end of part 2 =============================
32081
32082 //// ========================== start part 3 ===============================
32083
32084
32085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
32086   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32087   Dali::Vector< float >::SizeType arg2 ;
32088
32089   arg1 = (Dali::Vector< float > *)jarg1;
32090   arg2 = (Dali::Vector< float >::SizeType)jarg2;
32091   {
32092     try {
32093       (arg1)->Resize(arg2);
32094     } CALL_CATCH_EXCEPTION();
32095   }
32096
32097 }
32098
32099
32100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
32101   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32102   Dali::Vector< float >::SizeType arg2 ;
32103   Dali::Vector< float >::ItemType *arg3 = 0 ;
32104   Dali::Vector< float >::ItemType temp3 ;
32105
32106   arg1 = (Dali::Vector< float > *)jarg1;
32107   arg2 = (Dali::Vector< float >::SizeType)jarg2;
32108   temp3 = (Dali::Vector< float >::ItemType)jarg3;
32109   arg3 = &temp3;
32110   {
32111     try {
32112       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
32113     } CALL_CATCH_EXCEPTION();
32114   }
32115
32116 }
32117
32118
32119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
32120   void * jresult ;
32121   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32122   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
32123   Dali::Vector< float >::Iterator result;
32124
32125   arg1 = (Dali::Vector< float > *)jarg1;
32126   arg2 = (Dali::Vector< float >::Iterator)jarg2;
32127   {
32128     try {
32129       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
32130     } CALL_CATCH_EXCEPTION(0);
32131   }
32132
32133   jresult = (void *)result;
32134   return jresult;
32135 }
32136
32137
32138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
32139   void * jresult ;
32140   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32141   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
32142   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
32143   Dali::Vector< float >::Iterator result;
32144
32145   arg1 = (Dali::Vector< float > *)jarg1;
32146   arg2 = (Dali::Vector< float >::Iterator)jarg2;
32147   arg3 = (Dali::Vector< float >::Iterator)jarg3;
32148   {
32149     try {
32150       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
32151     } CALL_CATCH_EXCEPTION(0);
32152   }
32153
32154   jresult = (void *)result;
32155   return jresult;
32156 }
32157
32158
32159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
32160   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32161   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
32162
32163   arg1 = (Dali::Vector< float > *)jarg1;
32164   arg2 = (Dali::Vector< float >::Iterator)jarg2;
32165   {
32166     try {
32167       (arg1)->Remove(arg2);
32168     } CALL_CATCH_EXCEPTION();
32169   }
32170
32171 }
32172
32173
32174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
32175   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32176   Dali::Vector< float > *arg2 = 0 ;
32177
32178   arg1 = (Dali::Vector< float > *)jarg1;
32179   arg2 = (Dali::Vector< float > *)jarg2;
32180   if (!arg2) {
32181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
32182     return ;
32183   }
32184   {
32185     try {
32186       (arg1)->Swap(*arg2);
32187     } CALL_CATCH_EXCEPTION();
32188   }
32189
32190 }
32191
32192
32193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
32194   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32195
32196   arg1 = (Dali::Vector< float > *)jarg1;
32197   {
32198     try {
32199       (arg1)->Clear();
32200     } CALL_CATCH_EXCEPTION();
32201   }
32202
32203 }
32204
32205
32206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
32207   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32208
32209   arg1 = (Dali::Vector< float > *)jarg1;
32210   {
32211     try {
32212       (arg1)->Release();
32213     } CALL_CATCH_EXCEPTION();
32214   }
32215
32216 }
32217
32218
32219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
32220   int jresult ;
32221   int result;
32222
32223   result = (int)Dali::Vector< unsigned char >::BaseType;
32224   jresult = (int)result;
32225   return jresult;
32226 }
32227
32228
32229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
32230   void * jresult ;
32231   Dali::Vector< unsigned char > *result = 0 ;
32232
32233   {
32234     try {
32235       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
32236     } CALL_CATCH_EXCEPTION(0);
32237   }
32238
32239   jresult = (void *)result;
32240   return jresult;
32241 }
32242
32243
32244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
32245   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32246
32247   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32248   {
32249     try {
32250       delete arg1;
32251     } CALL_CATCH_EXCEPTION();
32252   }
32253
32254 }
32255
32256
32257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
32258   void * jresult ;
32259   Dali::Vector< unsigned char > *arg1 = 0 ;
32260   Dali::Vector< unsigned char > *result = 0 ;
32261
32262   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32263   if (!arg1) {
32264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
32265     return 0;
32266   }
32267   {
32268     try {
32269       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
32270     } CALL_CATCH_EXCEPTION(0);
32271   }
32272
32273   jresult = (void *)result;
32274   return jresult;
32275 }
32276
32277
32278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
32279   void * jresult ;
32280   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32281   Dali::Vector< unsigned char > *arg2 = 0 ;
32282   Dali::Vector< unsigned char > *result = 0 ;
32283
32284   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32285   arg2 = (Dali::Vector< unsigned char > *)jarg2;
32286   if (!arg2) {
32287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
32288     return 0;
32289   }
32290   {
32291     try {
32292       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
32293     } CALL_CATCH_EXCEPTION(0);
32294   }
32295
32296   jresult = (void *)result;
32297   return jresult;
32298 }
32299
32300
32301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
32302   void * jresult ;
32303   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32304   Dali::Vector< unsigned char >::Iterator result;
32305
32306   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32307   {
32308     try {
32309       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
32310     } CALL_CATCH_EXCEPTION(0);
32311   }
32312
32313   jresult = (void *)result;
32314   return jresult;
32315 }
32316
32317
32318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
32319   void * jresult ;
32320   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32321   Dali::Vector< unsigned char >::Iterator result;
32322
32323   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32324   {
32325     try {
32326       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
32327     } CALL_CATCH_EXCEPTION(0);
32328   }
32329
32330   jresult = (void *)result;
32331   return jresult;
32332 }
32333
32334
32335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
32336   void * jresult ;
32337   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32338   Dali::Vector< unsigned char >::SizeType arg2 ;
32339   Dali::Vector< unsigned char >::ItemType *result = 0 ;
32340
32341   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32342   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
32343   {
32344     try {
32345       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
32346     } CALL_CATCH_EXCEPTION(0);
32347   }
32348
32349   jresult = (void *)result;
32350   return jresult;
32351 }
32352
32353
32354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
32355   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32356   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
32357   Dali::Vector< unsigned char >::ItemType temp2 ;
32358
32359   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32360   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
32361   arg2 = &temp2;
32362   {
32363     try {
32364       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
32365     } CALL_CATCH_EXCEPTION();
32366   }
32367
32368 }
32369
32370
32371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
32372   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32373   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
32374   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
32375   Dali::Vector< unsigned char >::ItemType temp3 ;
32376
32377   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32378   arg2 = jarg2;
32379   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
32380   arg3 = &temp3;
32381   {
32382     try {
32383       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
32384     } CALL_CATCH_EXCEPTION();
32385   }
32386
32387
32388
32389 }
32390
32391
32392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
32393   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32394   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
32395   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
32396   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
32397
32398   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32399   arg2 = jarg2;
32400   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
32401   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
32402   {
32403     try {
32404       (arg1)->Insert(arg2,arg3,arg4);
32405     } CALL_CATCH_EXCEPTION();
32406   }
32407
32408
32409
32410 }
32411
32412
32413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
32414   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32415   Dali::Vector< unsigned char >::SizeType arg2 ;
32416
32417   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32418   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
32419   {
32420     try {
32421       (arg1)->Reserve(arg2);
32422     } CALL_CATCH_EXCEPTION();
32423   }
32424
32425 }
32426
32427
32428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
32429   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32430   Dali::Vector< unsigned char >::SizeType arg2 ;
32431
32432   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32433   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
32434   {
32435     try {
32436       (arg1)->Resize(arg2);
32437     } CALL_CATCH_EXCEPTION();
32438   }
32439
32440 }
32441
32442
32443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
32444   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32445   Dali::Vector< unsigned char >::SizeType arg2 ;
32446   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
32447   Dali::Vector< unsigned char >::ItemType temp3 ;
32448
32449   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32450   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
32451   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
32452   arg3 = &temp3;
32453   {
32454     try {
32455       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
32456     } CALL_CATCH_EXCEPTION();
32457   }
32458
32459 }
32460
32461
32462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
32463   void * jresult ;
32464   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32465   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
32466   Dali::Vector< unsigned char >::Iterator result;
32467
32468   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32469   arg2 = jarg2;
32470   {
32471     try {
32472       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
32473     } CALL_CATCH_EXCEPTION(0);
32474   }
32475
32476   jresult = (void *)result;
32477
32478
32479   return jresult;
32480 }
32481
32482
32483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
32484   void * jresult ;
32485   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32486   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
32487   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
32488   Dali::Vector< unsigned char >::Iterator result;
32489
32490   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32491   arg2 = jarg2;
32492   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
32493   {
32494     try {
32495       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
32496     } CALL_CATCH_EXCEPTION(0);
32497   }
32498
32499   jresult = (void *)result;
32500
32501
32502   return jresult;
32503 }
32504
32505
32506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
32507   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32508   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
32509
32510   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32511   arg2 = jarg2;
32512   {
32513     try {
32514       (arg1)->Remove(arg2);
32515     } CALL_CATCH_EXCEPTION();
32516   }
32517
32518
32519
32520 }
32521
32522
32523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
32524   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32525   Dali::Vector< unsigned char > *arg2 = 0 ;
32526
32527   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32528   arg2 = (Dali::Vector< unsigned char > *)jarg2;
32529   if (!arg2) {
32530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
32531     return ;
32532   }
32533   {
32534     try {
32535       (arg1)->Swap(*arg2);
32536     } CALL_CATCH_EXCEPTION();
32537   }
32538
32539 }
32540
32541
32542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
32543   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32544
32545   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32546   {
32547     try {
32548       (arg1)->Clear();
32549     } CALL_CATCH_EXCEPTION();
32550   }
32551
32552 }
32553
32554
32555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
32556   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32557
32558   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32559   {
32560     try {
32561       (arg1)->Release();
32562     } CALL_CATCH_EXCEPTION();
32563   }
32564
32565 }
32566
32567
32568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
32569   int jresult ;
32570   int result;
32571
32572   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
32573   jresult = (int)result;
32574   return jresult;
32575 }
32576
32577
32578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
32579   void * jresult ;
32580   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
32581
32582   {
32583     try {
32584       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
32585     } CALL_CATCH_EXCEPTION(0);
32586   }
32587
32588   jresult = (void *)result;
32589   return jresult;
32590 }
32591
32592
32593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
32594   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32595
32596   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32597   {
32598     try {
32599       delete arg1;
32600     } CALL_CATCH_EXCEPTION();
32601   }
32602
32603 }
32604
32605
32606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
32607   void * jresult ;
32608   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
32609   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
32610
32611   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32612   if (!arg1) {
32613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
32614     return 0;
32615   }
32616   {
32617     try {
32618       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
32619     } CALL_CATCH_EXCEPTION(0);
32620   }
32621
32622   jresult = (void *)result;
32623   return jresult;
32624 }
32625
32626
32627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
32628   void * jresult ;
32629   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32630   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
32631   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
32632
32633   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32634   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
32635   if (!arg2) {
32636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
32637     return 0;
32638   }
32639   {
32640     try {
32641       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
32642     } CALL_CATCH_EXCEPTION(0);
32643   }
32644
32645   jresult = (void *)result;
32646   return jresult;
32647 }
32648
32649
32650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
32651   void * jresult ;
32652   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32653   Dali::Vector< Dali::Uint16Pair >::Iterator result;
32654
32655   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32656   {
32657     try {
32658       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
32659     } CALL_CATCH_EXCEPTION(0);
32660   }
32661
32662   jresult = (void *)result;
32663   return jresult;
32664 }
32665
32666
32667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
32668   void * jresult ;
32669   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32670   Dali::Vector< Dali::Uint16Pair >::Iterator result;
32671
32672   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32673   {
32674     try {
32675       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
32676     } CALL_CATCH_EXCEPTION(0);
32677   }
32678
32679   jresult = (void *)result;
32680   return jresult;
32681 }
32682
32683
32684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
32685   void * jresult ;
32686   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32687   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
32688   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
32689
32690   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32691   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
32692   {
32693     try {
32694       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
32695     } CALL_CATCH_EXCEPTION(0);
32696   }
32697
32698   jresult = (void *)result;
32699   return jresult;
32700 }
32701
32702
32703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
32704   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32705   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
32706
32707   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32708   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
32709   if (!arg2) {
32710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
32711     return ;
32712   }
32713   {
32714     try {
32715       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
32716     } CALL_CATCH_EXCEPTION();
32717   }
32718
32719 }
32720
32721
32722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
32723   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32724   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
32725   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
32726
32727   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32728   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
32729   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
32730   if (!arg3) {
32731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
32732     return ;
32733   }
32734   {
32735     try {
32736       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
32737     } CALL_CATCH_EXCEPTION();
32738   }
32739
32740 }
32741
32742
32743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
32744   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32745   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
32746   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
32747   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
32748
32749   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32750   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
32751   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
32752   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
32753   {
32754     try {
32755       (arg1)->Insert(arg2,arg3,arg4);
32756     } CALL_CATCH_EXCEPTION();
32757   }
32758
32759 }
32760
32761
32762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
32763   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32764   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
32765
32766   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32767   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
32768   {
32769     try {
32770       (arg1)->Reserve(arg2);
32771     } CALL_CATCH_EXCEPTION();
32772   }
32773
32774 }
32775
32776
32777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
32778   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32779   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
32780
32781   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32782   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
32783   {
32784     try {
32785       (arg1)->Resize(arg2);
32786     } CALL_CATCH_EXCEPTION();
32787   }
32788
32789 }
32790
32791
32792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
32793   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32794   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
32795   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
32796
32797   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32798   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
32799   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
32800   if (!arg3) {
32801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
32802     return ;
32803   }
32804   {
32805     try {
32806       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
32807     } CALL_CATCH_EXCEPTION();
32808   }
32809
32810 }
32811
32812
32813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
32814   void * jresult ;
32815   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32816   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
32817   Dali::Vector< Dali::Uint16Pair >::Iterator result;
32818
32819   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32820   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
32821   {
32822     try {
32823       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
32824     } CALL_CATCH_EXCEPTION(0);
32825   }
32826
32827   jresult = (void *)result;
32828   return jresult;
32829 }
32830
32831
32832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
32833   void * jresult ;
32834   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32835   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
32836   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
32837   Dali::Vector< Dali::Uint16Pair >::Iterator result;
32838
32839   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32840   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
32841   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
32842   {
32843     try {
32844       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
32845     } CALL_CATCH_EXCEPTION(0);
32846   }
32847
32848   jresult = (void *)result;
32849   return jresult;
32850 }
32851
32852
32853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
32854   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32855   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
32856
32857   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32858   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
32859   {
32860     try {
32861       (arg1)->Remove(arg2);
32862     } CALL_CATCH_EXCEPTION();
32863   }
32864
32865 }
32866
32867
32868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
32869   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32870   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
32871
32872   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32873   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
32874   if (!arg2) {
32875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
32876     return ;
32877   }
32878   {
32879     try {
32880       (arg1)->Swap(*arg2);
32881     } CALL_CATCH_EXCEPTION();
32882   }
32883
32884 }
32885
32886
32887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
32888   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32889
32890   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32891   {
32892     try {
32893       (arg1)->Clear();
32894     } CALL_CATCH_EXCEPTION();
32895   }
32896
32897 }
32898
32899
32900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
32901   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
32902
32903   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
32904   {
32905     try {
32906       (arg1)->Release();
32907     } CALL_CATCH_EXCEPTION();
32908   }
32909
32910 }
32911
32912
32913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
32914   void * jresult ;
32915   Dali::Signal< void () > *result = 0 ;
32916
32917   {
32918     try {
32919       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
32920     } CALL_CATCH_EXCEPTION(0);
32921   }
32922
32923   jresult = (void *)result;
32924   return jresult;
32925 }
32926
32927
32928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
32929   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
32930
32931   arg1 = (Dali::Signal< void () > *)jarg1;
32932   {
32933     try {
32934       delete arg1;
32935     } CALL_CATCH_EXCEPTION();
32936   }
32937
32938 }
32939
32940
32941 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
32942   bool jresult ;
32943   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
32944   bool result;
32945
32946   arg1 = (Dali::Signal< void () > *)jarg1;
32947   {
32948     try {
32949       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
32950     } CALL_CATCH_EXCEPTION(0);
32951   }
32952
32953   jresult = result;
32954   return jresult;
32955 }
32956
32957
32958 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
32959   unsigned long jresult ;
32960   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
32961   std::size_t result;
32962
32963   arg1 = (Dali::Signal< void () > *)jarg1;
32964   {
32965     try {
32966       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
32967     } CALL_CATCH_EXCEPTION(0);
32968   }
32969
32970   jresult = (unsigned long)result;
32971   return jresult;
32972 }
32973
32974
32975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
32976   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
32977   void (*arg2)() = (void (*)()) 0 ;
32978
32979   arg1 = (Dali::Signal< void () > *)jarg1;
32980   arg2 = (void (*)())jarg2;
32981   {
32982     try {
32983       (arg1)->Connect(arg2);
32984     } CALL_CATCH_EXCEPTION();
32985   }
32986
32987 }
32988
32989
32990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
32991   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
32992   void (*arg2)() = (void (*)()) 0 ;
32993
32994   arg1 = (Dali::Signal< void () > *)jarg1;
32995   arg2 = (void (*)())jarg2;
32996   {
32997     try {
32998       (arg1)->Disconnect(arg2);
32999     } CALL_CATCH_EXCEPTION();
33000   }
33001
33002 }
33003
33004
33005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
33006   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
33007   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
33008   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
33009
33010   arg1 = (Dali::Signal< void () > *)jarg1;
33011   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
33012   arg3 = (Dali::FunctorDelegate *)jarg3;
33013   {
33014     try {
33015       (arg1)->Connect(arg2,arg3);
33016     } CALL_CATCH_EXCEPTION();
33017   }
33018
33019 }
33020
33021
33022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
33023   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
33024
33025   arg1 = (Dali::Signal< void () > *)jarg1;
33026   {
33027     try {
33028       (arg1)->Emit();
33029     } CALL_CATCH_EXCEPTION();
33030   }
33031
33032 }
33033
33034
33035 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
33036   bool jresult ;
33037   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
33038   bool result;
33039
33040   arg1 = (Dali::Signal< void (float) > *)jarg1;
33041   {
33042     try {
33043       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
33044     } CALL_CATCH_EXCEPTION(0);
33045   }
33046
33047   jresult = result;
33048   return jresult;
33049 }
33050
33051
33052 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
33053   unsigned long jresult ;
33054   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
33055   std::size_t result;
33056
33057   arg1 = (Dali::Signal< void (float) > *)jarg1;
33058   {
33059     try {
33060       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
33061     } CALL_CATCH_EXCEPTION(0);
33062   }
33063
33064   jresult = (unsigned long)result;
33065   return jresult;
33066 }
33067
33068
33069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
33070   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
33071   void (*arg2)(float) = (void (*)(float)) 0 ;
33072
33073   arg1 = (Dali::Signal< void (float) > *)jarg1;
33074   arg2 = (void (*)(float))jarg2;
33075   {
33076     try {
33077       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
33078     } CALL_CATCH_EXCEPTION();
33079   }
33080
33081 }
33082
33083
33084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
33085   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
33086   void (*arg2)(float) = (void (*)(float)) 0 ;
33087
33088   arg1 = (Dali::Signal< void (float) > *)jarg1;
33089   arg2 = (void (*)(float))jarg2;
33090   {
33091     try {
33092       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
33093     } CALL_CATCH_EXCEPTION();
33094   }
33095
33096 }
33097
33098
33099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
33100   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
33101   float arg2 ;
33102
33103   arg1 = (Dali::Signal< void (float) > *)jarg1;
33104   arg2 = (float)jarg2;
33105   {
33106     try {
33107       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
33108     } CALL_CATCH_EXCEPTION();
33109   }
33110
33111 }
33112
33113
33114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
33115   void * jresult ;
33116   Dali::Signal< void (float) > *result = 0 ;
33117
33118   {
33119     try {
33120       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
33121     } CALL_CATCH_EXCEPTION(0);
33122   }
33123
33124   jresult = (void *)result;
33125   return jresult;
33126 }
33127
33128
33129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
33130   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
33131
33132   arg1 = (Dali::Signal< void (float) > *)jarg1;
33133   {
33134     try {
33135       delete arg1;
33136     } CALL_CATCH_EXCEPTION();
33137   }
33138
33139 }
33140
33141
33142 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
33143   bool jresult ;
33144   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
33145   bool result;
33146
33147   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
33148   {
33149     try {
33150       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
33151     } CALL_CATCH_EXCEPTION(0);
33152   }
33153
33154   jresult = result;
33155   return jresult;
33156 }
33157
33158
33159 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
33160   unsigned long jresult ;
33161   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
33162   std::size_t result;
33163
33164   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
33165   {
33166     try {
33167       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
33168     } CALL_CATCH_EXCEPTION(0);
33169   }
33170
33171   jresult = (unsigned long)result;
33172   return jresult;
33173 }
33174
33175
33176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
33177   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
33178   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
33179
33180   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
33181   arg2 = (void (*)(Dali::BaseHandle))jarg2;
33182   {
33183     try {
33184       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
33185     } CALL_CATCH_EXCEPTION();
33186   }
33187
33188 }
33189
33190
33191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
33192   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
33193   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
33194
33195   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
33196   arg2 = (void (*)(Dali::BaseHandle))jarg2;
33197   {
33198     try {
33199       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
33200     } CALL_CATCH_EXCEPTION();
33201   }
33202
33203 }
33204
33205
33206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
33207   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
33208   Dali::BaseHandle arg2 ;
33209   Dali::BaseHandle *argp2 ;
33210
33211   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
33212   argp2 = (Dali::BaseHandle *)jarg2;
33213   if (!argp2) {
33214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33215     return ;
33216   }
33217   arg2 = *argp2;
33218   {
33219     try {
33220       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
33221     } CALL_CATCH_EXCEPTION();
33222   }
33223
33224 }
33225
33226
33227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
33228   void * jresult ;
33229   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
33230
33231   {
33232     try {
33233       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
33234     } CALL_CATCH_EXCEPTION(0);
33235   }
33236
33237   jresult = (void *)result;
33238   return jresult;
33239 }
33240
33241
33242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
33243   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
33244
33245   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
33246   {
33247     try {
33248       delete arg1;
33249     } CALL_CATCH_EXCEPTION();
33250   }
33251
33252 }
33253
33254
33255 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
33256   bool jresult ;
33257   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
33258   bool result;
33259
33260   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
33261   {
33262     try {
33263       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
33264     } CALL_CATCH_EXCEPTION(0);
33265   }
33266
33267   jresult = result;
33268   return jresult;
33269 }
33270
33271
33272 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
33273   unsigned long jresult ;
33274   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
33275   std::size_t result;
33276
33277   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
33278   {
33279     try {
33280       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
33281     } CALL_CATCH_EXCEPTION(0);
33282   }
33283
33284   jresult = (unsigned long)result;
33285   return jresult;
33286 }
33287
33288
33289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
33290   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
33291   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
33292
33293   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
33294   arg2 = (void (*)(Dali::RefObject const *))jarg2;
33295   {
33296     try {
33297       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
33298     } CALL_CATCH_EXCEPTION();
33299   }
33300
33301 }
33302
33303
33304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
33305   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
33306   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
33307
33308   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
33309   arg2 = (void (*)(Dali::RefObject const *))jarg2;
33310   {
33311     try {
33312       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
33313     } CALL_CATCH_EXCEPTION();
33314   }
33315
33316 }
33317
33318
33319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
33320   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
33321   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
33322
33323   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
33324   arg2 = (Dali::RefObject *)jarg2;
33325   {
33326     try {
33327       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
33328     } CALL_CATCH_EXCEPTION();
33329   }
33330
33331 }
33332
33333
33334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
33335   void * jresult ;
33336   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
33337
33338   {
33339     try {
33340       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
33341     } CALL_CATCH_EXCEPTION(0);
33342   }
33343
33344   jresult = (void *)result;
33345   return jresult;
33346 }
33347
33348
33349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
33350   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
33351
33352   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
33353   {
33354     try {
33355       delete arg1;
33356     } CALL_CATCH_EXCEPTION();
33357   }
33358
33359 }
33360
33361
33362 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
33363   bool jresult ;
33364   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
33365   bool result;
33366
33367   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
33368   {
33369     try {
33370       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
33371     } CALL_CATCH_EXCEPTION(0);
33372   }
33373
33374   jresult = result;
33375   return jresult;
33376 }
33377
33378
33379 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
33380   unsigned long jresult ;
33381   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
33382   std::size_t result;
33383
33384   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
33385   {
33386     try {
33387       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
33388     } CALL_CATCH_EXCEPTION(0);
33389   }
33390
33391   jresult = (unsigned long)result;
33392   return jresult;
33393 }
33394
33395
33396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
33397   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
33398   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
33399
33400   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
33401   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
33402   {
33403     try {
33404       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
33405     } CALL_CATCH_EXCEPTION();
33406   }
33407
33408 }
33409
33410
33411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
33412   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
33413   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
33414
33415   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
33416   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
33417   {
33418     try {
33419       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
33420     } CALL_CATCH_EXCEPTION();
33421   }
33422
33423 }
33424
33425
33426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
33427   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
33428   Dali::PropertyNotification *arg2 = 0 ;
33429
33430   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
33431   arg2 = (Dali::PropertyNotification *)jarg2;
33432   if (!arg2) {
33433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
33434     return ;
33435   }
33436   {
33437     try {
33438       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
33439     } CALL_CATCH_EXCEPTION();
33440   }
33441
33442 }
33443
33444
33445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
33446   void * jresult ;
33447   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
33448
33449   {
33450     try {
33451       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
33452     } CALL_CATCH_EXCEPTION(0);
33453   }
33454
33455   jresult = (void *)result;
33456   return jresult;
33457 }
33458
33459
33460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
33461   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
33462
33463   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
33464   {
33465     try {
33466       delete arg1;
33467     } CALL_CATCH_EXCEPTION();
33468   }
33469
33470 }
33471
33472
33473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
33474   void * jresult ;
33475   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
33476
33477   {
33478     try {
33479       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
33480     } CALL_CATCH_EXCEPTION(0);
33481   }
33482
33483   jresult = (void *)result;
33484   return jresult;
33485 }
33486
33487
33488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
33489   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
33490
33491   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
33492   {
33493     try {
33494       delete arg1;
33495     } CALL_CATCH_EXCEPTION();
33496   }
33497
33498 }
33499
33500
33501 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
33502   bool jresult ;
33503   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
33504   bool result;
33505
33506   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
33507   {
33508     try {
33509       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);
33510     } CALL_CATCH_EXCEPTION(0);
33511   }
33512
33513   jresult = result;
33514   return jresult;
33515 }
33516
33517
33518 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
33519   unsigned long jresult ;
33520   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
33521   std::size_t result;
33522
33523   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
33524   {
33525     try {
33526       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);
33527     } CALL_CATCH_EXCEPTION(0);
33528   }
33529
33530   jresult = (unsigned long)result;
33531   return jresult;
33532 }
33533
33534
33535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
33536   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
33537   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
33538
33539   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
33540   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
33541   {
33542     try {
33543       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
33544     } CALL_CATCH_EXCEPTION();
33545   }
33546
33547 }
33548
33549
33550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
33551   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
33552   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
33553
33554   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
33555   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
33556   {
33557     try {
33558       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
33559     } CALL_CATCH_EXCEPTION();
33560   }
33561
33562 }
33563
33564
33565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
33566   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
33567   Dali::Actor arg2 ;
33568   Dali::LongPressGesture *arg3 = 0 ;
33569   Dali::Actor *argp2 ;
33570
33571   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
33572   argp2 = (Dali::Actor *)jarg2;
33573   if (!argp2) {
33574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33575     return ;
33576   }
33577   arg2 = *argp2;
33578   arg3 = (Dali::LongPressGesture *)jarg3;
33579   if (!arg3) {
33580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
33581     return ;
33582   }
33583   {
33584     try {
33585       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
33586     } CALL_CATCH_EXCEPTION();
33587   }
33588
33589 }
33590
33591
33592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
33593   void * jresult ;
33594   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
33595
33596   {
33597     try {
33598       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
33599     } CALL_CATCH_EXCEPTION(0);
33600   }
33601
33602   jresult = (void *)result;
33603   return jresult;
33604 }
33605
33606
33607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
33608   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
33609
33610   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
33611   {
33612     try {
33613       delete arg1;
33614     } CALL_CATCH_EXCEPTION();
33615   }
33616
33617 }
33618
33619
33620 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
33621   bool jresult ;
33622   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
33623   bool result;
33624
33625   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
33626   {
33627     try {
33628       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);
33629     } CALL_CATCH_EXCEPTION(0);
33630   }
33631
33632   jresult = result;
33633   return jresult;
33634 }
33635
33636
33637 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
33638   unsigned long jresult ;
33639   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
33640   std::size_t result;
33641
33642   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
33643   {
33644     try {
33645       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);
33646     } CALL_CATCH_EXCEPTION(0);
33647   }
33648
33649   jresult = (unsigned long)result;
33650   return jresult;
33651 }
33652
33653
33654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
33655   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
33656   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
33657
33658   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
33659   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
33660   {
33661     try {
33662       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
33663     } CALL_CATCH_EXCEPTION();
33664   }
33665
33666 }
33667
33668
33669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
33670   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
33671   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
33672
33673   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
33674   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
33675   {
33676     try {
33677       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
33678     } CALL_CATCH_EXCEPTION();
33679   }
33680
33681 }
33682
33683
33684 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
33685   bool jresult ;
33686   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
33687   Dali::Actor arg2 ;
33688   Dali::TouchEvent *arg3 = 0 ;
33689   Dali::Actor *argp2 ;
33690   bool result;
33691
33692   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
33693   argp2 = (Dali::Actor *)jarg2;
33694   if (!argp2) {
33695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33696     return 0;
33697   }
33698   arg2 = *argp2;
33699   arg3 = (Dali::TouchEvent *)jarg3;
33700   if (!arg3) {
33701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
33702     return 0;
33703   }
33704   {
33705     try {
33706       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchEvent const &)*arg3);
33707     } CALL_CATCH_EXCEPTION(0);
33708   }
33709
33710   jresult = result;
33711   return jresult;
33712 }
33713
33714
33715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
33716   void * jresult ;
33717   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *result = 0 ;
33718
33719   {
33720     try {
33721       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) >();
33722     } CALL_CATCH_EXCEPTION(0);
33723   }
33724
33725   jresult = (void *)result;
33726   return jresult;
33727 }
33728
33729
33730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
33731   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
33732
33733   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
33734   {
33735     try {
33736       delete arg1;
33737     } CALL_CATCH_EXCEPTION();
33738   }
33739
33740 }
33741
33742
33743 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
33744   bool jresult ;
33745   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
33746   bool result;
33747
33748   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
33749   {
33750     try {
33751       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);
33752     } CALL_CATCH_EXCEPTION(0);
33753   }
33754
33755   jresult = result;
33756   return jresult;
33757 }
33758
33759
33760 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
33761   unsigned long jresult ;
33762   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
33763   std::size_t result;
33764
33765   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
33766   {
33767     try {
33768       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);
33769     } CALL_CATCH_EXCEPTION(0);
33770   }
33771
33772   jresult = (unsigned long)result;
33773   return jresult;
33774 }
33775
33776
33777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
33778   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
33779   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
33780
33781   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
33782   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
33783   {
33784     try {
33785       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
33786     } CALL_CATCH_EXCEPTION();
33787   }
33788
33789 }
33790
33791
33792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
33793   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
33794   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
33795
33796   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
33797   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
33798   {
33799     try {
33800       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
33801     } CALL_CATCH_EXCEPTION();
33802   }
33803
33804 }
33805
33806
33807 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
33808   bool jresult ;
33809   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
33810   Dali::Actor arg2 ;
33811   Dali::HoverEvent *arg3 = 0 ;
33812   Dali::Actor *argp2 ;
33813   bool result;
33814
33815   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
33816   argp2 = (Dali::Actor *)jarg2;
33817   if (!argp2) {
33818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33819     return 0;
33820   }
33821   arg2 = *argp2;
33822   arg3 = (Dali::HoverEvent *)jarg3;
33823   if (!arg3) {
33824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
33825     return 0;
33826   }
33827   {
33828     try {
33829       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
33830     } CALL_CATCH_EXCEPTION(0);
33831   }
33832
33833   jresult = result;
33834   return jresult;
33835 }
33836
33837
33838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
33839   void * jresult ;
33840   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
33841
33842   {
33843     try {
33844       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
33845     } CALL_CATCH_EXCEPTION(0);
33846   }
33847
33848   jresult = (void *)result;
33849   return jresult;
33850 }
33851
33852
33853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
33854   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
33855
33856   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
33857   {
33858     try {
33859       delete arg1;
33860     } CALL_CATCH_EXCEPTION();
33861   }
33862
33863 }
33864
33865
33866 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
33867   bool jresult ;
33868   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
33869   bool result;
33870
33871   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
33872   {
33873     try {
33874       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);
33875     } CALL_CATCH_EXCEPTION(0);
33876   }
33877
33878   jresult = result;
33879   return jresult;
33880 }
33881
33882
33883 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
33884   unsigned long jresult ;
33885   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
33886   std::size_t result;
33887
33888   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
33889   {
33890     try {
33891       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);
33892     } CALL_CATCH_EXCEPTION(0);
33893   }
33894
33895   jresult = (unsigned long)result;
33896   return jresult;
33897 }
33898
33899
33900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
33901   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
33902   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
33903
33904   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
33905   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
33906   {
33907     try {
33908       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
33909     } CALL_CATCH_EXCEPTION();
33910   }
33911
33912 }
33913
33914
33915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
33916   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
33917   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
33918
33919   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
33920   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
33921   {
33922     try {
33923       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
33924     } CALL_CATCH_EXCEPTION();
33925   }
33926
33927 }
33928
33929
33930 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
33931   bool jresult ;
33932   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
33933   Dali::Actor arg2 ;
33934   Dali::WheelEvent *arg3 = 0 ;
33935   Dali::Actor *argp2 ;
33936   bool result;
33937
33938   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
33939   argp2 = (Dali::Actor *)jarg2;
33940   if (!argp2) {
33941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33942     return 0;
33943   }
33944   arg2 = *argp2;
33945   arg3 = (Dali::WheelEvent *)jarg3;
33946   if (!arg3) {
33947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
33948     return 0;
33949   }
33950   {
33951     try {
33952       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
33953     } CALL_CATCH_EXCEPTION(0);
33954   }
33955
33956   jresult = result;
33957   return jresult;
33958 }
33959
33960
33961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
33962   void * jresult ;
33963   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
33964
33965   {
33966     try {
33967       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
33968     } CALL_CATCH_EXCEPTION(0);
33969   }
33970
33971   jresult = (void *)result;
33972   return jresult;
33973 }
33974
33975
33976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
33977   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
33978
33979   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
33980   {
33981     try {
33982       delete arg1;
33983     } CALL_CATCH_EXCEPTION();
33984   }
33985
33986 }
33987
33988
33989 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
33990   bool jresult ;
33991   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
33992   bool result;
33993
33994   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
33995   {
33996     try {
33997       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
33998     } CALL_CATCH_EXCEPTION(0);
33999   }
34000
34001   jresult = result;
34002   return jresult;
34003 }
34004
34005
34006 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
34007   unsigned long jresult ;
34008   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
34009   std::size_t result;
34010
34011   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
34012   {
34013     try {
34014       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
34015     } CALL_CATCH_EXCEPTION(0);
34016   }
34017
34018   jresult = (unsigned long)result;
34019   return jresult;
34020 }
34021
34022
34023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
34024   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
34025   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
34026
34027   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
34028   arg2 = (void (*)(Dali::Actor))jarg2;
34029   {
34030     try {
34031       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
34032     } CALL_CATCH_EXCEPTION();
34033   }
34034
34035 }
34036
34037
34038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
34039   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
34040   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
34041
34042   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
34043   arg2 = (void (*)(Dali::Actor))jarg2;
34044   {
34045     try {
34046       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
34047     } CALL_CATCH_EXCEPTION();
34048   }
34049
34050 }
34051
34052
34053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
34054   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
34055   Dali::Actor arg2 ;
34056   Dali::Actor *argp2 ;
34057
34058   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
34059   argp2 = (Dali::Actor *)jarg2;
34060   if (!argp2) {
34061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34062     return ;
34063   }
34064   arg2 = *argp2;
34065   {
34066     try {
34067       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
34068     } CALL_CATCH_EXCEPTION();
34069   }
34070
34071 }
34072
34073
34074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
34075   void * jresult ;
34076   Dali::Signal< void (Dali::Actor) > *result = 0 ;
34077
34078   {
34079     try {
34080       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
34081     } CALL_CATCH_EXCEPTION(0);
34082   }
34083
34084   jresult = (void *)result;
34085   return jresult;
34086 }
34087
34088
34089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
34090   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
34091
34092   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
34093   {
34094     try {
34095       delete arg1;
34096     } CALL_CATCH_EXCEPTION();
34097   }
34098
34099 }
34100
34101
34102 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
34103   bool jresult ;
34104   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
34105   bool result;
34106
34107   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
34108   {
34109     try {
34110       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
34111     } CALL_CATCH_EXCEPTION(0);
34112   }
34113
34114   jresult = result;
34115   return jresult;
34116 }
34117
34118
34119 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
34120   unsigned long jresult ;
34121   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
34122   std::size_t result;
34123
34124   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
34125   {
34126     try {
34127       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
34128     } CALL_CATCH_EXCEPTION(0);
34129   }
34130
34131   jresult = (unsigned long)result;
34132   return jresult;
34133 }
34134
34135
34136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
34137   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
34138   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
34139
34140   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
34141   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
34142   {
34143     try {
34144       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
34145     } CALL_CATCH_EXCEPTION();
34146   }
34147
34148 }
34149
34150
34151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
34152   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
34153   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
34154
34155   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
34156   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
34157   {
34158     try {
34159       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
34160     } CALL_CATCH_EXCEPTION();
34161   }
34162
34163 }
34164
34165
34166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
34167   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
34168   Dali::KeyEvent *arg2 = 0 ;
34169
34170   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
34171   arg2 = (Dali::KeyEvent *)jarg2;
34172   if (!arg2) {
34173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
34174     return ;
34175   }
34176   {
34177     try {
34178       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
34179     } CALL_CATCH_EXCEPTION();
34180   }
34181
34182 }
34183
34184
34185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
34186   void * jresult ;
34187   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
34188
34189   {
34190     try {
34191       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
34192     } CALL_CATCH_EXCEPTION(0);
34193   }
34194
34195   jresult = (void *)result;
34196   return jresult;
34197 }
34198
34199
34200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
34201   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
34202
34203   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
34204   {
34205     try {
34206       delete arg1;
34207     } CALL_CATCH_EXCEPTION();
34208   }
34209
34210 }
34211
34212
34213 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
34214   bool jresult ;
34215   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
34216   bool result;
34217
34218   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
34219   {
34220     try {
34221       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
34222     } CALL_CATCH_EXCEPTION(0);
34223   }
34224
34225   jresult = result;
34226   return jresult;
34227 }
34228
34229
34230 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
34231   unsigned long jresult ;
34232   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
34233   std::size_t result;
34234
34235   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
34236   {
34237     try {
34238       result = Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
34239     } CALL_CATCH_EXCEPTION(0);
34240   }
34241
34242   jresult = (unsigned long)result;
34243   return jresult;
34244 }
34245
34246
34247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
34248   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
34249   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
34250
34251   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
34252   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
34253   {
34254     try {
34255       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
34256     } CALL_CATCH_EXCEPTION();
34257   }
34258
34259 }
34260
34261
34262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
34263   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
34264   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
34265
34266   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
34267   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
34268   {
34269     try {
34270       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
34271     } CALL_CATCH_EXCEPTION();
34272   }
34273
34274 }
34275
34276
34277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
34278   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
34279   Dali::TouchEvent *arg2 = 0 ;
34280
34281   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
34282   arg2 = (Dali::TouchEvent *)jarg2;
34283   if (!arg2) {
34284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
34285     return ;
34286   }
34287   {
34288     try {
34289       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchEvent const &)*arg2);
34290     } CALL_CATCH_EXCEPTION();
34291   }
34292
34293 }
34294
34295
34296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
34297   void * jresult ;
34298   Dali::Signal< void (Dali::TouchEvent const &) > *result = 0 ;
34299
34300   {
34301     try {
34302       result = (Dali::Signal< void (Dali::TouchEvent const &) > *)new Dali::Signal< void (Dali::TouchEvent const &) >();
34303     } CALL_CATCH_EXCEPTION(0);
34304   }
34305
34306   jresult = (void *)result;
34307   return jresult;
34308 }
34309
34310
34311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
34312   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
34313
34314   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
34315   {
34316     try {
34317       delete arg1;
34318     } CALL_CATCH_EXCEPTION();
34319   }
34320
34321 }
34322
34323
34324 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
34325   bool jresult ;
34326   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
34327   bool result;
34328
34329   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
34330   {
34331     try {
34332       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
34333     } CALL_CATCH_EXCEPTION(0);
34334   }
34335
34336   jresult = result;
34337   return jresult;
34338 }
34339
34340
34341 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
34342   unsigned long jresult ;
34343   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
34344   std::size_t result;
34345
34346   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
34347   {
34348     try {
34349       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
34350     } CALL_CATCH_EXCEPTION(0);
34351   }
34352
34353   jresult = (unsigned long)result;
34354   return jresult;
34355 }
34356
34357
34358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
34359   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
34360   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
34361
34362   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
34363   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
34364   {
34365     try {
34366       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
34367     } CALL_CATCH_EXCEPTION();
34368   }
34369
34370 }
34371
34372
34373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
34374   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
34375   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
34376
34377   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
34378   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
34379   {
34380     try {
34381       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
34382     } CALL_CATCH_EXCEPTION();
34383   }
34384
34385 }
34386
34387
34388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
34389   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
34390   Dali::WheelEvent *arg2 = 0 ;
34391
34392   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
34393   arg2 = (Dali::WheelEvent *)jarg2;
34394   if (!arg2) {
34395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34396     return ;
34397   }
34398   {
34399     try {
34400       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
34401     } CALL_CATCH_EXCEPTION();
34402   }
34403
34404 }
34405
34406
34407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
34408   void * jresult ;
34409   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
34410
34411   {
34412     try {
34413       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
34414     } CALL_CATCH_EXCEPTION(0);
34415   }
34416
34417   jresult = (void *)result;
34418   return jresult;
34419 }
34420
34421
34422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
34423   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
34424
34425   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
34426   {
34427     try {
34428       delete arg1;
34429     } CALL_CATCH_EXCEPTION();
34430   }
34431
34432 }
34433
34434
34435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
34436   void * jresult ;
34437   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
34438
34439   {
34440     try {
34441       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
34442     } CALL_CATCH_EXCEPTION(0);
34443   }
34444
34445   jresult = (void *)result;
34446   return jresult;
34447 }
34448
34449
34450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
34451   void * jresult ;
34452   Dali::Radian arg1 ;
34453   Dali::Radian arg2 ;
34454   Dali::Radian *argp1 ;
34455   Dali::Radian *argp2 ;
34456   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
34457
34458   argp1 = (Dali::Radian *)jarg1;
34459   if (!argp1) {
34460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
34461     return 0;
34462   }
34463   arg1 = *argp1;
34464   argp2 = (Dali::Radian *)jarg2;
34465   if (!argp2) {
34466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
34467     return 0;
34468   }
34469   arg2 = *argp2;
34470   {
34471     try {
34472       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
34473     } CALL_CATCH_EXCEPTION(0);
34474   }
34475
34476   jresult = (void *)result;
34477   return jresult;
34478 }
34479
34480
34481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
34482   void * jresult ;
34483   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
34484   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
34485
34486   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
34487   if (!arg1) {
34488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
34489     return 0;
34490   }
34491   {
34492     try {
34493       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
34494     } CALL_CATCH_EXCEPTION(0);
34495   }
34496
34497   jresult = (void *)result;
34498   return jresult;
34499 }
34500
34501
34502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
34503   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
34504   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
34505
34506   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
34507   arg2 = (Dali::Radian *)jarg2;
34508   if (arg1) (arg1)->first = *arg2;
34509 }
34510
34511
34512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
34513   void * jresult ;
34514   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
34515   Dali::Radian *result = 0 ;
34516
34517   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
34518   result = (Dali::Radian *)& ((arg1)->first);
34519   jresult = (void *)result;
34520   return jresult;
34521 }
34522
34523
34524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
34525   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
34526   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
34527
34528   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
34529   arg2 = (Dali::Radian *)jarg2;
34530   if (arg1) (arg1)->second = *arg2;
34531 }
34532
34533
34534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
34535   void * jresult ;
34536   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
34537   Dali::Radian *result = 0 ;
34538
34539   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
34540   result = (Dali::Radian *)& ((arg1)->second);
34541   jresult = (void *)result;
34542   return jresult;
34543 }
34544
34545
34546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
34547   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
34548
34549   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
34550   {
34551     try {
34552       delete arg1;
34553     } CALL_CATCH_EXCEPTION();
34554   }
34555
34556 }
34557
34558
34559 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
34560   bool jresult ;
34561   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
34562   bool result;
34563
34564   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
34565   {
34566     try {
34567       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);
34568     } CALL_CATCH_EXCEPTION(0);
34569   }
34570
34571   jresult = result;
34572   return jresult;
34573 }
34574
34575
34576 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
34577   unsigned long jresult ;
34578   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
34579   std::size_t result;
34580
34581   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
34582   {
34583     try {
34584       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);
34585     } CALL_CATCH_EXCEPTION(0);
34586   }
34587
34588   jresult = (unsigned long)result;
34589   return jresult;
34590 }
34591
34592
34593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
34594   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
34595   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
34596
34597   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
34598   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
34599   {
34600     try {
34601       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
34602     } CALL_CATCH_EXCEPTION();
34603   }
34604
34605 }
34606
34607
34608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
34609   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
34610   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
34611
34612   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
34613   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
34614   {
34615     try {
34616       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
34617     } CALL_CATCH_EXCEPTION();
34618   }
34619
34620 }
34621
34622
34623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
34624   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
34625   Dali::Actor arg2 ;
34626   Dali::PanGesture *arg3 = 0 ;
34627   Dali::Actor *argp2 ;
34628
34629   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
34630   argp2 = (Dali::Actor *)jarg2;
34631   if (!argp2) {
34632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34633     return ;
34634   }
34635   arg2 = *argp2;
34636   arg3 = (Dali::PanGesture *)jarg3;
34637   if (!arg3) {
34638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
34639     return ;
34640   }
34641   {
34642     try {
34643       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
34644     } CALL_CATCH_EXCEPTION();
34645   }
34646
34647 }
34648
34649
34650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
34651   void * jresult ;
34652   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
34653
34654   {
34655     try {
34656       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
34657     } CALL_CATCH_EXCEPTION(0);
34658   }
34659
34660   jresult = (void *)result;
34661   return jresult;
34662 }
34663
34664
34665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
34666   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
34667
34668   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
34669   {
34670     try {
34671       delete arg1;
34672     } CALL_CATCH_EXCEPTION();
34673   }
34674
34675 }
34676
34677
34678 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
34679   bool jresult ;
34680   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
34681   bool result;
34682
34683   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
34684   {
34685     try {
34686       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);
34687     } CALL_CATCH_EXCEPTION(0);
34688   }
34689
34690   jresult = result;
34691   return jresult;
34692 }
34693
34694
34695 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
34696   unsigned long jresult ;
34697   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
34698   std::size_t result;
34699
34700   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
34701   {
34702     try {
34703       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);
34704     } CALL_CATCH_EXCEPTION(0);
34705   }
34706
34707   jresult = (unsigned long)result;
34708   return jresult;
34709 }
34710
34711
34712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
34713   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
34714   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
34715
34716   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
34717   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
34718   {
34719     try {
34720       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
34721     } CALL_CATCH_EXCEPTION();
34722   }
34723
34724 }
34725
34726
34727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
34728   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
34729   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
34730
34731   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
34732   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
34733   {
34734     try {
34735       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
34736     } CALL_CATCH_EXCEPTION();
34737   }
34738
34739 }
34740
34741
34742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
34743   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
34744   Dali::Actor arg2 ;
34745   Dali::PinchGesture *arg3 = 0 ;
34746   Dali::Actor *argp2 ;
34747
34748   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
34749   argp2 = (Dali::Actor *)jarg2;
34750   if (!argp2) {
34751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34752     return ;
34753   }
34754   arg2 = *argp2;
34755   arg3 = (Dali::PinchGesture *)jarg3;
34756   if (!arg3) {
34757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
34758     return ;
34759   }
34760   {
34761     try {
34762       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
34763     } CALL_CATCH_EXCEPTION();
34764   }
34765
34766 }
34767
34768
34769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
34770   void * jresult ;
34771   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
34772
34773   {
34774     try {
34775       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
34776     } CALL_CATCH_EXCEPTION(0);
34777   }
34778
34779   jresult = (void *)result;
34780   return jresult;
34781 }
34782
34783
34784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
34785   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
34786
34787   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
34788   {
34789     try {
34790       delete arg1;
34791     } CALL_CATCH_EXCEPTION();
34792   }
34793
34794 }
34795
34796
34797 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
34798   bool jresult ;
34799   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
34800   bool result;
34801
34802   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
34803   {
34804     try {
34805       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);
34806     } CALL_CATCH_EXCEPTION(0);
34807   }
34808
34809   jresult = result;
34810   return jresult;
34811 }
34812
34813
34814 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
34815   unsigned long jresult ;
34816   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
34817   std::size_t result;
34818
34819   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
34820   {
34821     try {
34822       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);
34823     } CALL_CATCH_EXCEPTION(0);
34824   }
34825
34826   jresult = (unsigned long)result;
34827   return jresult;
34828 }
34829
34830
34831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
34832   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
34833   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
34834
34835   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
34836   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
34837   {
34838     try {
34839       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
34840     } CALL_CATCH_EXCEPTION();
34841   }
34842
34843 }
34844
34845
34846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
34847   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
34848   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
34849
34850   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
34851   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
34852   {
34853     try {
34854       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
34855     } CALL_CATCH_EXCEPTION();
34856   }
34857
34858 }
34859
34860
34861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
34862   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
34863   Dali::Actor arg2 ;
34864   Dali::TapGesture *arg3 = 0 ;
34865   Dali::Actor *argp2 ;
34866
34867   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
34868   argp2 = (Dali::Actor *)jarg2;
34869   if (!argp2) {
34870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34871     return ;
34872   }
34873   arg2 = *argp2;
34874   arg3 = (Dali::TapGesture *)jarg3;
34875   if (!arg3) {
34876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
34877     return ;
34878   }
34879   {
34880     try {
34881       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
34882     } CALL_CATCH_EXCEPTION();
34883   }
34884
34885 }
34886
34887
34888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
34889   void * jresult ;
34890   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
34891
34892   {
34893     try {
34894       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
34895     } CALL_CATCH_EXCEPTION(0);
34896   }
34897
34898   jresult = (void *)result;
34899   return jresult;
34900 }
34901
34902
34903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
34904   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
34905
34906   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
34907   {
34908     try {
34909       delete arg1;
34910     } CALL_CATCH_EXCEPTION();
34911   }
34912
34913 }
34914
34915
34916 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
34917   bool jresult ;
34918   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
34919   bool result = false;
34920
34921   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
34922   {
34923     try {
34924       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);
34925     } CALL_CATCH_EXCEPTION(0);
34926   }
34927   jresult = result;
34928   return jresult;
34929 }
34930
34931 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
34932   unsigned long jresult ;
34933   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
34934   std::size_t result = 0;
34935
34936   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
34937   {
34938     try {
34939       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);
34940     }CALL_CATCH_EXCEPTION(0);
34941   }
34942   jresult = (unsigned long)result;
34943   return jresult;
34944 }
34945
34946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
34947   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
34948   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
34949
34950   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
34951   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
34952   {
34953     try {
34954       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
34955     } CALL_CATCH_EXCEPTION();
34956   }
34957 }
34958
34959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
34960   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
34961   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
34962
34963   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
34964   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
34965   {
34966     try {
34967       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
34968     } CALL_CATCH_EXCEPTION();
34969   }
34970 }
34971
34972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
34973   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
34974   Dali::Actor arg2 ;
34975   //bool arg3 ;
34976   Dali::LayoutDirection::Type arg4 ;
34977   Dali::Actor *argp2 ;
34978
34979   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
34980   argp2 = (Dali::Actor *)jarg2;
34981   if (!argp2) {
34982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34983     return ;
34984   }
34985   arg2 = *argp2;
34986   //arg3 = jarg3 ? true : false;
34987   arg4 = (Dali::LayoutDirection::Type)jarg4;
34988   {
34989     try {
34990       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
34991     } CALL_CATCH_EXCEPTION();
34992   }
34993 }
34994
34995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
34996   void * jresult ;
34997   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
34998
34999   {
35000     try {
35001       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
35002     } CALL_CATCH_EXCEPTION(0);
35003   }
35004   jresult = (void *)result;
35005   return jresult;
35006 }
35007
35008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
35009   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
35010
35011   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
35012   {
35013     try {
35014       delete arg1;
35015     } CALL_CATCH_EXCEPTION();
35016   }
35017 }
35018
35019
35020 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
35021   bool jresult ;
35022   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
35023   bool result = false;
35024
35025   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
35026   {
35027     try {
35028       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);
35029     } CALL_CATCH_EXCEPTION(0);
35030   }
35031   jresult = result;
35032   return jresult;
35033 }
35034
35035
35036 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
35037   unsigned long jresult ;
35038   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
35039   std::size_t result;
35040
35041   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
35042   {
35043     try {
35044       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);
35045     } CALL_CATCH_EXCEPTION(0);
35046   }
35047
35048   jresult = (unsigned long)result;
35049   return jresult;
35050 }
35051
35052
35053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
35054   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
35055   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
35056
35057   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
35058   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
35059   {
35060     try {
35061       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
35062     } CALL_CATCH_EXCEPTION();
35063   }
35064
35065 }
35066
35067
35068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
35069   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
35070   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
35071
35072   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
35073   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
35074   {
35075     try {
35076       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
35077     } CALL_CATCH_EXCEPTION();
35078   }
35079
35080 }
35081
35082
35083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, bool jarg3, int jarg4) {
35084   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
35085   Dali::Actor arg2 ;
35086   bool arg3 ;
35087   Dali::DevelActor::VisibilityChange::Type arg4 ;
35088   Dali::Actor *argp2 ;
35089
35090   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
35091   argp2 = (Dali::Actor *)jarg2;
35092   if (!argp2) {
35093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
35094     return ;
35095   }
35096   arg2 = *argp2;
35097   arg3 = jarg3 ? true : false;
35098   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
35099   {
35100     try {
35101       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
35102     } CALL_CATCH_EXCEPTION();
35103   }
35104
35105 }
35106
35107
35108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
35109   void * jresult ;
35110   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
35111
35112   {
35113     try {
35114       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
35115     } CALL_CATCH_EXCEPTION(0);
35116   }
35117
35118   jresult = (void *)result;
35119   return jresult;
35120 }
35121
35122
35123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
35124   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
35125
35126   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
35127   {
35128     try {
35129       delete arg1;
35130     } CALL_CATCH_EXCEPTION();
35131   }
35132
35133 }
35134
35135
35136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
35137   void * jresult ;
35138   Dali::Timer *result = 0 ;
35139
35140   {
35141     try {
35142       result = (Dali::Timer *)new Dali::Timer();
35143     } CALL_CATCH_EXCEPTION(0);
35144   }
35145
35146   jresult = (void *)result;
35147   return jresult;
35148 }
35149
35150
35151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
35152   void * jresult ;
35153   unsigned int arg1 ;
35154   Dali::Timer result;
35155
35156   arg1 = (unsigned int)jarg1;
35157   {
35158     try {
35159       result = Dali::Timer::New(arg1);
35160     } CALL_CATCH_EXCEPTION(0);
35161   }
35162
35163   jresult = new Dali::Timer((const Dali::Timer &)result);
35164   return jresult;
35165 }
35166
35167
35168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
35169   void * jresult ;
35170   Dali::Timer *arg1 = 0 ;
35171   Dali::Timer *result = 0 ;
35172
35173   arg1 = (Dali::Timer *)jarg1;
35174   if (!arg1) {
35175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
35176     return 0;
35177   }
35178   {
35179     try {
35180       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
35181     } CALL_CATCH_EXCEPTION(0);
35182   }
35183
35184   jresult = (void *)result;
35185   return jresult;
35186 }
35187
35188
35189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
35190   void * jresult ;
35191   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
35192   Dali::Timer *arg2 = 0 ;
35193   Dali::Timer *result = 0 ;
35194
35195   arg1 = (Dali::Timer *)jarg1;
35196   arg2 = (Dali::Timer *)jarg2;
35197   if (!arg2) {
35198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
35199     return 0;
35200   }
35201   {
35202     try {
35203       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
35204     } CALL_CATCH_EXCEPTION(0);
35205   }
35206
35207   jresult = (void *)result;
35208   return jresult;
35209 }
35210
35211
35212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
35213   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
35214
35215   arg1 = (Dali::Timer *)jarg1;
35216   {
35217     try {
35218       delete arg1;
35219     } CALL_CATCH_EXCEPTION();
35220   }
35221
35222 }
35223
35224
35225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
35226   void * jresult ;
35227   Dali::BaseHandle arg1 ;
35228   Dali::BaseHandle *argp1 ;
35229   Dali::Timer result;
35230
35231   argp1 = (Dali::BaseHandle *)jarg1;
35232   if (!argp1) {
35233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35234     return 0;
35235   }
35236   arg1 = *argp1;
35237   {
35238     try {
35239       result = Dali::Timer::DownCast(arg1);
35240     } CALL_CATCH_EXCEPTION(0);
35241   }
35242
35243   jresult = new Dali::Timer((const Dali::Timer &)result);
35244   return jresult;
35245 }
35246
35247
35248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
35249   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
35250
35251   arg1 = (Dali::Timer *)jarg1;
35252   {
35253     try {
35254       (arg1)->Start();
35255     } CALL_CATCH_EXCEPTION();
35256   }
35257
35258 }
35259
35260
35261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
35262   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
35263
35264   arg1 = (Dali::Timer *)jarg1;
35265   {
35266     try {
35267       (arg1)->Stop();
35268     } CALL_CATCH_EXCEPTION();
35269   }
35270
35271 }
35272
35273
35274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
35275   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
35276   unsigned int arg2 ;
35277
35278   arg1 = (Dali::Timer *)jarg1;
35279   arg2 = (unsigned int)jarg2;
35280   {
35281     try {
35282       (arg1)->SetInterval(arg2);
35283     } CALL_CATCH_EXCEPTION();
35284   }
35285
35286 }
35287
35288
35289 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
35290   unsigned int jresult ;
35291   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
35292   unsigned int result;
35293
35294   arg1 = (Dali::Timer *)jarg1;
35295   {
35296     try {
35297       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
35298     } CALL_CATCH_EXCEPTION(0);
35299   }
35300
35301   jresult = result;
35302   return jresult;
35303 }
35304
35305
35306 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
35307   bool jresult ;
35308   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
35309   bool result;
35310
35311   arg1 = (Dali::Timer *)jarg1;
35312   {
35313     try {
35314       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
35315     } CALL_CATCH_EXCEPTION(0);
35316   }
35317
35318   jresult = result;
35319   return jresult;
35320 }
35321
35322
35323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
35324   void * jresult ;
35325   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
35326   Dali::Timer::TimerSignalType *result = 0 ;
35327
35328   arg1 = (Dali::Timer *)jarg1;
35329   {
35330     try {
35331       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
35332     } CALL_CATCH_EXCEPTION(0);
35333   }
35334
35335   jresult = (void *)result;
35336   return jresult;
35337 }
35338
35339
35340 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
35341   bool jresult ;
35342   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
35343   bool result;
35344
35345   arg1 = (Dali::Signal< bool () > *)jarg1;
35346   {
35347     try {
35348       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
35349     } CALL_CATCH_EXCEPTION(0);
35350   }
35351
35352   jresult = result;
35353   return jresult;
35354 }
35355
35356
35357 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
35358   unsigned long jresult ;
35359   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
35360   std::size_t result;
35361
35362   arg1 = (Dali::Signal< bool () > *)jarg1;
35363   {
35364     try {
35365       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
35366     } CALL_CATCH_EXCEPTION(0);
35367   }
35368
35369   jresult = (unsigned long)result;
35370   return jresult;
35371 }
35372
35373
35374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
35375   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
35376   bool (*arg2)() = (bool (*)()) 0 ;
35377
35378   arg1 = (Dali::Signal< bool () > *)jarg1;
35379   arg2 = (bool (*)())jarg2;
35380   {
35381     try {
35382       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
35383     } CALL_CATCH_EXCEPTION();
35384   }
35385
35386 }
35387
35388
35389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
35390   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
35391   bool (*arg2)() = (bool (*)()) 0 ;
35392
35393   arg1 = (Dali::Signal< bool () > *)jarg1;
35394   arg2 = (bool (*)())jarg2;
35395   {
35396     try {
35397       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
35398     } CALL_CATCH_EXCEPTION();
35399   }
35400
35401 }
35402
35403
35404 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
35405   bool jresult ;
35406   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
35407   bool result;
35408
35409   arg1 = (Dali::Signal< bool () > *)jarg1;
35410   {
35411     try {
35412       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
35413     } CALL_CATCH_EXCEPTION(0);
35414   }
35415
35416   jresult = result;
35417   return jresult;
35418 }
35419
35420
35421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
35422   void * jresult ;
35423   Dali::Signal< bool () > *result = 0 ;
35424
35425   {
35426     try {
35427       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
35428     } CALL_CATCH_EXCEPTION(0);
35429   }
35430
35431   jresult = (void *)result;
35432   return jresult;
35433 }
35434
35435
35436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
35437   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
35438
35439   arg1 = (Dali::Signal< bool () > *)jarg1;
35440   {
35441     try {
35442       delete arg1;
35443     } CALL_CATCH_EXCEPTION();
35444   }
35445
35446 }
35447
35448
35449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
35450   int jresult ;
35451   int result;
35452
35453   {
35454     try {
35455       result = (int)Dali::Toolkit::Visual::Property::TYPE;
35456     } CALL_CATCH_EXCEPTION(0);
35457   }
35458
35459   jresult = (int)result;
35460   return jresult;
35461 }
35462
35463
35464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
35465   int jresult ;
35466   int result;
35467
35468   {
35469     try {
35470       result = (int)Dali::Toolkit::Visual::Property::SHADER;
35471     } CALL_CATCH_EXCEPTION(0);
35472   }
35473
35474   jresult = (int)result;
35475   return jresult;
35476 }
35477
35478
35479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
35480   int jresult ;
35481   int result;
35482
35483   {
35484     try {
35485       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
35486     } CALL_CATCH_EXCEPTION(0);
35487   }
35488
35489   jresult = (int)result;
35490   return jresult;
35491 }
35492
35493
35494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
35495   int jresult ;
35496   int result;
35497
35498   {
35499     try {
35500       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
35501     } CALL_CATCH_EXCEPTION(0);
35502   }
35503
35504   jresult = (int)result;
35505   return jresult;
35506 }
35507
35508
35509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
35510   int jresult ;
35511   int result;
35512
35513   {
35514     try {
35515       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
35516     } CALL_CATCH_EXCEPTION(0);
35517   }
35518
35519   jresult = (int)result;
35520   return jresult;
35521 }
35522
35523
35524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
35525   int jresult ;
35526   int result;
35527
35528   {
35529     try {
35530       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
35531     } CALL_CATCH_EXCEPTION(0);
35532   }
35533
35534   jresult = (int)result;
35535   return jresult;
35536 }
35537
35538
35539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
35540   int jresult ;
35541   int result;
35542
35543   {
35544     try {
35545       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
35546     } CALL_CATCH_EXCEPTION(0);
35547   }
35548
35549   jresult = (int)result;
35550   return jresult;
35551 }
35552
35553
35554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
35555   int jresult ;
35556   int result;
35557
35558   {
35559     try {
35560       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
35561     } CALL_CATCH_EXCEPTION(0);
35562   }
35563
35564   jresult = (int)result;
35565   return jresult;
35566 }
35567
35568
35569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
35570   int jresult ;
35571   int result;
35572
35573   {
35574     try {
35575       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
35576     } CALL_CATCH_EXCEPTION(0);
35577   }
35578
35579   jresult = (int)result;
35580   return jresult;
35581 }
35582
35583
35584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
35585   int jresult ;
35586   int result;
35587
35588   {
35589     try {
35590       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
35591     } CALL_CATCH_EXCEPTION(0);
35592   }
35593
35594   jresult = (int)result;
35595   return jresult;
35596 }
35597
35598
35599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
35600   int jresult ;
35601   int result;
35602
35603   {
35604     try {
35605       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
35606     } CALL_CATCH_EXCEPTION(0);
35607   }
35608
35609   jresult = (int)result;
35610   return jresult;
35611 }
35612
35613
35614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
35615   int jresult ;
35616   int result;
35617
35618   {
35619     try {
35620       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
35621     } CALL_CATCH_EXCEPTION(0);
35622   }
35623
35624   jresult = (int)result;
35625   return jresult;
35626 }
35627
35628
35629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
35630   int jresult ;
35631   int result;
35632
35633   {
35634     try {
35635       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
35636     } CALL_CATCH_EXCEPTION(0);
35637   }
35638
35639   jresult = (int)result;
35640   return jresult;
35641 }
35642
35643
35644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
35645   int jresult ;
35646   int result;
35647
35648   {
35649     try {
35650       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
35651     } CALL_CATCH_EXCEPTION(0);
35652   }
35653
35654   jresult = (int)result;
35655   return jresult;
35656 }
35657
35658
35659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
35660   int jresult ;
35661   int result;
35662
35663   {
35664     try {
35665       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
35666     } CALL_CATCH_EXCEPTION(0);
35667   }
35668
35669   jresult = (int)result;
35670   return jresult;
35671 }
35672
35673
35674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
35675   int jresult ;
35676   int result;
35677
35678   {
35679     try {
35680       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
35681     } CALL_CATCH_EXCEPTION(0);
35682   }
35683
35684   jresult = (int)result;
35685   return jresult;
35686 }
35687
35688
35689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
35690   int jresult ;
35691   int result;
35692
35693   {
35694     try {
35695       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
35696     } CALL_CATCH_EXCEPTION(0);
35697   }
35698
35699   jresult = (int)result;
35700   return jresult;
35701 }
35702
35703
35704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
35705   int jresult ;
35706   int result;
35707
35708   {
35709     try {
35710       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
35711     } CALL_CATCH_EXCEPTION(0);
35712   }
35713
35714   jresult = (int)result;
35715   return jresult;
35716 }
35717
35718
35719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
35720   int jresult ;
35721   int result;
35722
35723   {
35724     try {
35725       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
35726     } CALL_CATCH_EXCEPTION(0);
35727   }
35728
35729   jresult = (int)result;
35730   return jresult;
35731 }
35732
35733
35734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
35735   int jresult ;
35736   int result;
35737
35738   {
35739     try {
35740       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
35741     } CALL_CATCH_EXCEPTION(0);
35742   }
35743
35744   jresult = (int)result;
35745   return jresult;
35746 }
35747
35748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
35749   int jresult ;
35750   int result;
35751
35752   {
35753     try {
35754       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
35755     } CALL_CATCH_EXCEPTION(0);
35756   }
35757
35758   jresult = (int)result;
35759   return jresult;
35760 }
35761
35762
35763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
35764   int jresult ;
35765   int result;
35766   {
35767     try
35768     {
35769       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
35770     } CALL_CATCH_EXCEPTION(0);
35771   }
35772
35773   jresult = (int)result;
35774   return jresult;
35775 }
35776
35777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
35778   int jresult ;
35779   int result;
35780   {
35781     try
35782     {
35783       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
35784     } CALL_CATCH_EXCEPTION(0);
35785   }
35786
35787   jresult = (int)result;
35788   return jresult;
35789 }
35790
35791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
35792   int jresult ;
35793   int result;
35794   {
35795     try
35796     {
35797       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
35798     } CALL_CATCH_EXCEPTION(0);
35799   }
35800
35801   jresult = (int)result;
35802   return jresult;
35803 }
35804
35805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
35806   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
35807 }
35808
35809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
35810   int jresult ;
35811   int result;
35812   {
35813     try
35814     {
35815       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
35816     } CALL_CATCH_EXCEPTION(0);
35817   }
35818
35819   jresult = (int)result;
35820   return jresult;
35821 }
35822
35823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
35824   int jresult ;
35825   int result;
35826   {
35827     try
35828     {
35829       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
35830     } CALL_CATCH_EXCEPTION(0);
35831   }
35832
35833   jresult = (int)result;
35834   return jresult;
35835 }
35836
35837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
35838   int jresult ;
35839   int result;
35840
35841   {
35842     try {
35843       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
35844     } CALL_CATCH_EXCEPTION(0);
35845   }
35846
35847   jresult = (int)result;
35848   return jresult;
35849 }
35850
35851
35852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
35853   int jresult ;
35854   int result;
35855
35856   {
35857     try {
35858       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
35859     } CALL_CATCH_EXCEPTION(0);
35860   }
35861
35862   jresult = (int)result;
35863   return jresult;
35864 }
35865
35866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
35867   int jresult ;
35868   int result;
35869   {
35870     try
35871     {
35872       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
35873     } CALL_CATCH_EXCEPTION(0);
35874   }
35875
35876   jresult = (int)result;
35877   return jresult;
35878 }
35879
35880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
35881   int jresult ;
35882   int result;
35883   {
35884     try
35885     {
35886       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
35887     } CALL_CATCH_EXCEPTION(0);
35888   }
35889
35890   jresult = (int)result;
35891   return jresult;
35892 }
35893
35894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
35895   int jresult ;
35896   int result;
35897   {
35898     try
35899     {
35900       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
35901     } CALL_CATCH_EXCEPTION(0);
35902   }
35903
35904   jresult = (int)result;
35905   return jresult;
35906 }
35907
35908
35909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
35910   int jresult ;
35911   int result;
35912   {
35913     try
35914     {
35915       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
35916     } CALL_CATCH_EXCEPTION(0);
35917   }
35918
35919   jresult = (int)result;
35920   return jresult;
35921 }
35922
35923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
35924   int jresult ;
35925   int result;
35926   {
35927     try
35928     {
35929       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
35930     } CALL_CATCH_EXCEPTION(0);
35931   }
35932
35933   jresult = (int)result;
35934   return jresult;
35935 }
35936
35937
35938
35939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
35940   int jresult ;
35941   int result;
35942
35943   {
35944     try {
35945       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
35946     } CALL_CATCH_EXCEPTION(0);
35947   }
35948
35949   jresult = (int)result;
35950   return jresult;
35951 }
35952
35953
35954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
35955   int jresult ;
35956   int result;
35957
35958   {
35959     try {
35960       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
35961     } CALL_CATCH_EXCEPTION(0);
35962   }
35963
35964   jresult = (int)result;
35965   return jresult;
35966 }
35967
35968
35969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
35970   int jresult ;
35971   int result;
35972
35973   {
35974     try {
35975       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
35976     } CALL_CATCH_EXCEPTION(0);
35977   }
35978
35979   jresult = (int)result;
35980   return jresult;
35981 }
35982
35983
35984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
35985   int jresult ;
35986   int result;
35987
35988   {
35989     try {
35990       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
35991     } CALL_CATCH_EXCEPTION(0);
35992   }
35993
35994   jresult = (int)result;
35995   return jresult;
35996 }
35997
35998
35999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
36000   int jresult ;
36001   int result;
36002
36003   {
36004     try {
36005       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
36006     } CALL_CATCH_EXCEPTION(0);
36007   }
36008
36009   jresult = (int)result;
36010   return jresult;
36011 }
36012
36013
36014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
36015   int jresult ;
36016   int result;
36017
36018   {
36019     try {
36020       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
36021     } CALL_CATCH_EXCEPTION(0);
36022   }
36023
36024   jresult = (int)result;
36025   return jresult;
36026 }
36027
36028
36029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
36030   int jresult ;
36031   int result;
36032
36033   {
36034     try {
36035       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
36036     } CALL_CATCH_EXCEPTION(0);
36037   }
36038
36039   jresult = (int)result;
36040   return jresult;
36041 }
36042
36043 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
36044   int jresult ;
36045   int result;
36046
36047   {
36048     try {
36049       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
36050     } CALL_CATCH_EXCEPTION(0);
36051   }
36052
36053   jresult = (int)result;
36054   return jresult;
36055 }
36056
36057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
36058   int jresult ;
36059   int result;
36060
36061   {
36062     try {
36063       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
36064     } CALL_CATCH_EXCEPTION(0);
36065   }
36066
36067   jresult = (int)result;
36068   return jresult;
36069 }
36070
36071
36072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
36073   int jresult ;
36074   int result;
36075
36076   {
36077     try {
36078       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
36079     } CALL_CATCH_EXCEPTION(0);
36080   }
36081
36082   jresult = (int)result;
36083   return jresult;
36084 }
36085
36086
36087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
36088   int jresult ;
36089   int result;
36090
36091   {
36092     try {
36093       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
36094     } CALL_CATCH_EXCEPTION(0);
36095   }
36096
36097   jresult = (int)result;
36098   return jresult;
36099 }
36100
36101
36102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
36103   int jresult ;
36104   int result;
36105
36106   {
36107     try {
36108       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
36109     } CALL_CATCH_EXCEPTION(0);
36110   }
36111
36112   jresult = (int)result;
36113   return jresult;
36114 }
36115
36116
36117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
36118   int jresult ;
36119   int result;
36120
36121   {
36122     try {
36123       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
36124     } CALL_CATCH_EXCEPTION(0);
36125   }
36126
36127   jresult = (int)result;
36128   return jresult;
36129 }
36130
36131
36132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
36133   int jresult ;
36134   int result;
36135
36136   {
36137     try {
36138       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
36139     } CALL_CATCH_EXCEPTION(0);
36140   }
36141
36142   jresult = (int)result;
36143   return jresult;
36144 }
36145
36146
36147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
36148   int jresult ;
36149   int result;
36150
36151   {
36152     try {
36153       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
36154     } CALL_CATCH_EXCEPTION(0);
36155   }
36156
36157   jresult = (int)result;
36158   return jresult;
36159 }
36160
36161
36162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
36163   int jresult ;
36164   int result;
36165
36166   {
36167     try {
36168       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
36169     } CALL_CATCH_EXCEPTION(0);
36170   }
36171
36172   jresult = (int)result;
36173   return jresult;
36174 }
36175
36176
36177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
36178   int jresult ;
36179   int result;
36180
36181   {
36182     try {
36183       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
36184     } CALL_CATCH_EXCEPTION(0);
36185   }
36186
36187   jresult = (int)result;
36188   return jresult;
36189 }
36190
36191
36192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
36193   int jresult ;
36194   int result;
36195
36196   {
36197     try {
36198       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
36199     } CALL_CATCH_EXCEPTION(0);
36200   }
36201
36202   jresult = (int)result;
36203   return jresult;
36204 }
36205
36206
36207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
36208   int jresult ;
36209   int result;
36210
36211   {
36212     try {
36213       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
36214     } CALL_CATCH_EXCEPTION(0);
36215   }
36216
36217   jresult = (int)result;
36218   return jresult;
36219 }
36220
36221
36222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
36223   int jresult ;
36224   int result;
36225
36226   {
36227     try {
36228       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
36229     } CALL_CATCH_EXCEPTION(0);
36230   }
36231
36232   jresult = (int)result;
36233   return jresult;
36234 }
36235
36236
36237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
36238   int jresult ;
36239   int result;
36240
36241   {
36242     try {
36243       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
36244     } CALL_CATCH_EXCEPTION(0);
36245   }
36246
36247   jresult = (int)result;
36248   return jresult;
36249 }
36250
36251
36252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
36253   int jresult ;
36254   int result;
36255
36256   {
36257     try {
36258       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
36259     } CALL_CATCH_EXCEPTION(0);
36260   }
36261
36262   jresult = (int)result;
36263   return jresult;
36264 }
36265
36266
36267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
36268   int jresult ;
36269   int result;
36270
36271   {
36272     try {
36273       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
36274     } CALL_CATCH_EXCEPTION(0);
36275   }
36276
36277   jresult = (int)result;
36278   return jresult;
36279 }
36280
36281
36282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
36283   int jresult ;
36284   int result;
36285
36286   {
36287     try {
36288       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
36289     } CALL_CATCH_EXCEPTION(0);
36290   }
36291
36292   jresult = (int)result;
36293   return jresult;
36294 }
36295
36296
36297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
36298   int jresult ;
36299   int result;
36300
36301   {
36302     try {
36303       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
36304     } CALL_CATCH_EXCEPTION(0);
36305   }
36306
36307   jresult = (int)result;
36308   return jresult;
36309 }
36310
36311
36312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
36313   int jresult ;
36314   int result;
36315
36316   {
36317     try {
36318       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
36319     } CALL_CATCH_EXCEPTION(0);
36320   }
36321
36322   jresult = (int)result;
36323   return jresult;
36324 }
36325
36326
36327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
36328   int jresult ;
36329   int result;
36330
36331   {
36332     try {
36333       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
36334     } CALL_CATCH_EXCEPTION(0);
36335   }
36336
36337   jresult = (int)result;
36338   return jresult;
36339 }
36340
36341
36342 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
36343   int jresult ;
36344   int result;
36345
36346   {
36347     try {
36348       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
36349     } CALL_CATCH_EXCEPTION(0);
36350   }
36351
36352   jresult = (int)result;
36353   return jresult;
36354 }
36355
36356
36357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
36358   int jresult ;
36359   int result;
36360
36361   {
36362     try {
36363       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
36364     } CALL_CATCH_EXCEPTION(0);
36365   }
36366
36367   jresult = (int)result;
36368   return jresult;
36369 }
36370
36371
36372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
36373   int jresult ;
36374   int result;
36375
36376   {
36377     try {
36378       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
36379     } CALL_CATCH_EXCEPTION(0);
36380   }
36381
36382   jresult = (int)result;
36383   return jresult;
36384 }
36385
36386
36387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
36388   int jresult ;
36389   int result;
36390
36391   {
36392     try {
36393       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
36394     } CALL_CATCH_EXCEPTION(0);
36395   }
36396
36397   jresult = (int)result;
36398   return jresult;
36399 }
36400
36401
36402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
36403   int jresult ;
36404   int result;
36405
36406   {
36407     try {
36408       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
36409     } CALL_CATCH_EXCEPTION(0);
36410   }
36411
36412   jresult = (int)result;
36413   return jresult;
36414 }
36415
36416
36417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
36418   int jresult ;
36419   int result;
36420
36421   {
36422     try {
36423       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
36424     } CALL_CATCH_EXCEPTION(0);
36425   }
36426
36427   jresult = (int)result;
36428   return jresult;
36429 }
36430
36431
36432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
36433   int jresult ;
36434   int result;
36435
36436   {
36437     try {
36438       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
36439     } CALL_CATCH_EXCEPTION(0);
36440   }
36441
36442   jresult = (int)result;
36443   return jresult;
36444 }
36445
36446
36447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
36448   int jresult ;
36449   int result;
36450
36451   {
36452     try {
36453       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
36454     } CALL_CATCH_EXCEPTION(0);
36455   }
36456
36457   jresult = (int)result;
36458   return jresult;
36459 }
36460
36461
36462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
36463   int jresult ;
36464   int result;
36465
36466   {
36467     try {
36468       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
36469     } CALL_CATCH_EXCEPTION(0);
36470   }
36471
36472   jresult = (int)result;
36473   return jresult;
36474 }
36475
36476
36477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
36478   void * jresult ;
36479   Dali::Toolkit::Builder *result = 0 ;
36480
36481   {
36482     try {
36483       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
36484     } CALL_CATCH_EXCEPTION(0);
36485   }
36486
36487   jresult = (void *)result;
36488   return jresult;
36489 }
36490
36491
36492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
36493   void * jresult ;
36494   Dali::Toolkit::Builder result;
36495
36496   {
36497     try {
36498       result = Dali::Toolkit::Builder::New();
36499     } CALL_CATCH_EXCEPTION(0);
36500   }
36501
36502   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
36503   return jresult;
36504 }
36505
36506
36507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
36508   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36509
36510   arg1 = (Dali::Toolkit::Builder *)jarg1;
36511   {
36512     try {
36513       delete arg1;
36514     } CALL_CATCH_EXCEPTION();
36515   }
36516
36517 }
36518
36519
36520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
36521   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36522   std::string *arg2 = 0 ;
36523   Dali::Toolkit::Builder::UIFormat arg3 ;
36524
36525   arg1 = (Dali::Toolkit::Builder *)jarg1;
36526   if (!jarg2) {
36527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36528     return ;
36529   }
36530   std::string arg2_str(jarg2);
36531   arg2 = &arg2_str;
36532   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
36533   {
36534     try {
36535       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
36536     } CALL_CATCH_EXCEPTION();
36537   }
36538
36539
36540   //argout typemap for const std::string&
36541
36542 }
36543
36544
36545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
36546   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36547   std::string *arg2 = 0 ;
36548
36549   arg1 = (Dali::Toolkit::Builder *)jarg1;
36550   if (!jarg2) {
36551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36552     return ;
36553   }
36554   std::string arg2_str(jarg2);
36555   arg2 = &arg2_str;
36556   {
36557     try {
36558       (arg1)->LoadFromString((std::string const &)*arg2);
36559     } CALL_CATCH_EXCEPTION();
36560   }
36561
36562
36563   //argout typemap for const std::string&
36564
36565 }
36566
36567
36568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
36569   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36570   Dali::Property::Map *arg2 = 0 ;
36571
36572   arg1 = (Dali::Toolkit::Builder *)jarg1;
36573   arg2 = (Dali::Property::Map *)jarg2;
36574   if (!arg2) {
36575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
36576     return ;
36577   }
36578   {
36579     try {
36580       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
36581     } CALL_CATCH_EXCEPTION();
36582   }
36583
36584 }
36585
36586
36587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
36588   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36589   std::string *arg2 = 0 ;
36590   Dali::Property::Value *arg3 = 0 ;
36591
36592   arg1 = (Dali::Toolkit::Builder *)jarg1;
36593   if (!jarg2) {
36594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36595     return ;
36596   }
36597   std::string arg2_str(jarg2);
36598   arg2 = &arg2_str;
36599   arg3 = (Dali::Property::Value *)jarg3;
36600   if (!arg3) {
36601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
36602     return ;
36603   }
36604   {
36605     try {
36606       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
36607     } CALL_CATCH_EXCEPTION();
36608   }
36609
36610
36611   //argout typemap for const std::string&
36612
36613 }
36614
36615
36616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
36617   void * jresult ;
36618   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36619   Dali::Property::Map *result = 0 ;
36620
36621   arg1 = (Dali::Toolkit::Builder *)jarg1;
36622   {
36623     try {
36624       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
36625     } CALL_CATCH_EXCEPTION(0);
36626   }
36627
36628   jresult = (void *)result;
36629   return jresult;
36630 }
36631
36632
36633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
36634   void * jresult ;
36635   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36636   std::string *arg2 = 0 ;
36637   Dali::Property::Value *result = 0 ;
36638
36639   arg1 = (Dali::Toolkit::Builder *)jarg1;
36640   if (!jarg2) {
36641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36642     return 0;
36643   }
36644   std::string arg2_str(jarg2);
36645   arg2 = &arg2_str;
36646   {
36647     try {
36648       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
36649     } CALL_CATCH_EXCEPTION(0);
36650   }
36651
36652   jresult = (void *)result;
36653
36654   //argout typemap for const std::string&
36655
36656   return jresult;
36657 }
36658
36659
36660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
36661   void * jresult ;
36662   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36663   std::string *arg2 = 0 ;
36664   Dali::Animation result;
36665
36666   arg1 = (Dali::Toolkit::Builder *)jarg1;
36667   if (!jarg2) {
36668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36669     return 0;
36670   }
36671   std::string arg2_str(jarg2);
36672   arg2 = &arg2_str;
36673   {
36674     try {
36675       result = (arg1)->CreateAnimation((std::string const &)*arg2);
36676     } CALL_CATCH_EXCEPTION(0);
36677   }
36678
36679   jresult = new Dali::Animation((const Dali::Animation &)result);
36680
36681   //argout typemap for const std::string&
36682
36683   return jresult;
36684 }
36685
36686
36687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
36688   void * jresult ;
36689   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36690   std::string *arg2 = 0 ;
36691   Dali::Property::Map *arg3 = 0 ;
36692   Dali::Animation result;
36693
36694   arg1 = (Dali::Toolkit::Builder *)jarg1;
36695   if (!jarg2) {
36696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36697     return 0;
36698   }
36699   std::string arg2_str(jarg2);
36700   arg2 = &arg2_str;
36701   arg3 = (Dali::Property::Map *)jarg3;
36702   if (!arg3) {
36703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
36704     return 0;
36705   }
36706   {
36707     try {
36708       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
36709     } CALL_CATCH_EXCEPTION(0);
36710   }
36711
36712   jresult = new Dali::Animation((const Dali::Animation &)result);
36713
36714   //argout typemap for const std::string&
36715
36716   return jresult;
36717 }
36718
36719
36720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
36721   void * jresult ;
36722   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36723   std::string *arg2 = 0 ;
36724   Dali::Actor arg3 ;
36725   Dali::Actor *argp3 ;
36726   Dali::Animation result;
36727
36728   arg1 = (Dali::Toolkit::Builder *)jarg1;
36729   if (!jarg2) {
36730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36731     return 0;
36732   }
36733   std::string arg2_str(jarg2);
36734   arg2 = &arg2_str;
36735   argp3 = (Dali::Actor *)jarg3;
36736   if (!argp3) {
36737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
36738     return 0;
36739   }
36740   arg3 = *argp3;
36741   {
36742     try {
36743       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
36744     } CALL_CATCH_EXCEPTION(0);
36745   }
36746
36747   jresult = new Dali::Animation((const Dali::Animation &)result);
36748
36749   //argout typemap for const std::string&
36750
36751   return jresult;
36752 }
36753
36754
36755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
36756   void * jresult ;
36757   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36758   std::string *arg2 = 0 ;
36759   Dali::Property::Map *arg3 = 0 ;
36760   Dali::Actor arg4 ;
36761   Dali::Actor *argp4 ;
36762   Dali::Animation result;
36763
36764   arg1 = (Dali::Toolkit::Builder *)jarg1;
36765   if (!jarg2) {
36766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36767     return 0;
36768   }
36769   std::string arg2_str(jarg2);
36770   arg2 = &arg2_str;
36771   arg3 = (Dali::Property::Map *)jarg3;
36772   if (!arg3) {
36773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
36774     return 0;
36775   }
36776   argp4 = (Dali::Actor *)jarg4;
36777   if (!argp4) {
36778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
36779     return 0;
36780   }
36781   arg4 = *argp4;
36782   {
36783     try {
36784       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
36785     } CALL_CATCH_EXCEPTION(0);
36786   }
36787
36788   jresult = new Dali::Animation((const Dali::Animation &)result);
36789
36790   //argout typemap for const std::string&
36791
36792   return jresult;
36793 }
36794
36795
36796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
36797   void * jresult ;
36798   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36799   std::string *arg2 = 0 ;
36800   Dali::BaseHandle result;
36801
36802   arg1 = (Dali::Toolkit::Builder *)jarg1;
36803   if (!jarg2) {
36804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36805     return 0;
36806   }
36807   std::string arg2_str(jarg2);
36808   arg2 = &arg2_str;
36809   {
36810     try {
36811       result = (arg1)->Create((std::string const &)*arg2);
36812     } CALL_CATCH_EXCEPTION(0);
36813   }
36814
36815   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
36816
36817   //argout typemap for const std::string&
36818
36819   return jresult;
36820 }
36821
36822
36823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
36824   void * jresult ;
36825   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36826   std::string *arg2 = 0 ;
36827   Dali::Property::Map *arg3 = 0 ;
36828   Dali::BaseHandle result;
36829
36830   arg1 = (Dali::Toolkit::Builder *)jarg1;
36831   if (!jarg2) {
36832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36833     return 0;
36834   }
36835   std::string arg2_str(jarg2);
36836   arg2 = &arg2_str;
36837   arg3 = (Dali::Property::Map *)jarg3;
36838   if (!arg3) {
36839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
36840     return 0;
36841   }
36842   {
36843     try {
36844       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
36845     } CALL_CATCH_EXCEPTION(0);
36846   }
36847
36848   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
36849
36850   //argout typemap for const std::string&
36851
36852   return jresult;
36853 }
36854
36855
36856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
36857   void * jresult ;
36858   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36859   std::string *arg2 = 0 ;
36860   Dali::BaseHandle result;
36861
36862   arg1 = (Dali::Toolkit::Builder *)jarg1;
36863   if (!jarg2) {
36864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36865     return 0;
36866   }
36867   std::string arg2_str(jarg2);
36868   arg2 = &arg2_str;
36869   {
36870     try {
36871       result = (arg1)->CreateFromJson((std::string const &)*arg2);
36872     } CALL_CATCH_EXCEPTION(0);
36873   }
36874
36875   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
36876
36877   //argout typemap for const std::string&
36878
36879   return jresult;
36880 }
36881
36882
36883 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
36884   bool jresult ;
36885   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36886   std::string *arg2 = 0 ;
36887   Dali::Handle *arg3 = 0 ;
36888   bool result;
36889
36890   arg1 = (Dali::Toolkit::Builder *)jarg1;
36891   if (!jarg2) {
36892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36893     return 0;
36894   }
36895   std::string arg2_str(jarg2);
36896   arg2 = &arg2_str;
36897   arg3 = (Dali::Handle *)jarg3;
36898   if (!arg3) {
36899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
36900     return 0;
36901   }
36902   {
36903     try {
36904       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
36905     } CALL_CATCH_EXCEPTION(0);
36906   }
36907
36908   jresult = result;
36909
36910   //argout typemap for const std::string&
36911
36912   return jresult;
36913 }
36914
36915
36916 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
36917   bool jresult ;
36918   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36919   Dali::Handle *arg2 = 0 ;
36920   std::string *arg3 = 0 ;
36921   bool result;
36922
36923   arg1 = (Dali::Toolkit::Builder *)jarg1;
36924   arg2 = (Dali::Handle *)jarg2;
36925   if (!arg2) {
36926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
36927     return 0;
36928   }
36929   if (!jarg3) {
36930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36931     return 0;
36932   }
36933   std::string arg3_str(jarg3);
36934   arg3 = &arg3_str;
36935   {
36936     try {
36937       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
36938     } CALL_CATCH_EXCEPTION(0);
36939   }
36940
36941   jresult = result;
36942
36943   //argout typemap for const std::string&
36944
36945   return jresult;
36946 }
36947
36948
36949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
36950   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36951   Dali::Actor arg2 ;
36952   Dali::Actor *argp2 ;
36953
36954   arg1 = (Dali::Toolkit::Builder *)jarg1;
36955   argp2 = (Dali::Actor *)jarg2;
36956   if (!argp2) {
36957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
36958     return ;
36959   }
36960   arg2 = *argp2;
36961   {
36962     try {
36963       (arg1)->AddActors(arg2);
36964     } CALL_CATCH_EXCEPTION();
36965   }
36966
36967 }
36968
36969
36970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
36971   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36972   std::string *arg2 = 0 ;
36973   Dali::Actor arg3 ;
36974   Dali::Actor *argp3 ;
36975
36976   arg1 = (Dali::Toolkit::Builder *)jarg1;
36977   if (!jarg2) {
36978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36979     return ;
36980   }
36981   std::string arg2_str(jarg2);
36982   arg2 = &arg2_str;
36983   argp3 = (Dali::Actor *)jarg3;
36984   if (!argp3) {
36985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
36986     return ;
36987   }
36988   arg3 = *argp3;
36989   {
36990     try {
36991       (arg1)->AddActors((std::string const &)*arg2,arg3);
36992     } CALL_CATCH_EXCEPTION();
36993   }
36994
36995
36996   //argout typemap for const std::string&
36997
36998 }
36999
37000
37001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
37002   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37003   std::string *arg2 = 0 ;
37004
37005   arg1 = (Dali::Toolkit::Builder *)jarg1;
37006   if (!jarg2) {
37007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37008     return ;
37009   }
37010   std::string arg2_str(jarg2);
37011   arg2 = &arg2_str;
37012   {
37013     try {
37014       (arg1)->CreateRenderTask((std::string const &)*arg2);
37015     } CALL_CATCH_EXCEPTION();
37016   }
37017
37018
37019   //argout typemap for const std::string&
37020
37021 }
37022
37023
37024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
37025   void * jresult ;
37026   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37027   std::string *arg2 = 0 ;
37028   Dali::Path result;
37029
37030   arg1 = (Dali::Toolkit::Builder *)jarg1;
37031   if (!jarg2) {
37032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37033     return 0;
37034   }
37035   std::string arg2_str(jarg2);
37036   arg2 = &arg2_str;
37037   {
37038     try {
37039       result = (arg1)->GetPath((std::string const &)*arg2);
37040     } CALL_CATCH_EXCEPTION(0);
37041   }
37042
37043   jresult = new Dali::Path((const Dali::Path &)result);
37044
37045   //argout typemap for const std::string&
37046
37047   return jresult;
37048 }
37049
37050
37051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
37052   void * jresult ;
37053   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37054   std::string *arg2 = 0 ;
37055   Dali::PathConstrainer result;
37056
37057   arg1 = (Dali::Toolkit::Builder *)jarg1;
37058   if (!jarg2) {
37059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37060     return 0;
37061   }
37062   std::string arg2_str(jarg2);
37063   arg2 = &arg2_str;
37064   {
37065     try {
37066       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
37067     } CALL_CATCH_EXCEPTION(0);
37068   }
37069
37070   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
37071
37072   //argout typemap for const std::string&
37073
37074   return jresult;
37075 }
37076
37077
37078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
37079   void * jresult ;
37080   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37081   std::string *arg2 = 0 ;
37082   Dali::LinearConstrainer result;
37083
37084   arg1 = (Dali::Toolkit::Builder *)jarg1;
37085   if (!jarg2) {
37086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37087     return 0;
37088   }
37089   std::string arg2_str(jarg2);
37090   arg2 = &arg2_str;
37091   {
37092     try {
37093       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
37094     } CALL_CATCH_EXCEPTION(0);
37095   }
37096
37097   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
37098
37099   //argout typemap for const std::string&
37100
37101   return jresult;
37102 }
37103
37104
37105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
37106   void * jresult ;
37107   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37108   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
37109
37110   arg1 = (Dali::Toolkit::Builder *)jarg1;
37111   {
37112     try {
37113       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
37114     } CALL_CATCH_EXCEPTION(0);
37115   }
37116
37117   jresult = (void *)result;
37118   return jresult;
37119 }
37120
37121
37122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
37123   void * jresult ;
37124   Dali::Toolkit::TransitionData *result = 0 ;
37125
37126   {
37127     try {
37128       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
37129     } CALL_CATCH_EXCEPTION(0);
37130   }
37131
37132   jresult = (void *)result;
37133   return jresult;
37134 }
37135
37136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
37137   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
37138
37139   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
37140   {
37141     try {
37142       delete arg1;
37143     } CALL_CATCH_EXCEPTION();
37144   }
37145
37146 }
37147
37148
37149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
37150   void * jresult ;
37151   Dali::Property::Map *arg1 = 0 ;
37152   Dali::Toolkit::TransitionData result;
37153
37154   arg1 = (Dali::Property::Map *)jarg1;
37155   if (!arg1) {
37156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
37157     return 0;
37158   }
37159   {
37160     try {
37161       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
37162     } CALL_CATCH_EXCEPTION(0);
37163   }
37164
37165   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
37166   return jresult;
37167 }
37168
37169
37170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
37171   void * jresult ;
37172   Dali::Property::Array *arg1 = 0 ;
37173   Dali::Toolkit::TransitionData result;
37174
37175   arg1 = (Dali::Property::Array *)jarg1;
37176   if (!arg1) {
37177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
37178     return 0;
37179   }
37180   {
37181     try {
37182       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
37183     } CALL_CATCH_EXCEPTION(0);
37184   }
37185
37186   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
37187   return jresult;
37188 }
37189
37190
37191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
37192   void * jresult ;
37193   Dali::BaseHandle arg1 ;
37194   Dali::BaseHandle *argp1 ;
37195   Dali::Toolkit::TransitionData result;
37196
37197   argp1 = (Dali::BaseHandle *)jarg1;
37198   if (!argp1) {
37199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37200     return 0;
37201   }
37202   arg1 = *argp1;
37203   {
37204     try {
37205       result = Dali::Toolkit::TransitionData::DownCast(arg1);
37206     } CALL_CATCH_EXCEPTION(0);
37207   }
37208
37209   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
37210   return jresult;
37211 }
37212
37213
37214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
37215   void * jresult ;
37216   Dali::Toolkit::TransitionData *arg1 = 0 ;
37217   Dali::Toolkit::TransitionData *result = 0 ;
37218
37219   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
37220   if (!arg1) {
37221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
37222     return 0;
37223   }
37224   {
37225     try {
37226       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
37227     } CALL_CATCH_EXCEPTION(0);
37228   }
37229
37230   jresult = (void *)result;
37231   return jresult;
37232 }
37233
37234
37235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
37236   void * jresult ;
37237   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
37238   Dali::Toolkit::TransitionData *arg2 = 0 ;
37239   Dali::Toolkit::TransitionData *result = 0 ;
37240
37241   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
37242   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
37243   if (!arg2) {
37244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
37245     return 0;
37246   }
37247   {
37248     try {
37249       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
37250     } CALL_CATCH_EXCEPTION(0);
37251   }
37252
37253   jresult = (void *)result;
37254   return jresult;
37255 }
37256
37257
37258 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
37259   unsigned long jresult ;
37260   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
37261   size_t result;
37262
37263   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
37264   {
37265     try {
37266       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
37267     } CALL_CATCH_EXCEPTION(0);
37268   }
37269
37270   jresult = (unsigned long)result;
37271   return jresult;
37272 }
37273
37274
37275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
37276   void * jresult ;
37277   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
37278   size_t arg2 ;
37279   Dali::Property::Map result;
37280
37281   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
37282   arg2 = (size_t)jarg2;
37283   {
37284     try {
37285       result = (arg1)->GetAnimatorAt(arg2);
37286     } CALL_CATCH_EXCEPTION(0);
37287   }
37288
37289   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
37290   return jresult;
37291 }
37292
37293
37294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
37295   int jresult ;
37296   int result;
37297
37298   {
37299     try {
37300       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
37301     } CALL_CATCH_EXCEPTION(0);
37302   }
37303
37304   jresult = (int)result;
37305   return jresult;
37306 }
37307
37308
37309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
37310   int jresult ;
37311   int result;
37312
37313   {
37314     try {
37315       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
37316     } CALL_CATCH_EXCEPTION(0);
37317   }
37318
37319   jresult = (int)result;
37320   return jresult;
37321 }
37322
37323
37324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
37325   int jresult ;
37326   int result;
37327
37328   {
37329     try {
37330       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
37331     } CALL_CATCH_EXCEPTION(0);
37332   }
37333
37334   jresult = (int)result;
37335   return jresult;
37336 }
37337
37338
37339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
37340   int jresult ;
37341   int result;
37342
37343   {
37344     try {
37345       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
37346     } CALL_CATCH_EXCEPTION(0);
37347   }
37348
37349   jresult = (int)result;
37350   return jresult;
37351 }
37352
37353
37354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
37355   int jresult ;
37356   int result;
37357
37358   {
37359     try {
37360       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
37361     } CALL_CATCH_EXCEPTION(0);
37362   }
37363
37364   jresult = (int)result;
37365   return jresult;
37366 }
37367
37368
37369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
37370   int jresult ;
37371   int result;
37372
37373   {
37374     try {
37375       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
37376     } CALL_CATCH_EXCEPTION(0);
37377   }
37378
37379   jresult = (int)result;
37380   return jresult;
37381 }
37382
37383
37384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
37385   int jresult ;
37386   int result;
37387
37388   {
37389     try {
37390       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
37391     } CALL_CATCH_EXCEPTION(0);
37392   }
37393
37394   jresult = (int)result;
37395   return jresult;
37396 }
37397
37398
37399 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
37400   int jresult ;
37401   int result;
37402
37403   {
37404     try {
37405       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
37406     } CALL_CATCH_EXCEPTION(0);
37407   }
37408
37409   jresult = (int)result;
37410   return jresult;
37411 }
37412
37413
37414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
37415   int jresult ;
37416   int result;
37417
37418   {
37419     try {
37420       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
37421     } CALL_CATCH_EXCEPTION(0);
37422   }
37423
37424   jresult = (int)result;
37425   return jresult;
37426 }
37427
37428
37429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
37430   int jresult ;
37431   int result;
37432
37433   {
37434     try {
37435       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
37436     } CALL_CATCH_EXCEPTION(0);
37437   }
37438
37439   jresult = (int)result;
37440   return jresult;
37441 }
37442
37443
37444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
37445   int jresult ;
37446   int result;
37447
37448   {
37449     try {
37450       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
37451     } CALL_CATCH_EXCEPTION(0);
37452   }
37453
37454   jresult = (int)result;
37455   return jresult;
37456 }
37457
37458
37459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
37460   int jresult ;
37461   int result;
37462
37463   {
37464     try {
37465       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
37466     } CALL_CATCH_EXCEPTION(0);
37467   }
37468
37469   jresult = (int)result;
37470   return jresult;
37471 }
37472
37473
37474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
37475   int jresult ;
37476   int result;
37477
37478   {
37479     try {
37480       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
37481     } CALL_CATCH_EXCEPTION(0);
37482   }
37483
37484   jresult = (int)result;
37485   return jresult;
37486 }
37487
37488
37489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
37490   int jresult ;
37491   int result;
37492
37493   {
37494     try {
37495       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
37496     } CALL_CATCH_EXCEPTION(0);
37497   }
37498
37499   jresult = (int)result;
37500   return jresult;
37501 }
37502
37503
37504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
37505   void * jresult ;
37506   Dali::Toolkit::Control result;
37507
37508   {
37509     try {
37510       result = Dali::Toolkit::Internal::Control::New(Dali::Toolkit::Internal::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
37511     } CALL_CATCH_EXCEPTION(0);
37512   }
37513
37514   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
37515   return jresult;
37516 }
37517
37518
37519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
37520   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37521   std::string *arg2 = 0 ;
37522
37523   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37524   if (!jarg2) {
37525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37526     return ;
37527   }
37528   std::string arg2_str(jarg2);
37529   arg2 = &arg2_str;
37530   {
37531     try {
37532       (arg1)->SetStyleName((std::string const &)*arg2);
37533     } CALL_CATCH_EXCEPTION();
37534   }
37535
37536
37537   //argout typemap for const std::string&
37538
37539 }
37540
37541
37542 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
37543   char * jresult ;
37544   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37545   std::string *result = 0 ;
37546
37547   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37548   {
37549     try {
37550       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
37551     } CALL_CATCH_EXCEPTION(0);
37552   }
37553
37554   jresult = SWIG_csharp_string_callback(result->c_str());
37555   return jresult;
37556 }
37557
37558
37559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
37560   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37561   Dali::Vector4 *arg2 = 0 ;
37562
37563   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37564   arg2 = (Dali::Vector4 *)jarg2;
37565   if (!arg2) {
37566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
37567     return ;
37568   }
37569   {
37570     try {
37571       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
37572     } CALL_CATCH_EXCEPTION();
37573   }
37574
37575 }
37576
37577
37578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
37579   void * jresult ;
37580   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
37581   Dali::Vector4 result;
37582
37583   arg1 = (Dali::Handle *)jarg1;
37584   {
37585     try {
37586       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
37587       if (resultMap)
37588       {
37589         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
37590         if(type && type->Get<int>() == Visual::COLOR )
37591         {
37592           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
37593           if (value)
37594           {
37595             result = value->Get<Vector4>();
37596           }
37597         }
37598       }
37599     } CALL_CATCH_EXCEPTION(0);
37600   }
37601
37602   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
37603   return jresult;
37604 }
37605
37606
37607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
37608   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37609   Dali::Property::Map *arg2 = 0 ;
37610
37611   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37612   arg2 = (Dali::Property::Map *)jarg2;
37613   if (!arg2) {
37614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
37615     return ;
37616   }
37617   {
37618     try {
37619       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
37620     } CALL_CATCH_EXCEPTION();
37621   }
37622
37623 }
37624
37625
37626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
37627   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37628
37629   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37630   {
37631     try {
37632       (arg1)->ClearBackground();
37633     } CALL_CATCH_EXCEPTION();
37634   }
37635
37636 }
37637
37638
37639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
37640   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37641   Dali::GestureType::Value arg2 ;
37642
37643   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37644   arg2 = (Dali::GestureType::Value)jarg2;
37645   {
37646     try {
37647       (arg1)->EnableGestureDetection(arg2);
37648     } CALL_CATCH_EXCEPTION();
37649   }
37650
37651 }
37652
37653
37654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
37655   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37656   Dali::GestureType::Value arg2 ;
37657
37658   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37659   arg2 = (Dali::GestureType::Value)jarg2;
37660   {
37661     try {
37662       (arg1)->DisableGestureDetection(arg2);
37663     } CALL_CATCH_EXCEPTION();
37664   }
37665
37666 }
37667
37668
37669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
37670   void * jresult ;
37671   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37672   Dali::PinchGestureDetector result;
37673
37674   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37675   {
37676     try {
37677       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
37678     } CALL_CATCH_EXCEPTION(0);
37679   }
37680
37681   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
37682   return jresult;
37683 }
37684
37685
37686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
37687   void * jresult ;
37688   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37689   Dali::PanGestureDetector result;
37690
37691   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37692   {
37693     try {
37694       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
37695     } CALL_CATCH_EXCEPTION(0);
37696   }
37697
37698   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
37699   return jresult;
37700 }
37701
37702
37703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
37704   void * jresult ;
37705   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37706   Dali::TapGestureDetector result;
37707
37708   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37709   {
37710     try {
37711       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
37712     } CALL_CATCH_EXCEPTION(0);
37713   }
37714
37715   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
37716   return jresult;
37717 }
37718
37719
37720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
37721   void * jresult ;
37722   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37723   Dali::LongPressGestureDetector result;
37724
37725   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37726   {
37727     try {
37728       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
37729     } CALL_CATCH_EXCEPTION(0);
37730   }
37731
37732   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
37733   return jresult;
37734 }
37735
37736
37737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, bool jarg2) {
37738   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37739   bool arg2 ;
37740
37741   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37742   arg2 = jarg2 ? true : false;
37743   {
37744     try {
37745       (arg1)->SetKeyboardNavigationSupport(arg2);
37746     } CALL_CATCH_EXCEPTION();
37747   }
37748
37749 }
37750
37751
37752 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
37753   bool jresult ;
37754   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37755   bool result;
37756
37757   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37758   {
37759     try {
37760       result = (bool)(arg1)->IsKeyboardNavigationSupported();
37761     } CALL_CATCH_EXCEPTION(0);
37762   }
37763
37764   jresult = result;
37765   return jresult;
37766 }
37767
37768
37769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
37770   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37771
37772   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37773   {
37774     try {
37775       (arg1)->SetKeyInputFocus();
37776     } CALL_CATCH_EXCEPTION();
37777   }
37778
37779 }
37780
37781
37782 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
37783   bool jresult ;
37784   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37785   bool result;
37786
37787   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37788   {
37789     try {
37790       result = (bool)(arg1)->HasKeyInputFocus();
37791     } CALL_CATCH_EXCEPTION(0);
37792   }
37793
37794   jresult = result;
37795   return jresult;
37796 }
37797
37798
37799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
37800   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37801
37802   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37803   {
37804     try {
37805       (arg1)->ClearKeyInputFocus();
37806     } CALL_CATCH_EXCEPTION();
37807   }
37808
37809 }
37810
37811
37812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, bool jarg2) {
37813   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37814   bool arg2 ;
37815
37816   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37817   arg2 = jarg2 ? true : false;
37818   {
37819     try {
37820       (arg1)->SetAsKeyboardFocusGroup(arg2);
37821     } CALL_CATCH_EXCEPTION();
37822   }
37823
37824 }
37825
37826
37827 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
37828   bool jresult ;
37829   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37830   bool result;
37831
37832   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37833   {
37834     try {
37835       result = (bool)(arg1)->IsKeyboardFocusGroup();
37836     } CALL_CATCH_EXCEPTION(0);
37837   }
37838
37839   jresult = result;
37840   return jresult;
37841 }
37842
37843
37844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
37845   void * jresult ;
37846   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37847   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
37848
37849   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37850   {
37851     try {
37852       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
37853     } CALL_CATCH_EXCEPTION(0);
37854   }
37855
37856   jresult = (void *)result;
37857   return jresult;
37858 }
37859
37860
37861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
37862   void * jresult ;
37863   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37864   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
37865
37866   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37867   {
37868     try {
37869       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
37870     } CALL_CATCH_EXCEPTION(0);
37871   }
37872
37873   jresult = (void *)result;
37874   return jresult;
37875 }
37876
37877
37878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
37879   void * jresult ;
37880   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37881   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
37882
37883   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37884   {
37885     try {
37886       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
37887     } CALL_CATCH_EXCEPTION(0);
37888   }
37889
37890   jresult = (void *)result;
37891   return jresult;
37892 }
37893
37894
37895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnection(void * jarg1, int jarg2) {
37896   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37897   int arg2 ;
37898   SwigDirector_ViewImpl *darg = 0;
37899
37900   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37901   arg2 = (int)jarg2;
37902   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37903   if(!darg) {
37904     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37905     return;
37906   }
37907   {
37908     try {
37909       if(darg) {
37910         (darg)->OnSceneConnection(arg2);
37911       }
37912     } CALL_CATCH_EXCEPTION();
37913   }
37914
37915 }
37916
37917
37918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
37919   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37920   int arg2 ;
37921   SwigDirector_ViewImpl *darg = 0;
37922
37923   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37924   arg2 = (int)jarg2;
37925   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37926   if(!darg) {
37927     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37928     return;
37929   }
37930   {
37931     try {
37932       if(darg) {
37933         (darg)->OnSceneConnectionSwigPublic(arg2);
37934       }
37935     } CALL_CATCH_EXCEPTION();
37936   }
37937
37938 }
37939
37940
37941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnection(void * jarg1) {
37942   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37943   SwigDirector_ViewImpl *darg = 0;
37944
37945   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37946   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37947   if(!darg) {
37948     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37949     return;
37950   }
37951   {
37952     try {
37953       if(darg) {
37954         (darg)->OnSceneDisconnection();
37955       }
37956     } CALL_CATCH_EXCEPTION();
37957   }
37958
37959 }
37960
37961
37962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnectionSwigExplicitViewImpl(void * jarg1) {
37963   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37964   SwigDirector_ViewImpl *darg = 0;
37965
37966   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37967   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37968   if(!darg) {
37969     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37970     return;
37971   }
37972   {
37973     try {
37974       if(darg) {
37975         (darg)->OnSceneDisconnectionSwigPublic();
37976       }
37977     } CALL_CATCH_EXCEPTION();
37978   }
37979
37980 }
37981
37982
37983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
37984   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37985   Dali::Actor *arg2 = 0 ;
37986   SwigDirector_ViewImpl *darg = 0;
37987
37988   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37989   arg2 = (Dali::Actor *)jarg2;
37990   if (!arg2) {
37991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37992     return ;
37993   }
37994   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37995   if(!darg) {
37996     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37997     return;
37998   }
37999   {
38000     try {
38001       if(darg) {
38002         (darg)->OnChildAdd(*arg2);
38003       }
38004     } CALL_CATCH_EXCEPTION();
38005   }
38006
38007 }
38008
38009
38010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
38011   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38012   Dali::Actor *arg2 = 0 ;
38013   SwigDirector_ViewImpl *darg = 0;
38014
38015   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38016   arg2 = (Dali::Actor *)jarg2;
38017   if (!arg2) {
38018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38019     return ;
38020   }
38021   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38022   if(!darg) {
38023     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38024     return;
38025   }
38026   {
38027     try {
38028       if(darg) {
38029           (darg)->OnChildAddSwigPublic(*arg2);
38030       }
38031     } CALL_CATCH_EXCEPTION();
38032   }
38033
38034 }
38035
38036
38037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
38038   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38039   Dali::Actor *arg2 = 0 ;
38040   SwigDirector_ViewImpl *darg = 0;
38041
38042   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38043   arg2 = (Dali::Actor *)jarg2;
38044   if (!arg2) {
38045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38046     return ;
38047   }
38048   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38049   if(!darg) {
38050     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38051     return;
38052   }
38053   {
38054     try {
38055       if(darg) {
38056         (darg)->OnChildRemove(*arg2);
38057       }
38058     } CALL_CATCH_EXCEPTION();
38059   }
38060
38061 }
38062
38063
38064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
38065   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38066   Dali::Actor *arg2 = 0 ;
38067   SwigDirector_ViewImpl *darg = 0;
38068
38069   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38070   arg2 = (Dali::Actor *)jarg2;
38071   if (!arg2) {
38072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38073     return ;
38074   }
38075   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38076   if(!darg) {
38077     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38078     return;
38079   }
38080   {
38081     try {
38082       if(darg) {
38083         (darg)->OnChildRemoveSwigPublic(*arg2);
38084       }
38085     } CALL_CATCH_EXCEPTION();
38086   }
38087
38088 }
38089
38090
38091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
38092   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38093   Dali::Property::Index arg2 ;
38094   Dali::Property::Value arg3 ;
38095   Dali::Property::Value *argp3 ;
38096   SwigDirector_ViewImpl *darg = 0;
38097
38098   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38099   arg2 = (Dali::Property::Index)jarg2;
38100   argp3 = (Dali::Property::Value *)jarg3;
38101   if (!argp3) {
38102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
38103     return ;
38104   }
38105   arg3 = *argp3;
38106   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38107   if (!darg) {
38108     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38109     return;
38110   }
38111   {
38112     try {
38113       (darg)->OnPropertySet(arg2,arg3);
38114     } CALL_CATCH_EXCEPTION();
38115   }
38116
38117 }
38118
38119
38120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
38121   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38122   Dali::Vector3 *arg2 = 0 ;
38123   SwigDirector_ViewImpl *darg = 0;
38124
38125   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38126   arg2 = (Dali::Vector3 *)jarg2;
38127   if (!arg2) {
38128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38129     return ;
38130   }
38131   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38132   if (!darg) {
38133     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38134     return;
38135   }
38136   {
38137     try {
38138       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
38139     } CALL_CATCH_EXCEPTION();
38140   }
38141
38142 }
38143
38144
38145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
38146   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38147   Dali::Vector3 *arg2 = 0 ;
38148   SwigDirector_ViewImpl *darg = 0;
38149
38150   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38151   arg2 = (Dali::Vector3 *)jarg2;
38152   if (!arg2) {
38153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38154     return ;
38155   }
38156   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38157   if (!darg) {
38158     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38159     return;
38160   }
38161   {
38162     try {
38163       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
38164     } CALL_CATCH_EXCEPTION();
38165   }
38166
38167 }
38168
38169
38170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
38171   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38172   Dali::Animation *arg2 = 0 ;
38173   Dali::Vector3 *arg3 = 0 ;
38174   SwigDirector_ViewImpl *darg = 0;
38175
38176   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38177   arg2 = (Dali::Animation *)jarg2;
38178   if (!arg2) {
38179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
38180     return ;
38181   }
38182   arg3 = (Dali::Vector3 *)jarg3;
38183   if (!arg3) {
38184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38185     return ;
38186   }
38187   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38188   if (!darg) {
38189     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38190     return;
38191   }
38192   {
38193     try {
38194       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
38195     } CALL_CATCH_EXCEPTION();
38196   }
38197
38198 }
38199
38200
38201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
38202   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38203   Dali::Animation *arg2 = 0 ;
38204   Dali::Vector3 *arg3 = 0 ;
38205   SwigDirector_ViewImpl *darg = 0;
38206
38207   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38208   arg2 = (Dali::Animation *)jarg2;
38209   if (!arg2) {
38210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
38211     return ;
38212   }
38213   arg3 = (Dali::Vector3 *)jarg3;
38214   if (!arg3) {
38215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38216     return ;
38217   }
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;
38222   }
38223   {
38224     try {
38225       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
38226     } CALL_CATCH_EXCEPTION();
38227   }
38228 }
38229
38230 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
38231   bool jresult ;
38232   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38233   Dali::KeyEvent *arg2 = 0 ;
38234   SwigDirector_ViewImpl *darg = 0;
38235   bool result;
38236
38237   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38238   arg2 = (Dali::KeyEvent *)jarg2;
38239   if (!arg2) {
38240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
38241     return 0;
38242   }
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)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
38251     } CALL_CATCH_EXCEPTION(0);
38252   }
38253
38254   jresult = result;
38255   return jresult;
38256 }
38257
38258
38259 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
38260   bool jresult ;
38261   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38262   Dali::KeyEvent *arg2 = 0 ;
38263   SwigDirector_ViewImpl *darg = 0;
38264   bool result;
38265
38266   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38267   arg2 = (Dali::KeyEvent *)jarg2;
38268   if (!arg2) {
38269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
38270     return 0;
38271   }
38272   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38273   if (!darg) {
38274     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38275     return 0;
38276   }
38277   {
38278     try {
38279       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
38280     } CALL_CATCH_EXCEPTION(0);
38281   }
38282
38283   jresult = result;
38284   return jresult;
38285 }
38286
38287
38288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
38289   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38290   Dali::Vector2 *arg2 = 0 ;
38291   Dali::RelayoutContainer *arg3 = 0 ;
38292   SwigDirector_ViewImpl *darg = 0;
38293
38294   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38295   arg2 = (Dali::Vector2 *)jarg2;
38296   if (!arg2) {
38297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38298     return ;
38299   }
38300   arg3 = (Dali::RelayoutContainer *)jarg3;
38301   if (!arg3) {
38302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
38303     return ;
38304   }
38305   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38306   if (!darg) {
38307     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38308     return;
38309   }
38310   {
38311     try {
38312       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
38313     } CALL_CATCH_EXCEPTION();
38314   }
38315
38316 }
38317
38318
38319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
38320   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38321   Dali::Vector2 *arg2 = 0 ;
38322   Dali::RelayoutContainer *arg3 = 0 ;
38323   SwigDirector_ViewImpl *darg = 0;
38324
38325   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38326   arg2 = (Dali::Vector2 *)jarg2;
38327   if (!arg2) {
38328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38329     return ;
38330   }
38331   arg3 = (Dali::RelayoutContainer *)jarg3;
38332   if (!arg3) {
38333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
38334     return ;
38335   }
38336   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38337   if (!darg) {
38338     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38339     return;
38340   }
38341   {
38342     try {
38343       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
38344     } CALL_CATCH_EXCEPTION();
38345   }
38346
38347 }
38348
38349
38350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
38351   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38352   Dali::ResizePolicy::Type arg2 ;
38353   Dali::Dimension::Type arg3 ;
38354   SwigDirector_ViewImpl *darg = 0;
38355
38356   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38357   arg2 = (Dali::ResizePolicy::Type)jarg2;
38358   arg3 = (Dali::Dimension::Type)jarg3;
38359   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38360   if (!darg) {
38361     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38362     return;
38363   }
38364   {
38365     try {
38366       (darg)->OnSetResizePolicy(arg2,arg3);
38367     } CALL_CATCH_EXCEPTION();
38368   }
38369
38370 }
38371
38372
38373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
38374   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38375   Dali::ResizePolicy::Type arg2 ;
38376   Dali::Dimension::Type arg3 ;
38377   SwigDirector_ViewImpl *darg = 0;
38378
38379   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38380   arg2 = (Dali::ResizePolicy::Type)jarg2;
38381   arg3 = (Dali::Dimension::Type)jarg3;
38382   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38383   if (!darg) {
38384     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38385     return;
38386   }
38387   {
38388     try {
38389       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
38390     } CALL_CATCH_EXCEPTION();
38391   }
38392
38393 }
38394
38395
38396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
38397   void * jresult ;
38398   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38399   SwigDirector_ViewImpl *darg = 0;
38400   Dali::Vector3 result;
38401
38402   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38403   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38404   if (!darg) {
38405     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38406     return 0;
38407   }
38408   {
38409     try {
38410       result = (darg)->GetNaturalSize();
38411     } CALL_CATCH_EXCEPTION(0);
38412   }
38413
38414   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
38415   return jresult;
38416 }
38417
38418
38419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
38420   void * jresult ;
38421   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38422   SwigDirector_ViewImpl *darg = 0;
38423   Dali::Vector3 result;
38424
38425   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38426   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38427   if (!darg) {
38428     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38429     return 0;
38430   }
38431   {
38432     try {
38433       result = (darg)->GetNaturalSizeSwigPublic();
38434     } CALL_CATCH_EXCEPTION(0);
38435   }
38436
38437   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
38438   return jresult;
38439 }
38440
38441
38442 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
38443   float jresult ;
38444   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38445   Dali::Actor *arg2 = 0 ;
38446   Dali::Dimension::Type arg3 ;
38447   SwigDirector_ViewImpl *darg = 0;
38448   float result;
38449
38450   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38451   arg2 = (Dali::Actor *)jarg2;
38452   if (!arg2) {
38453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
38454     return 0;
38455   }
38456   arg3 = (Dali::Dimension::Type)jarg3;
38457   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38458   if (!darg) {
38459     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38460     return 0;
38461   }
38462   {
38463     try {
38464       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
38465     } CALL_CATCH_EXCEPTION(0);
38466   }
38467
38468   jresult = result;
38469   return jresult;
38470 }
38471
38472
38473 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
38474   float jresult ;
38475   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38476   Dali::Actor *arg2 = 0 ;
38477   Dali::Dimension::Type arg3 ;
38478   SwigDirector_ViewImpl *darg = 0;
38479   float result;
38480
38481   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38482   arg2 = (Dali::Actor *)jarg2;
38483   if (!arg2) {
38484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
38485     return 0;
38486   }
38487   arg3 = (Dali::Dimension::Type)jarg3;
38488   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38489   if (!darg) {
38490     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38491     return 0;
38492   }
38493   {
38494     try {
38495       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
38496     } CALL_CATCH_EXCEPTION(0);
38497   }
38498
38499   jresult = result;
38500   return jresult;
38501 }
38502
38503
38504 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
38505   float jresult ;
38506   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38507   float arg2 ;
38508   SwigDirector_ViewImpl *darg = 0;
38509   float result;
38510
38511   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38512   arg2 = (float)jarg2;
38513   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38514   if (!darg) {
38515     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38516     return 0;
38517   }
38518   {
38519     try {
38520       result = (float)(darg)->GetHeightForWidth(arg2);
38521     } CALL_CATCH_EXCEPTION(0);
38522   }
38523
38524   jresult = result;
38525   return jresult;
38526 }
38527
38528
38529 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
38530   float jresult ;
38531   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38532   float arg2 ;
38533   SwigDirector_ViewImpl *darg = 0;
38534   float result;
38535
38536   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38537   arg2 = (float)jarg2;
38538   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38539   if (!darg) {
38540     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38541     return 0;
38542   }
38543   {
38544     try {
38545       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
38546     } CALL_CATCH_EXCEPTION(0);
38547   }
38548
38549   jresult = result;
38550   return jresult;
38551 }
38552
38553
38554 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
38555   float jresult ;
38556   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38557   float arg2 ;
38558   SwigDirector_ViewImpl *darg = 0;
38559   float result;
38560
38561   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38562   arg2 = (float)jarg2;
38563   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38564   if (!darg) {
38565     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38566     return 0;
38567   }
38568   {
38569     try {
38570       result = (float)(darg)->GetWidthForHeight(arg2);
38571     } CALL_CATCH_EXCEPTION(0);
38572   }
38573
38574   jresult = result;
38575   return jresult;
38576 }
38577
38578
38579 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
38580   float jresult ;
38581   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38582   float arg2 ;
38583   SwigDirector_ViewImpl *darg = 0;
38584   float result;
38585
38586   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38587   arg2 = (float)jarg2;
38588   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38589   if (!darg) {
38590     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38591     return 0;
38592   }
38593   {
38594     try {
38595       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
38596     } CALL_CATCH_EXCEPTION(0);
38597   }
38598
38599   jresult = result;
38600   return jresult;
38601 }
38602
38603
38604 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
38605   bool jresult ;
38606   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38607   Dali::Dimension::Type arg2 ;
38608   SwigDirector_ViewImpl *darg = 0;
38609   bool result;
38610
38611   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38612   arg2 = (Dali::Dimension::Type)jarg2;
38613   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38614   if (!darg) {
38615     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38616     return 0;
38617   }
38618   {
38619     try {
38620       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
38621     } CALL_CATCH_EXCEPTION(0);
38622   }
38623
38624   jresult = result;
38625   return jresult;
38626 }
38627
38628
38629 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
38630   bool jresult ;
38631   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38632   Dali::Dimension::Type arg2 ;
38633   SwigDirector_ViewImpl *darg = 0;
38634   bool result;
38635
38636   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38637   arg2 = (Dali::Dimension::Type)jarg2;
38638   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38639   if (!darg) {
38640     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38641     return 0;
38642   }
38643   {
38644     try {
38645       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
38646     } CALL_CATCH_EXCEPTION(0);
38647   }
38648
38649   jresult = result;
38650   return jresult;
38651 }
38652
38653
38654 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
38655   bool jresult ;
38656   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38657   SwigDirector_ViewImpl *darg = 0;
38658   bool result;
38659
38660   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38661   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38662   if (!darg) {
38663     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38664     return 0;
38665   }
38666   {
38667     try {
38668       result = (bool)(darg)->RelayoutDependentOnChildren();
38669     } CALL_CATCH_EXCEPTION(0);
38670   }
38671
38672   jresult = result;
38673   return jresult;
38674 }
38675
38676
38677 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
38678   bool jresult ;
38679   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38680   SwigDirector_ViewImpl *darg = 0;
38681   bool result;
38682
38683   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38684   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38685   if (!darg) {
38686     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38687     return 0;
38688   }
38689   {
38690     try {
38691       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
38692     } CALL_CATCH_EXCEPTION(0);
38693   }
38694
38695   jresult = result;
38696   return jresult;
38697 }
38698
38699
38700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
38701   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38702   Dali::Dimension::Type arg2 ;
38703   SwigDirector_ViewImpl *darg = 0;
38704
38705   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38706   arg2 = (Dali::Dimension::Type)jarg2;
38707   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38708   if (!darg) {
38709     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38710     return;
38711   }
38712   {
38713     try {
38714       (darg)->OnCalculateRelayoutSize(arg2);
38715     } CALL_CATCH_EXCEPTION();
38716   }
38717
38718 }
38719
38720
38721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
38722   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38723   Dali::Dimension::Type arg2 ;
38724   SwigDirector_ViewImpl *darg = 0;
38725
38726   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38727   arg2 = (Dali::Dimension::Type)jarg2;
38728   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38729   if (!darg) {
38730     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38731     return;
38732   }
38733   {
38734     try {
38735       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
38736     } CALL_CATCH_EXCEPTION();
38737   }
38738
38739 }
38740
38741
38742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
38743   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38744   float arg2 ;
38745   Dali::Dimension::Type arg3 ;
38746   SwigDirector_ViewImpl *darg = 0;
38747
38748   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38749   arg2 = (float)jarg2;
38750   arg3 = (Dali::Dimension::Type)jarg3;
38751   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38752   if (!darg) {
38753     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38754     return;
38755   }
38756   {
38757     try {
38758       (darg)->OnLayoutNegotiated(arg2,arg3);
38759     } CALL_CATCH_EXCEPTION();
38760   }
38761
38762 }
38763
38764
38765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
38766   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38767   float arg2 ;
38768   Dali::Dimension::Type arg3 ;
38769   SwigDirector_ViewImpl *darg = 0;
38770
38771   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38772   arg2 = (float)jarg2;
38773   arg3 = (Dali::Dimension::Type)jarg3;
38774   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38775   if (!darg) {
38776     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38777     return;
38778   }
38779   {
38780     try {
38781       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
38782     } CALL_CATCH_EXCEPTION();
38783   }
38784
38785 }
38786
38787
38788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
38789   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38790
38791   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38792   {
38793     try {
38794       (arg1)->OnInitialize();
38795     } CALL_CATCH_EXCEPTION();
38796   }
38797
38798 }
38799
38800
38801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
38802   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38803
38804   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38805   {
38806     try {
38807       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
38808     } CALL_CATCH_EXCEPTION();
38809   }
38810
38811 }
38812
38813
38814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
38815   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38816   Dali::Toolkit::StyleManager arg2 ;
38817   Dali::StyleChange::Type arg3 ;
38818   Dali::Toolkit::StyleManager *argp2 ;
38819
38820   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38821   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
38822   if (!argp2) {
38823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
38824     return ;
38825   }
38826   arg2 = *argp2;
38827   arg3 = (Dali::StyleChange::Type)jarg3;
38828   {
38829     try {
38830       (arg1)->OnStyleChange(arg2,arg3);
38831     } CALL_CATCH_EXCEPTION();
38832   }
38833
38834 }
38835
38836
38837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
38838   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38839   Dali::Toolkit::StyleManager arg2 ;
38840   Dali::StyleChange::Type arg3 ;
38841   Dali::Toolkit::StyleManager *argp2 ;
38842
38843   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38844   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
38845   if (!argp2) {
38846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
38847     return ;
38848   }
38849   arg2 = *argp2;
38850   arg3 = (Dali::StyleChange::Type)jarg3;
38851   {
38852     try {
38853       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
38854     } CALL_CATCH_EXCEPTION();
38855   }
38856
38857 }
38858
38859
38860 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
38861   bool jresult ;
38862   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38863   bool result;
38864
38865   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38866   {
38867     try {
38868       result = (bool)(arg1)->OnAccessibilityActivated();
38869     } CALL_CATCH_EXCEPTION(0);
38870   }
38871
38872   jresult = result;
38873   return jresult;
38874 }
38875
38876
38877 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
38878   bool jresult ;
38879   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38880   bool result;
38881
38882   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38883   {
38884     try {
38885       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
38886     } CALL_CATCH_EXCEPTION(0);
38887   }
38888
38889   jresult = result;
38890   return jresult;
38891 }
38892
38893
38894 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
38895   bool jresult ;
38896   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38897   Dali::PanGesture arg2 ;
38898   Dali::PanGesture *argp2 ;
38899   bool result;
38900
38901   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38902   argp2 = (Dali::PanGesture *)jarg2;
38903   if (!argp2) {
38904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
38905     return 0;
38906   }
38907   arg2 = *argp2;
38908   {
38909     try {
38910       result = (bool)(arg1)->OnAccessibilityPan(arg2);
38911     } CALL_CATCH_EXCEPTION(0);
38912   }
38913
38914   jresult = result;
38915   return jresult;
38916 }
38917
38918
38919 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
38920   bool jresult ;
38921   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38922   Dali::PanGesture arg2 ;
38923   Dali::PanGesture *argp2 ;
38924   bool result;
38925
38926   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38927   argp2 = (Dali::PanGesture *)jarg2;
38928   if (!argp2) {
38929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
38930     return 0;
38931   }
38932   arg2 = *argp2;
38933   {
38934     try {
38935       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
38936     } CALL_CATCH_EXCEPTION(0);
38937   }
38938
38939   jresult = result;
38940   return jresult;
38941 }
38942
38943 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, bool jarg2) {
38944   bool jresult ;
38945   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38946   bool arg2 ;
38947   bool result;
38948
38949   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38950   arg2 = jarg2 ? true : false;
38951   {
38952     try {
38953       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
38954     } CALL_CATCH_EXCEPTION(0);
38955   }
38956
38957   jresult = result;
38958   return jresult;
38959 }
38960
38961
38962 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, bool jarg2) {
38963   bool jresult ;
38964   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38965   bool arg2 ;
38966   bool result;
38967
38968   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38969   arg2 = jarg2 ? true : false;
38970   {
38971     try {
38972       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
38973     } CALL_CATCH_EXCEPTION(0);
38974   }
38975
38976   jresult = result;
38977   return jresult;
38978 }
38979
38980
38981 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
38982   bool jresult ;
38983   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38984   bool result;
38985
38986   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38987   {
38988     try {
38989       result = (bool)(arg1)->OnAccessibilityZoom();
38990     } CALL_CATCH_EXCEPTION(0);
38991   }
38992
38993   jresult = result;
38994   return jresult;
38995 }
38996
38997
38998 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
38999   bool jresult ;
39000   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39001   bool result;
39002
39003   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39004   {
39005     try {
39006       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
39007     } CALL_CATCH_EXCEPTION(0);
39008   }
39009
39010   jresult = result;
39011   return jresult;
39012 }
39013
39014
39015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
39016   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39017
39018   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39019   {
39020     try {
39021       (arg1)->OnKeyInputFocusGained();
39022     } CALL_CATCH_EXCEPTION();
39023   }
39024
39025 }
39026
39027
39028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
39029   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39030
39031   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39032   {
39033     try {
39034       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
39035     } CALL_CATCH_EXCEPTION();
39036   }
39037
39038 }
39039
39040
39041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
39042   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39043
39044   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39045   {
39046     try {
39047       (arg1)->OnKeyInputFocusLost();
39048     } CALL_CATCH_EXCEPTION();
39049   }
39050
39051 }
39052
39053
39054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
39055   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39056
39057   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39058   {
39059     try {
39060       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
39061     } CALL_CATCH_EXCEPTION();
39062   }
39063
39064 }
39065
39066
39067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, bool jarg4) {
39068   void * jresult ;
39069   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39070   Dali::Actor arg2 ;
39071   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
39072   bool arg4 ;
39073   Dali::Actor *argp2 ;
39074   Dali::Actor result;
39075
39076   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39077   argp2 = (Dali::Actor *)jarg2;
39078   if (!argp2) {
39079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39080     return 0;
39081   }
39082   arg2 = *argp2;
39083   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
39084   arg4 = jarg4 ? true : false;
39085   {
39086     try {
39087       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
39088     } CALL_CATCH_EXCEPTION(0);
39089   }
39090
39091   jresult = new Dali::Actor((const Dali::Actor &)result);
39092   return jresult;
39093 }
39094
39095
39096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, bool jarg4) {
39097   void * jresult ;
39098   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39099   Dali::Actor arg2 ;
39100   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
39101   bool arg4 ;
39102   Dali::Actor *argp2 ;
39103   Dali::Actor result;
39104
39105   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39106   argp2 = (Dali::Actor *)jarg2;
39107   if (!argp2) {
39108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39109     return 0;
39110   }
39111   arg2 = *argp2;
39112   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
39113   arg4 = jarg4 ? true : false;
39114   {
39115     try {
39116       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
39117     } CALL_CATCH_EXCEPTION(0);
39118   }
39119
39120   jresult = new Dali::Actor((const Dali::Actor &)result);
39121   return jresult;
39122 }
39123
39124
39125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
39126   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39127   Dali::Actor arg2 ;
39128   Dali::Actor *argp2 ;
39129
39130   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39131   argp2 = (Dali::Actor *)jarg2;
39132   if (!argp2) {
39133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39134     return ;
39135   }
39136   arg2 = *argp2;
39137   {
39138     try {
39139       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
39140     } CALL_CATCH_EXCEPTION();
39141   }
39142
39143 }
39144
39145
39146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
39147   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39148   Dali::Actor arg2 ;
39149   Dali::Actor *argp2 ;
39150
39151   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39152   argp2 = (Dali::Actor *)jarg2;
39153   if (!argp2) {
39154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39155     return ;
39156   }
39157   arg2 = *argp2;
39158   {
39159     try {
39160       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
39161     } CALL_CATCH_EXCEPTION();
39162   }
39163
39164 }
39165
39166
39167 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
39168   bool jresult ;
39169   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39170   bool result;
39171
39172   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39173   {
39174     try {
39175       result = (bool)(arg1)->OnKeyboardEnter();
39176     } CALL_CATCH_EXCEPTION(0);
39177   }
39178
39179   jresult = result;
39180   return jresult;
39181 }
39182
39183
39184 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
39185   bool jresult ;
39186   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39187   bool result;
39188
39189   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39190   {
39191     try {
39192       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
39193     } CALL_CATCH_EXCEPTION(0);
39194   }
39195
39196   jresult = result;
39197   return jresult;
39198 }
39199
39200
39201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
39202   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39203   Dali::PinchGesture *arg2 = 0 ;
39204
39205   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39206   arg2 = (Dali::PinchGesture *)jarg2;
39207   if (!arg2) {
39208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
39209     return ;
39210   }
39211   {
39212     try {
39213       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
39214     } CALL_CATCH_EXCEPTION();
39215   }
39216
39217 }
39218
39219
39220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
39221   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39222   Dali::PinchGesture *arg2 = 0 ;
39223
39224   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39225   arg2 = (Dali::PinchGesture *)jarg2;
39226   if (!arg2) {
39227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
39228     return ;
39229   }
39230   {
39231     try {
39232       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
39233     } CALL_CATCH_EXCEPTION();
39234   }
39235
39236 }
39237
39238
39239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
39240   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39241   Dali::PanGesture *arg2 = 0 ;
39242
39243   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39244   arg2 = (Dali::PanGesture *)jarg2;
39245   if (!arg2) {
39246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
39247     return ;
39248   }
39249   {
39250     try {
39251       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
39252     } CALL_CATCH_EXCEPTION();
39253   }
39254
39255 }
39256
39257
39258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
39259   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39260   Dali::PanGesture *arg2 = 0 ;
39261
39262   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39263   arg2 = (Dali::PanGesture *)jarg2;
39264   if (!arg2) {
39265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
39266     return ;
39267   }
39268   {
39269     try {
39270       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
39271     } CALL_CATCH_EXCEPTION();
39272   }
39273
39274 }
39275
39276
39277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
39278   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39279   Dali::TapGesture *arg2 = 0 ;
39280
39281   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39282   arg2 = (Dali::TapGesture *)jarg2;
39283   if (!arg2) {
39284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
39285     return ;
39286   }
39287   {
39288     try {
39289       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
39290     } CALL_CATCH_EXCEPTION();
39291   }
39292
39293 }
39294
39295
39296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
39297   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39298   Dali::TapGesture *arg2 = 0 ;
39299
39300   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39301   arg2 = (Dali::TapGesture *)jarg2;
39302   if (!arg2) {
39303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
39304     return ;
39305   }
39306   {
39307     try {
39308       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
39309     } CALL_CATCH_EXCEPTION();
39310   }
39311
39312 }
39313
39314
39315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
39316   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39317   Dali::LongPressGesture *arg2 = 0 ;
39318
39319   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39320   arg2 = (Dali::LongPressGesture *)jarg2;
39321   if (!arg2) {
39322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
39323     return ;
39324   }
39325   {
39326     try {
39327       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
39328     } CALL_CATCH_EXCEPTION();
39329   }
39330
39331 }
39332
39333
39334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
39335   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39336   Dali::LongPressGesture *arg2 = 0 ;
39337
39338   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39339   arg2 = (Dali::LongPressGesture *)jarg2;
39340   if (!arg2) {
39341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
39342     return ;
39343   }
39344   {
39345     try {
39346       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
39347     } CALL_CATCH_EXCEPTION();
39348   }
39349
39350 }
39351
39352
39353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
39354   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39355   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
39356   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
39357
39358   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39359   arg2 = (Dali::SlotObserver *)jarg2;
39360   arg3 = (Dali::CallbackBase *)jarg3;
39361   {
39362     try {
39363       (arg1)->SignalConnected(arg2,arg3);
39364     } CALL_CATCH_EXCEPTION();
39365   }
39366
39367 }
39368
39369
39370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
39371   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39372   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
39373   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
39374
39375   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39376   arg2 = (Dali::SlotObserver *)jarg2;
39377   arg3 = (Dali::CallbackBase *)jarg3;
39378   {
39379     try {
39380       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
39381     } CALL_CATCH_EXCEPTION();
39382   }
39383
39384 }
39385
39386
39387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
39388   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39389   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
39390   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
39391
39392   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39393   arg2 = (Dali::SlotObserver *)jarg2;
39394   arg3 = (Dali::CallbackBase *)jarg3;
39395   {
39396     try {
39397       (arg1)->SignalDisconnected(arg2,arg3);
39398     } CALL_CATCH_EXCEPTION();
39399   }
39400
39401 }
39402
39403
39404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
39405   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39406   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
39407   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
39408
39409   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39410   arg2 = (Dali::SlotObserver *)jarg2;
39411   arg3 = (Dali::CallbackBase *)jarg3;
39412   {
39413     try {
39414       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
39415     } CALL_CATCH_EXCEPTION();
39416   }
39417
39418 }
39419
39420 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) {
39421   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
39422   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
39423   if (director) {
39424     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);
39425   }
39426 }
39427
39428
39429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
39430   void * jresult ;
39431   Dali::Toolkit::Control *arg1 = 0 ;
39432   Dali::Toolkit::Internal::Control *result = 0 ;
39433
39434   arg1 = (Dali::Toolkit::Control *)jarg1;
39435   if (!arg1) {
39436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
39437     return 0;
39438   }
39439   {
39440     try {
39441       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
39442     } CALL_CATCH_EXCEPTION(0);
39443   }
39444
39445   jresult = (void *)result;
39446   return jresult;
39447 }
39448
39449
39450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
39451   int jresult ;
39452   int result;
39453
39454   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
39455   jresult = (int)result;
39456   return jresult;
39457 }
39458
39459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
39460   int jresult ;
39461   int result;
39462
39463   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
39464   jresult = (int)result;
39465   return jresult;
39466 }
39467
39468
39469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
39470   int jresult ;
39471   int result;
39472
39473   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
39474   jresult = (int)result;
39475   return jresult;
39476 }
39477
39478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
39479   int jresult ;
39480   int result;
39481
39482   result = (int)Dali::Toolkit::Control::Property::MARGIN;
39483   jresult = (int)result;
39484   return jresult;
39485 }
39486
39487
39488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
39489   int jresult ;
39490   int result;
39491
39492   result = (int)Dali::Toolkit::Control::Property::PADDING;
39493   jresult = (int)result;
39494   return jresult;
39495 }
39496
39497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
39498   int jresult ;
39499   int result;
39500
39501   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
39502   jresult = (int)result;
39503   return jresult;
39504 }
39505
39506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_NAME_get() {
39507   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_NAME;
39508 }
39509
39510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_DESCRIPTION_get() {
39511   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_DESCRIPTION;
39512 }
39513
39514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_TRANSLATION_DOMAIN_get() {
39515   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_TRANSLATION_DOMAIN;
39516 }
39517
39518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_ROLE_get() {
39519   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_ROLE;
39520 }
39521
39522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_HIGHLIGHTABLE_get() {
39523   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE;
39524 }
39525
39526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_ATTRIBUTES_get() {
39527   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_ATTRIBUTES;
39528 }
39529
39530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_HIDDEN_get() {
39531   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_HIDDEN;
39532 }
39533
39534 SWIGEXPORT int SWIGSTDCALL  CSharp_Dali_View_Property_AUTOMATION_ID_get() {
39535   return (int)Dali::Toolkit::DevelControl::Property::AUTOMATION_ID;
39536 }
39537
39538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
39539   void * jresult ;
39540   Dali::Toolkit::Control::Property *result = 0 ;
39541
39542   {
39543     try {
39544       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
39545     } CALL_CATCH_EXCEPTION(0);
39546   }
39547
39548   jresult = (void *)result;
39549   return jresult;
39550 }
39551
39552
39553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
39554   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
39555
39556   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
39557   {
39558     try {
39559       delete arg1;
39560     } CALL_CATCH_EXCEPTION();
39561   }
39562
39563 }
39564
39565
39566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
39567   void * jresult ;
39568   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
39569
39570   {
39571     try {
39572       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
39573     } CALL_CATCH_EXCEPTION(0);
39574   }
39575
39576   jresult = (void *)result;
39577   return jresult;
39578 }
39579
39580
39581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
39582   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
39583
39584   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
39585   {
39586     try {
39587       delete arg1;
39588     } CALL_CATCH_EXCEPTION();
39589   }
39590
39591 }
39592
39593
39594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
39595   void * jresult ;
39596   Dali::Toolkit::Control result;
39597
39598   {
39599     try {
39600       result = Dali::Toolkit::Control::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
39601     } CALL_CATCH_EXCEPTION(0);
39602   }
39603
39604   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
39605   return jresult;
39606 }
39607
39608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_NewCustom() {
39609   void * jresult;
39610   Dali::Toolkit::Control result;
39611
39612   {
39613     try {
39614       result = SlimCustomViewImpl::New(Dali::Toolkit::Internal::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
39615     } CALL_CATCH_EXCEPTION(0);
39616   }
39617
39618   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
39619   return jresult;
39620 }
39621
39622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
39623   void * jresult ;
39624   Dali::Toolkit::Control *result = 0 ;
39625
39626   {
39627     try {
39628       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
39629     } CALL_CATCH_EXCEPTION(0);
39630   }
39631
39632   jresult = (void *)result;
39633   return jresult;
39634 }
39635
39636
39637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
39638   void * jresult ;
39639   Dali::Toolkit::Control *arg1 = 0 ;
39640   Dali::Toolkit::Control *result = 0 ;
39641
39642   arg1 = (Dali::Toolkit::Control *)jarg1;
39643   if (!arg1) {
39644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
39645     return 0;
39646   }
39647   {
39648     try {
39649       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
39650     } CALL_CATCH_EXCEPTION(0);
39651   }
39652
39653   jresult = (void *)result;
39654   return jresult;
39655 }
39656
39657
39658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
39659   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39660
39661   arg1 = (Dali::Toolkit::Control *)jarg1;
39662   {
39663     try {
39664       delete arg1;
39665     } CALL_CATCH_EXCEPTION();
39666   }
39667
39668 }
39669
39670
39671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
39672   void * jresult ;
39673   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39674   Dali::Toolkit::Control *arg2 = 0 ;
39675   Dali::Toolkit::Control *result = 0 ;
39676
39677   arg1 = (Dali::Toolkit::Control *)jarg1;
39678   arg2 = (Dali::Toolkit::Control *)jarg2;
39679   if (!arg2) {
39680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
39681     return 0;
39682   }
39683   {
39684     try {
39685       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
39686     } CALL_CATCH_EXCEPTION(0);
39687   }
39688
39689   jresult = (void *)result;
39690   return jresult;
39691 }
39692
39693
39694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
39695   void * jresult ;
39696   Dali::BaseHandle arg1 ;
39697   Dali::BaseHandle *argp1 ;
39698   Dali::Toolkit::Control result;
39699
39700   argp1 = (Dali::BaseHandle *)jarg1;
39701   if (!argp1) {
39702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39703     return 0;
39704   }
39705   arg1 = *argp1;
39706   {
39707     try {
39708       result = Dali::Toolkit::Control::DownCast(arg1);
39709     } CALL_CATCH_EXCEPTION(0);
39710   }
39711
39712   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
39713   return jresult;
39714 }
39715
39716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Control(void * jarg1) {
39717   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) jarg1;
39718   try {
39719     delete arg1;
39720   } CALL_CATCH_EXCEPTION();
39721 }
39722
39723
39724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
39725   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39726
39727   arg1 = (Dali::Toolkit::Control *)jarg1;
39728   {
39729     try {
39730       (arg1)->SetKeyInputFocus();
39731     } CALL_CATCH_EXCEPTION();
39732   }
39733
39734 }
39735
39736
39737 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
39738   bool jresult ;
39739   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39740   bool result;
39741
39742   arg1 = (Dali::Toolkit::Control *)jarg1;
39743   {
39744     try {
39745       result = (bool)(arg1)->HasKeyInputFocus();
39746     } CALL_CATCH_EXCEPTION(0);
39747   }
39748
39749   jresult = result;
39750   return jresult;
39751 }
39752
39753
39754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
39755   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39756
39757   arg1 = (Dali::Toolkit::Control *)jarg1;
39758   {
39759     try {
39760       (arg1)->ClearKeyInputFocus();
39761     } CALL_CATCH_EXCEPTION();
39762   }
39763
39764 }
39765
39766
39767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
39768   void * jresult ;
39769   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39770   Dali::PinchGestureDetector result;
39771
39772   arg1 = (Dali::Toolkit::Control *)jarg1;
39773   {
39774     try {
39775       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
39776     } CALL_CATCH_EXCEPTION(0);
39777   }
39778
39779   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
39780   return jresult;
39781 }
39782
39783
39784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
39785   void * jresult ;
39786   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39787   Dali::PanGestureDetector result;
39788
39789   arg1 = (Dali::Toolkit::Control *)jarg1;
39790   {
39791     try {
39792       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
39793     } CALL_CATCH_EXCEPTION(0);
39794   }
39795
39796   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
39797   return jresult;
39798 }
39799
39800
39801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
39802   void * jresult ;
39803   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39804   Dali::TapGestureDetector result;
39805
39806   arg1 = (Dali::Toolkit::Control *)jarg1;
39807   {
39808     try {
39809       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
39810     } CALL_CATCH_EXCEPTION(0);
39811   }
39812
39813   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
39814   return jresult;
39815 }
39816
39817
39818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
39819   void * jresult ;
39820   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39821   Dali::LongPressGestureDetector result;
39822
39823   arg1 = (Dali::Toolkit::Control *)jarg1;
39824   {
39825     try {
39826       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
39827     } CALL_CATCH_EXCEPTION(0);
39828   }
39829
39830   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
39831   return jresult;
39832 }
39833
39834
39835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
39836   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39837   std::string *arg2 = 0 ;
39838
39839   arg1 = (Dali::Toolkit::Control *)jarg1;
39840   if (!jarg2) {
39841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
39842     return ;
39843   }
39844   std::string arg2_str(jarg2);
39845   arg2 = &arg2_str;
39846   {
39847     try {
39848       (arg1)->SetStyleName((std::string const &)*arg2);
39849     } CALL_CATCH_EXCEPTION();
39850   }
39851
39852
39853   //argout typemap for const std::string&
39854
39855 }
39856
39857
39858 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
39859   char * jresult ;
39860   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39861   std::string *result = 0 ;
39862
39863   arg1 = (Dali::Toolkit::Control *)jarg1;
39864   {
39865     try {
39866       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
39867     } CALL_CATCH_EXCEPTION(0);
39868   }
39869
39870   jresult = SWIG_csharp_string_callback(result->c_str());
39871   return jresult;
39872 }
39873
39874
39875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
39876   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39877   Dali::Vector4 *arg2 = 0 ;
39878
39879   arg1 = (Dali::Toolkit::Control *)jarg1;
39880   arg2 = (Dali::Vector4 *)jarg2;
39881   if (!arg2) {
39882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
39883     return ;
39884   }
39885   {
39886     try {
39887       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
39888     } CALL_CATCH_EXCEPTION();
39889   }
39890
39891 }
39892
39893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
39894   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39895
39896   arg1 = (Dali::Toolkit::Control *)jarg1;
39897   {
39898     try {
39899       (arg1)->ClearBackground();
39900     } CALL_CATCH_EXCEPTION();
39901   }
39902
39903 }
39904
39905
39906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
39907   void * jresult ;
39908   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39909   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
39910
39911   arg1 = (Dali::Toolkit::Control *)jarg1;
39912   {
39913     try {
39914       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
39915     } CALL_CATCH_EXCEPTION(0);
39916   }
39917
39918   jresult = (void *)result;
39919   return jresult;
39920 }
39921
39922
39923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
39924   void * jresult ;
39925   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39926   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
39927
39928   arg1 = (Dali::Toolkit::Control *)jarg1;
39929   {
39930     try {
39931       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
39932     } CALL_CATCH_EXCEPTION(0);
39933   }
39934
39935   jresult = (void *)result;
39936   return jresult;
39937 }
39938
39939
39940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
39941   void * jresult ;
39942   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39943   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
39944
39945   arg1 = (Dali::Toolkit::Control *)jarg1;
39946   {
39947     try {
39948       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
39949     } CALL_CATCH_EXCEPTION(0);
39950   }
39951
39952   jresult = (void *)result;
39953   return jresult;
39954 }
39955
39956
39957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
39958   void * jresult ;
39959   Dali::Toolkit::Internal::Control *arg1 = 0 ;
39960   Dali::Toolkit::Control *result = 0 ;
39961
39962   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39963   if (!arg1) {
39964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
39965     return 0;
39966   }
39967   {
39968     try {
39969       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
39970     } CALL_CATCH_EXCEPTION(0);
39971   }
39972
39973   jresult = (void *)result;
39974   return jresult;
39975 }
39976
39977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
39978 {
39979   int jresult;
39980   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39981   arg1 = (Dali::Toolkit::Control *)jarg1;
39982
39983   if (!arg1) {
39984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
39985     return 0;
39986   }
39987
39988   Dali::Property::Index arg2 = 0 ;
39989   arg2 = (Dali::Property::Index)jarg2;
39990
39991   Toolkit::Visual::ResourceStatus result;
39992   {
39993     try {
39994       result = arg1->GetVisualResourceStatus(arg2);
39995     } CALL_CATCH_EXCEPTION(0);
39996   }
39997
39998   jresult = (int)result;
39999   return jresult;
40000 }
40001
40002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
40003 {
40004   void * jresult;
40005   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40006   arg1 = (Dali::Toolkit::Control *)jarg1;
40007
40008   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
40009
40010   Dali::Toolkit::TransitionData *arg2 = 0 ;
40011   Dali::Animation result;
40012
40013   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
40014   if (!arg2) {
40015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
40016     return 0;
40017   }
40018   {
40019     try {
40020       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
40021     } CALL_CATCH_EXCEPTION(0);
40022   }
40023
40024   jresult = new Dali::Animation((const Dali::Animation &)result);
40025   return jresult;
40026 }
40027
40028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
40029 {
40030   Dali::Toolkit::Control arg1;
40031   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
40032
40033   if (!argp1) {
40034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
40035   }
40036   arg1 = *argp1;
40037
40038   Dali::Property::Index arg2 = 0 ;
40039   arg2 = (Dali::Property::Index)jarg2;
40040
40041   Dali::Property::Index arg3 = 0 ;
40042   arg3 = (Dali::Property::Index)jarg3;
40043
40044   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
40045
40046   {
40047     try {
40048       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
40049     } CALL_CATCH_EXCEPTION();
40050   }
40051 }
40052
40053 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_View_GetVisualProperty(void* control, int propertyIndex, int visualPropertyIndex)
40054 {
40055   if (!control)
40056   {
40057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Given control is null", 0);
40058     return 0;
40059   }
40060
40061   void* result = 0;
40062   try
40063   {
40064     Dali::Property property = DevelControl::GetVisualProperty(*((Dali::Toolkit::Control*)control), (Dali::Property::Index)propertyIndex, (Dali::Property::Index)visualPropertyIndex);
40065     result = new Dali::Property(property.object, property.propertyIndex, property.componentIndex);
40066   }
40067   CALL_CATCH_EXCEPTION(0);
40068
40069   return result;
40070 }
40071
40072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
40073   void * jresult ;
40074   Dali::Toolkit::Control *arg1 = 0 ;
40075   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
40076
40077   arg1 = (Dali::Toolkit::Control *)jarg1;
40078   if (!arg1) {
40079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
40080     return 0;
40081   }
40082   {
40083     try {
40084       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
40085     } CALL_CATCH_EXCEPTION(0);
40086   }
40087
40088   jresult = (void *)result;
40089   return jresult;
40090 }
40091
40092
40093 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
40094   bool jresult ;
40095   Dali::Toolkit::Control *arg1 = 0 ;
40096   bool result;
40097
40098   arg1 = (Dali::Toolkit::Control *)jarg1;
40099   if (!arg1) {
40100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
40101     return 0;
40102   }
40103   {
40104     try {
40105       result = (bool)arg1->IsResourceReady();
40106     } CALL_CATCH_EXCEPTION(0);
40107   }
40108
40109   jresult = result;
40110   return jresult;
40111 }
40112
40113
40114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
40115   void * jresult ;
40116   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
40117
40118   {
40119     try {
40120       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
40121     } CALL_CATCH_EXCEPTION(0);
40122   }
40123
40124   jresult = (void *)result;
40125   return jresult;
40126 }
40127
40128
40129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
40130   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
40131
40132   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
40133   {
40134     try {
40135       delete arg1;
40136     } CALL_CATCH_EXCEPTION();
40137   }
40138
40139 }
40140
40141
40142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
40143   void * jresult ;
40144   Dali::Toolkit::KeyInputFocusManager result;
40145
40146   {
40147     try {
40148       result = Dali::Toolkit::KeyInputFocusManager::Get();
40149     } CALL_CATCH_EXCEPTION(0);
40150   }
40151
40152   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
40153   return jresult;
40154 }
40155
40156
40157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
40158   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
40159   Dali::Toolkit::Control arg2 ;
40160   Dali::Toolkit::Control *argp2 ;
40161
40162   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
40163   argp2 = (Dali::Toolkit::Control *)jarg2;
40164   if (!argp2) {
40165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
40166     return ;
40167   }
40168   arg2 = *argp2;
40169   {
40170     try {
40171       (arg1)->SetFocus(arg2);
40172     } CALL_CATCH_EXCEPTION();
40173   }
40174
40175 }
40176
40177
40178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
40179   void * jresult ;
40180   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
40181   Dali::Toolkit::Control result;
40182
40183   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
40184   {
40185     try {
40186       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
40187     } CALL_CATCH_EXCEPTION(0);
40188   }
40189
40190   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
40191   return jresult;
40192 }
40193
40194
40195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
40196   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
40197   Dali::Toolkit::Control arg2 ;
40198   Dali::Toolkit::Control *argp2 ;
40199
40200   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
40201   argp2 = (Dali::Toolkit::Control *)jarg2;
40202   if (!argp2) {
40203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
40204     return ;
40205   }
40206   arg2 = *argp2;
40207   {
40208     try {
40209       (arg1)->RemoveFocus(arg2);
40210     } CALL_CATCH_EXCEPTION();
40211   }
40212
40213 }
40214
40215
40216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
40217   void * jresult ;
40218   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
40219   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
40220
40221   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
40222   {
40223     try {
40224       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
40225     } CALL_CATCH_EXCEPTION(0);
40226   }
40227
40228   jresult = (void *)result;
40229   return jresult;
40230 }
40231
40232
40233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
40234   void * jresult ;
40235   Dali::Toolkit::Alignment::Padding *result = 0 ;
40236
40237   {
40238     try {
40239       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
40240     } CALL_CATCH_EXCEPTION(0);
40241   }
40242
40243   jresult = (void *)result;
40244   return jresult;
40245 }
40246
40247
40248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
40249   void * jresult ;
40250   float arg1 ;
40251   float arg2 ;
40252   float arg3 ;
40253   float arg4 ;
40254   Dali::Toolkit::Alignment::Padding *result = 0 ;
40255
40256   arg1 = (float)jarg1;
40257   arg2 = (float)jarg2;
40258   arg3 = (float)jarg3;
40259   arg4 = (float)jarg4;
40260   {
40261     try {
40262       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
40263     } CALL_CATCH_EXCEPTION(0);
40264   }
40265
40266   jresult = (void *)result;
40267   return jresult;
40268 }
40269
40270
40271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
40272   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
40273   float arg2 ;
40274
40275   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
40276   arg2 = (float)jarg2;
40277   if (arg1) (arg1)->left = arg2;
40278 }
40279
40280
40281 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
40282   float jresult ;
40283   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
40284   float result;
40285
40286   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
40287   result = (float) ((arg1)->left);
40288   jresult = result;
40289   return jresult;
40290 }
40291
40292
40293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
40294   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
40295   float arg2 ;
40296
40297   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
40298   arg2 = (float)jarg2;
40299   if (arg1) (arg1)->right = arg2;
40300 }
40301
40302
40303 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
40304   float jresult ;
40305   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
40306   float result;
40307
40308   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
40309   result = (float) ((arg1)->right);
40310   jresult = result;
40311   return jresult;
40312 }
40313
40314
40315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
40316   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
40317   float arg2 ;
40318
40319   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
40320   arg2 = (float)jarg2;
40321   if (arg1) (arg1)->top = arg2;
40322 }
40323
40324
40325 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
40326   float jresult ;
40327   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
40328   float result;
40329
40330   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
40331   result = (float) ((arg1)->top);
40332   jresult = result;
40333   return jresult;
40334 }
40335
40336
40337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
40338   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
40339   float arg2 ;
40340
40341   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
40342   arg2 = (float)jarg2;
40343   if (arg1) (arg1)->bottom = arg2;
40344 }
40345
40346
40347 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
40348   float jresult ;
40349   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
40350   float result;
40351
40352   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
40353   result = (float) ((arg1)->bottom);
40354   jresult = result;
40355   return jresult;
40356 }
40357
40358
40359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
40360   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
40361
40362   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
40363   {
40364     try {
40365       delete arg1;
40366     } CALL_CATCH_EXCEPTION();
40367   }
40368
40369 }
40370
40371
40372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
40373   void * jresult ;
40374   Dali::Toolkit::Alignment *result = 0 ;
40375
40376   {
40377     try {
40378       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
40379     } CALL_CATCH_EXCEPTION(0);
40380   }
40381
40382   jresult = (void *)result;
40383   return jresult;
40384 }
40385
40386
40387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
40388   void * jresult ;
40389   Dali::Toolkit::Alignment::Type arg1 ;
40390   Dali::Toolkit::Alignment::Type arg2 ;
40391   Dali::Toolkit::Alignment result;
40392
40393   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
40394   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
40395   {
40396     try {
40397       result = Dali::Toolkit::Alignment::New(arg1,arg2);
40398     } CALL_CATCH_EXCEPTION(0);
40399   }
40400
40401   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
40402   return jresult;
40403 }
40404
40405
40406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
40407   void * jresult ;
40408   Dali::Toolkit::Alignment::Type arg1 ;
40409   Dali::Toolkit::Alignment result;
40410
40411   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
40412   {
40413     try {
40414       result = Dali::Toolkit::Alignment::New(arg1);
40415     } CALL_CATCH_EXCEPTION(0);
40416   }
40417
40418   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
40419   return jresult;
40420 }
40421
40422
40423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
40424   void * jresult ;
40425   Dali::Toolkit::Alignment result;
40426
40427   {
40428     try {
40429       result = Dali::Toolkit::Alignment::New();
40430     } CALL_CATCH_EXCEPTION(0);
40431   }
40432
40433   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
40434   return jresult;
40435 }
40436
40437
40438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
40439   void * jresult ;
40440   Dali::Toolkit::Alignment *arg1 = 0 ;
40441   Dali::Toolkit::Alignment *result = 0 ;
40442
40443   arg1 = (Dali::Toolkit::Alignment *)jarg1;
40444   if (!arg1) {
40445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
40446     return 0;
40447   }
40448   {
40449     try {
40450       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
40451     } CALL_CATCH_EXCEPTION(0);
40452   }
40453
40454   jresult = (void *)result;
40455   return jresult;
40456 }
40457
40458
40459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
40460   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
40461
40462   arg1 = (Dali::Toolkit::Alignment *)jarg1;
40463   {
40464     try {
40465       delete arg1;
40466     } CALL_CATCH_EXCEPTION();
40467   }
40468
40469 }
40470
40471
40472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
40473   void * jresult ;
40474   Dali::BaseHandle arg1 ;
40475   Dali::BaseHandle *argp1 ;
40476   Dali::Toolkit::Alignment result;
40477
40478   argp1 = (Dali::BaseHandle *)jarg1;
40479   if (!argp1) {
40480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40481     return 0;
40482   }
40483   arg1 = *argp1;
40484   {
40485     try {
40486       result = Dali::Toolkit::Alignment::DownCast(arg1);
40487     } CALL_CATCH_EXCEPTION(0);
40488   }
40489
40490   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
40491   return jresult;
40492 }
40493
40494
40495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
40496   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
40497   Dali::Toolkit::Alignment::Type arg2 ;
40498
40499   arg1 = (Dali::Toolkit::Alignment *)jarg1;
40500   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
40501   {
40502     try {
40503       (arg1)->SetAlignmentType(arg2);
40504     } CALL_CATCH_EXCEPTION();
40505   }
40506
40507 }
40508
40509
40510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
40511   int jresult ;
40512   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
40513   Dali::Toolkit::Alignment::Type result;
40514
40515   arg1 = (Dali::Toolkit::Alignment *)jarg1;
40516   {
40517     try {
40518       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
40519     } CALL_CATCH_EXCEPTION(0);
40520   }
40521
40522   jresult = (int)result;
40523   return jresult;
40524 }
40525
40526
40527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
40528   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
40529   Dali::Toolkit::Alignment::Scaling arg2 ;
40530
40531   arg1 = (Dali::Toolkit::Alignment *)jarg1;
40532   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
40533   {
40534     try {
40535       (arg1)->SetScaling(arg2);
40536     } CALL_CATCH_EXCEPTION();
40537   }
40538
40539 }
40540
40541
40542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
40543   int jresult ;
40544   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
40545   Dali::Toolkit::Alignment::Scaling result;
40546
40547   arg1 = (Dali::Toolkit::Alignment *)jarg1;
40548   {
40549     try {
40550       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
40551     } CALL_CATCH_EXCEPTION(0);
40552   }
40553
40554   jresult = (int)result;
40555   return jresult;
40556 }
40557
40558
40559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
40560   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
40561   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
40562
40563   arg1 = (Dali::Toolkit::Alignment *)jarg1;
40564   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
40565   if (!arg2) {
40566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
40567     return ;
40568   }
40569   {
40570     try {
40571       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
40572     } CALL_CATCH_EXCEPTION();
40573   }
40574
40575 }
40576
40577
40578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
40579   void * jresult ;
40580   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
40581   Dali::Toolkit::Alignment::Padding *result = 0 ;
40582
40583   arg1 = (Dali::Toolkit::Alignment *)jarg1;
40584   {
40585     try {
40586       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
40587     } CALL_CATCH_EXCEPTION(0);
40588   }
40589
40590   jresult = (void *)result;
40591   return jresult;
40592 }
40593
40594
40595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
40596   void * jresult ;
40597   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
40598   Dali::Toolkit::Alignment *arg2 = 0 ;
40599   Dali::Toolkit::Alignment *result = 0 ;
40600
40601   arg1 = (Dali::Toolkit::Alignment *)jarg1;
40602   arg2 = (Dali::Toolkit::Alignment *)jarg2;
40603   if (!arg2) {
40604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
40605     return 0;
40606   }
40607   {
40608     try {
40609       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
40610     } CALL_CATCH_EXCEPTION(0);
40611   }
40612
40613   jresult = (void *)result;
40614   return jresult;
40615 }
40616
40617
40618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
40619   int jresult ;
40620   int result;
40621
40622   result = (int)Dali::Toolkit::Button::Property::DISABLED;
40623   jresult = (int)result;
40624   return jresult;
40625 }
40626
40627
40628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
40629   int jresult ;
40630   int result;
40631
40632   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
40633   jresult = (int)result;
40634   return jresult;
40635 }
40636
40637
40638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
40639   int jresult ;
40640   int result;
40641
40642   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
40643   jresult = (int)result;
40644   return jresult;
40645 }
40646
40647
40648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
40649   int jresult ;
40650   int result;
40651
40652   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
40653   jresult = (int)result;
40654   return jresult;
40655 }
40656
40657
40658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
40659   int jresult ;
40660   int result;
40661
40662   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
40663   jresult = (int)result;
40664   return jresult;
40665 }
40666
40667
40668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
40669   int jresult ;
40670   int result;
40671
40672   result = (int)Dali::Toolkit::Button::Property::SELECTED;
40673   jresult = (int)result;
40674   return jresult;
40675 }
40676
40677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
40678   int jresult ;
40679   int result;
40680
40681   result = (int)Dali::Toolkit::Button::Property::LABEL;
40682   jresult = (int)result;
40683   return jresult;
40684 }
40685
40686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
40687   void * jresult ;
40688   Dali::Toolkit::Button::Property *result = 0 ;
40689
40690   {
40691     try {
40692       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
40693     } CALL_CATCH_EXCEPTION(0);
40694   }
40695
40696   jresult = (void *)result;
40697   return jresult;
40698 }
40699
40700
40701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
40702   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
40703
40704   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
40705   {
40706     try {
40707       delete arg1;
40708     } CALL_CATCH_EXCEPTION();
40709   }
40710
40711 }
40712
40713
40714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
40715   void * jresult ;
40716   Dali::Toolkit::Button *result = 0 ;
40717
40718   {
40719     try {
40720       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
40721     } CALL_CATCH_EXCEPTION(0);
40722   }
40723
40724   jresult = (void *)result;
40725   return jresult;
40726 }
40727
40728
40729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
40730   void * jresult ;
40731   Dali::Toolkit::Button *arg1 = 0 ;
40732   Dali::Toolkit::Button *result = 0 ;
40733
40734   arg1 = (Dali::Toolkit::Button *)jarg1;
40735   if (!arg1) {
40736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
40737     return 0;
40738   }
40739   {
40740     try {
40741       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
40742     } CALL_CATCH_EXCEPTION(0);
40743   }
40744
40745   jresult = (void *)result;
40746   return jresult;
40747 }
40748
40749
40750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
40751   void * jresult ;
40752   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
40753   Dali::Toolkit::Button *arg2 = 0 ;
40754   Dali::Toolkit::Button *result = 0 ;
40755
40756   arg1 = (Dali::Toolkit::Button *)jarg1;
40757   arg2 = (Dali::Toolkit::Button *)jarg2;
40758   if (!arg2) {
40759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
40760     return 0;
40761   }
40762   {
40763     try {
40764       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
40765     } CALL_CATCH_EXCEPTION(0);
40766   }
40767
40768   jresult = (void *)result;
40769   return jresult;
40770 }
40771
40772
40773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
40774   void * jresult ;
40775   Dali::BaseHandle arg1 ;
40776   Dali::BaseHandle *argp1 ;
40777   Dali::Toolkit::Button result;
40778
40779   argp1 = (Dali::BaseHandle *)jarg1;
40780   if (!argp1) {
40781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40782     return 0;
40783   }
40784   arg1 = *argp1;
40785   {
40786     try {
40787       result = Dali::Toolkit::Button::DownCast(arg1);
40788     } CALL_CATCH_EXCEPTION(0);
40789   }
40790
40791   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
40792   return jresult;
40793 }
40794
40795
40796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
40797   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
40798
40799   arg1 = (Dali::Toolkit::Button *)jarg1;
40800   {
40801     try {
40802       delete arg1;
40803     } CALL_CATCH_EXCEPTION();
40804   }
40805
40806 }
40807
40808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
40809   void * jresult ;
40810   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
40811   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
40812
40813   arg1 = (Dali::Toolkit::Button *)jarg1;
40814   {
40815     try {
40816       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
40817     } CALL_CATCH_EXCEPTION(0);
40818   }
40819
40820   jresult = (void *)result;
40821   return jresult;
40822 }
40823
40824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
40825   void * jresult ;
40826   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
40827   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
40828
40829   arg1 = (Dali::Toolkit::Button *)jarg1;
40830   {
40831     try {
40832       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
40833     } CALL_CATCH_EXCEPTION(0);
40834   }
40835
40836   jresult = (void *)result;
40837   return jresult;
40838 }
40839
40840
40841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
40842   void * jresult ;
40843   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
40844   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
40845
40846   arg1 = (Dali::Toolkit::Button *)jarg1;
40847   {
40848     try {
40849       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
40850     } CALL_CATCH_EXCEPTION(0);
40851   }
40852
40853   jresult = (void *)result;
40854   return jresult;
40855 }
40856
40857
40858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
40859   void * jresult ;
40860   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
40861   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
40862
40863   arg1 = (Dali::Toolkit::Button *)jarg1;
40864   {
40865     try {
40866       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
40867     } CALL_CATCH_EXCEPTION(0);
40868   }
40869
40870   jresult = (void *)result;
40871   return jresult;
40872 }
40873
40874
40875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
40876   void * jresult ;
40877   Dali::Toolkit::CheckBoxButton *result = 0 ;
40878
40879   {
40880     try {
40881       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
40882     } CALL_CATCH_EXCEPTION(0);
40883   }
40884
40885   jresult = (void *)result;
40886   return jresult;
40887 }
40888
40889
40890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
40891   void * jresult ;
40892   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
40893   Dali::Toolkit::CheckBoxButton *result = 0 ;
40894
40895   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
40896   if (!arg1) {
40897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
40898     return 0;
40899   }
40900   {
40901     try {
40902       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
40903     } CALL_CATCH_EXCEPTION(0);
40904   }
40905
40906   jresult = (void *)result;
40907   return jresult;
40908 }
40909
40910
40911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
40912   void * jresult ;
40913   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
40914   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
40915   Dali::Toolkit::CheckBoxButton *result = 0 ;
40916
40917   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
40918   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
40919   if (!arg2) {
40920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
40921     return 0;
40922   }
40923   {
40924     try {
40925       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
40926     } CALL_CATCH_EXCEPTION(0);
40927   }
40928
40929   jresult = (void *)result;
40930   return jresult;
40931 }
40932
40933
40934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
40935   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
40936
40937   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
40938   {
40939     try {
40940       delete arg1;
40941     } CALL_CATCH_EXCEPTION();
40942   }
40943
40944 }
40945
40946
40947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
40948   void * jresult ;
40949   Dali::Toolkit::CheckBoxButton result;
40950
40951   {
40952     try {
40953       result = Dali::Toolkit::CheckBoxButton::New();
40954     } CALL_CATCH_EXCEPTION(0);
40955   }
40956
40957   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
40958   return jresult;
40959 }
40960
40961
40962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
40963   void * jresult ;
40964   Dali::BaseHandle arg1 ;
40965   Dali::BaseHandle *argp1 ;
40966   Dali::Toolkit::CheckBoxButton result;
40967
40968   argp1 = (Dali::BaseHandle *)jarg1;
40969   if (!argp1) {
40970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40971     return 0;
40972   }
40973   arg1 = *argp1;
40974   {
40975     try {
40976       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
40977     } CALL_CATCH_EXCEPTION(0);
40978   }
40979
40980   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
40981   return jresult;
40982 }
40983
40984
40985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
40986   int jresult ;
40987   int result;
40988
40989   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
40990   jresult = (int)result;
40991   return jresult;
40992 }
40993
40994
40995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
40996   int jresult ;
40997   int result;
40998
40999   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
41000   jresult = (int)result;
41001   return jresult;
41002 }
41003
41004
41005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
41006   void * jresult ;
41007   Dali::Toolkit::PushButton::Property *result = 0 ;
41008
41009   {
41010     try {
41011       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
41012     } CALL_CATCH_EXCEPTION(0);
41013   }
41014
41015   jresult = (void *)result;
41016   return jresult;
41017 }
41018
41019
41020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
41021   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
41022
41023   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
41024   {
41025     try {
41026       delete arg1;
41027     } CALL_CATCH_EXCEPTION();
41028   }
41029
41030 }
41031
41032
41033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
41034   void * jresult ;
41035   Dali::Toolkit::PushButton *result = 0 ;
41036
41037   {
41038     try {
41039       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
41040     } CALL_CATCH_EXCEPTION(0);
41041   }
41042
41043   jresult = (void *)result;
41044   return jresult;
41045 }
41046
41047
41048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
41049   void * jresult ;
41050   Dali::Toolkit::PushButton *arg1 = 0 ;
41051   Dali::Toolkit::PushButton *result = 0 ;
41052
41053   arg1 = (Dali::Toolkit::PushButton *)jarg1;
41054   if (!arg1) {
41055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
41056     return 0;
41057   }
41058   {
41059     try {
41060       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
41061     } CALL_CATCH_EXCEPTION(0);
41062   }
41063
41064   jresult = (void *)result;
41065   return jresult;
41066 }
41067
41068
41069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
41070   void * jresult ;
41071   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
41072   Dali::Toolkit::PushButton *arg2 = 0 ;
41073   Dali::Toolkit::PushButton *result = 0 ;
41074
41075   arg1 = (Dali::Toolkit::PushButton *)jarg1;
41076   arg2 = (Dali::Toolkit::PushButton *)jarg2;
41077   if (!arg2) {
41078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
41079     return 0;
41080   }
41081   {
41082     try {
41083       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
41084     } CALL_CATCH_EXCEPTION(0);
41085   }
41086
41087   jresult = (void *)result;
41088   return jresult;
41089 }
41090
41091
41092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
41093   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
41094
41095   arg1 = (Dali::Toolkit::PushButton *)jarg1;
41096   {
41097     try {
41098       delete arg1;
41099     } CALL_CATCH_EXCEPTION();
41100   }
41101
41102 }
41103
41104
41105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
41106   void * jresult ;
41107   Dali::Toolkit::PushButton result;
41108
41109   {
41110     try {
41111       result = Dali::Toolkit::PushButton::New();
41112     } CALL_CATCH_EXCEPTION(0);
41113   }
41114
41115   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
41116   return jresult;
41117 }
41118
41119
41120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
41121   void * jresult ;
41122   Dali::BaseHandle arg1 ;
41123   Dali::BaseHandle *argp1 ;
41124   Dali::Toolkit::PushButton result;
41125
41126   argp1 = (Dali::BaseHandle *)jarg1;
41127   if (!argp1) {
41128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41129     return 0;
41130   }
41131   arg1 = *argp1;
41132   {
41133     try {
41134       result = Dali::Toolkit::PushButton::DownCast(arg1);
41135     } CALL_CATCH_EXCEPTION(0);
41136   }
41137
41138   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
41139   return jresult;
41140 }
41141
41142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
41143   void * jresult ;
41144   Dali::Toolkit::RadioButton *result = 0 ;
41145
41146   {
41147     try {
41148       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
41149     } CALL_CATCH_EXCEPTION(0);
41150   }
41151
41152   jresult = (void *)result;
41153   return jresult;
41154 }
41155
41156
41157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
41158   void * jresult ;
41159   Dali::Toolkit::RadioButton *arg1 = 0 ;
41160   Dali::Toolkit::RadioButton *result = 0 ;
41161
41162   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
41163   if (!arg1) {
41164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
41165     return 0;
41166   }
41167   {
41168     try {
41169       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
41170     } CALL_CATCH_EXCEPTION(0);
41171   }
41172
41173   jresult = (void *)result;
41174   return jresult;
41175 }
41176
41177
41178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
41179   void * jresult ;
41180   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
41181   Dali::Toolkit::RadioButton *arg2 = 0 ;
41182   Dali::Toolkit::RadioButton *result = 0 ;
41183
41184   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
41185   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
41186   if (!arg2) {
41187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
41188     return 0;
41189   }
41190   {
41191     try {
41192       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
41193     } CALL_CATCH_EXCEPTION(0);
41194   }
41195
41196   jresult = (void *)result;
41197   return jresult;
41198 }
41199
41200
41201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
41202   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
41203
41204   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
41205   {
41206     try {
41207       delete arg1;
41208     } CALL_CATCH_EXCEPTION();
41209   }
41210
41211 }
41212
41213
41214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
41215   void * jresult ;
41216   Dali::Toolkit::RadioButton result;
41217
41218   {
41219     try {
41220       result = Dali::Toolkit::RadioButton::New();
41221     } CALL_CATCH_EXCEPTION(0);
41222   }
41223
41224   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
41225   return jresult;
41226 }
41227
41228
41229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
41230   void * jresult ;
41231   std::string *arg1 = 0 ;
41232   Dali::Toolkit::RadioButton result;
41233
41234   if (!jarg1) {
41235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
41236     return 0;
41237   }
41238   std::string arg1_str(jarg1);
41239   arg1 = &arg1_str;
41240   {
41241     try {
41242       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
41243     } CALL_CATCH_EXCEPTION(0);
41244   }
41245
41246   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
41247
41248   //argout typemap for const std::string&
41249
41250   return jresult;
41251 }
41252
41253
41254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
41255   void * jresult ;
41256   Dali::BaseHandle arg1 ;
41257   Dali::BaseHandle *argp1 ;
41258   Dali::Toolkit::RadioButton result;
41259
41260   argp1 = (Dali::BaseHandle *)jarg1;
41261   if (!argp1) {
41262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41263     return 0;
41264   }
41265   arg1 = *argp1;
41266   {
41267     try {
41268       result = Dali::Toolkit::RadioButton::DownCast(arg1);
41269     } CALL_CATCH_EXCEPTION(0);
41270   }
41271
41272   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
41273   return jresult;
41274 }
41275
41276
41277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
41278   int jresult ;
41279   int result;
41280
41281   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
41282   jresult = (int)result;
41283   return jresult;
41284 }
41285
41286
41287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
41288   int jresult ;
41289   int result;
41290
41291   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
41292   jresult = (int)result;
41293   return jresult;
41294 }
41295
41296
41297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
41298   int jresult ;
41299   int result;
41300
41301   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
41302   jresult = (int)result;
41303   return jresult;
41304 }
41305
41306
41307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
41308   int jresult ;
41309   int result;
41310
41311   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
41312   jresult = (int)result;
41313   return jresult;
41314 }
41315
41316
41317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
41318   int jresult ;
41319   int result;
41320
41321   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
41322   jresult = (int)result;
41323   return jresult;
41324 }
41325
41326
41327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
41328   int jresult ;
41329   int result;
41330
41331   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
41332   jresult = (int)result;
41333   return jresult;
41334 }
41335
41336
41337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
41338   void * jresult ;
41339   Dali::Toolkit::FlexContainer::Property *result = 0 ;
41340
41341   {
41342     try {
41343       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
41344     } CALL_CATCH_EXCEPTION(0);
41345   }
41346
41347   jresult = (void *)result;
41348   return jresult;
41349 }
41350
41351
41352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
41353   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
41354
41355   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
41356   {
41357     try {
41358       delete arg1;
41359     } CALL_CATCH_EXCEPTION();
41360   }
41361
41362 }
41363
41364
41365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
41366   int jresult ;
41367   int result;
41368
41369   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
41370   jresult = (int)result;
41371   return jresult;
41372 }
41373
41374
41375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
41376   int jresult ;
41377   int result;
41378
41379   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
41380   jresult = (int)result;
41381   return jresult;
41382 }
41383
41384
41385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
41386   int jresult ;
41387   int result;
41388
41389   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
41390   jresult = (int)result;
41391   return jresult;
41392 }
41393
41394
41395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
41396   void * jresult ;
41397   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
41398
41399   {
41400     try {
41401       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
41402     } CALL_CATCH_EXCEPTION(0);
41403   }
41404
41405   jresult = (void *)result;
41406   return jresult;
41407 }
41408
41409
41410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
41411   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
41412
41413   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
41414   {
41415     try {
41416       delete arg1;
41417     } CALL_CATCH_EXCEPTION();
41418   }
41419
41420 }
41421
41422
41423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
41424   void * jresult ;
41425   Dali::Toolkit::FlexContainer *result = 0 ;
41426
41427   {
41428     try {
41429       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
41430     } CALL_CATCH_EXCEPTION(0);
41431   }
41432
41433   jresult = (void *)result;
41434   return jresult;
41435 }
41436
41437
41438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
41439   void * jresult ;
41440   Dali::Toolkit::FlexContainer *arg1 = 0 ;
41441   Dali::Toolkit::FlexContainer *result = 0 ;
41442
41443   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
41444   if (!arg1) {
41445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
41446     return 0;
41447   }
41448   {
41449     try {
41450       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
41451     } CALL_CATCH_EXCEPTION(0);
41452   }
41453
41454   jresult = (void *)result;
41455   return jresult;
41456 }
41457
41458
41459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
41460   void * jresult ;
41461   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
41462   Dali::Toolkit::FlexContainer *arg2 = 0 ;
41463   Dali::Toolkit::FlexContainer *result = 0 ;
41464
41465   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
41466   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
41467   if (!arg2) {
41468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
41469     return 0;
41470   }
41471   {
41472     try {
41473       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
41474     } CALL_CATCH_EXCEPTION(0);
41475   }
41476
41477   jresult = (void *)result;
41478   return jresult;
41479 }
41480
41481
41482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
41483   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
41484
41485   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
41486   {
41487     try {
41488       delete arg1;
41489     } CALL_CATCH_EXCEPTION();
41490   }
41491
41492 }
41493
41494
41495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
41496   void * jresult ;
41497   Dali::Toolkit::FlexContainer result;
41498
41499   {
41500     try {
41501       result = Dali::Toolkit::FlexContainer::New();
41502     } CALL_CATCH_EXCEPTION(0);
41503   }
41504
41505   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
41506   return jresult;
41507 }
41508
41509
41510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
41511   void * jresult ;
41512   Dali::BaseHandle arg1 ;
41513   Dali::BaseHandle *argp1 ;
41514   Dali::Toolkit::FlexContainer result;
41515
41516   argp1 = (Dali::BaseHandle *)jarg1;
41517   if (!argp1) {
41518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41519     return 0;
41520   }
41521   arg1 = *argp1;
41522   {
41523     try {
41524       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
41525     } CALL_CATCH_EXCEPTION(0);
41526   }
41527
41528   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
41529   return jresult;
41530 }
41531
41532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
41533   int jresult ;
41534   int result;
41535
41536   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
41537   jresult = (int)result;
41538   return jresult;
41539 }
41540
41541
41542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
41543   int jresult ;
41544   int result;
41545
41546   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
41547   jresult = (int)result;
41548   return jresult;
41549 }
41550
41551
41552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
41553   int jresult ;
41554   int result;
41555
41556   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
41557   jresult = (int)result;
41558   return jresult;
41559 }
41560
41561
41562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
41563   void * jresult ;
41564   Dali::Toolkit::ImageView::Property *result = 0 ;
41565
41566   {
41567     try {
41568       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
41569     } CALL_CATCH_EXCEPTION(0);
41570   }
41571
41572   jresult = (void *)result;
41573   return jresult;
41574 }
41575
41576
41577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
41578   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
41579
41580   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
41581   {
41582     try {
41583       delete arg1;
41584     } CALL_CATCH_EXCEPTION();
41585   }
41586
41587 }
41588
41589
41590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
41591   void * jresult ;
41592   Dali::Toolkit::ImageView *result = 0 ;
41593
41594   {
41595     try {
41596       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
41597     } CALL_CATCH_EXCEPTION(0);
41598   }
41599
41600   jresult = (void *)result;
41601   return jresult;
41602 }
41603
41604
41605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
41606   void * jresult ;
41607   Dali::Toolkit::ImageView result;
41608
41609   {
41610     try {
41611       result = Dali::Toolkit::ImageView::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
41612     } CALL_CATCH_EXCEPTION(0);
41613   }
41614
41615   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
41616   return jresult;
41617 }
41618
41619
41620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
41621   void * jresult ;
41622   std::string *arg1 = 0 ;
41623   Dali::Toolkit::ImageView result;
41624
41625   if (!jarg1) {
41626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
41627     return 0;
41628   }
41629   std::string arg1_str(jarg1);
41630   arg1 = &arg1_str;
41631   {
41632     try {
41633       result = Dali::Toolkit::ImageView::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS, (std::string const &)*arg1);
41634     } CALL_CATCH_EXCEPTION(0);
41635   }
41636
41637   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
41638
41639   //argout typemap for const std::string&
41640
41641   return jresult;
41642 }
41643
41644
41645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
41646   void * jresult ;
41647   std::string *arg1 = 0 ;
41648   Dali::ImageDimensions arg2 ;
41649   Dali::ImageDimensions *argp2 ;
41650   Dali::Toolkit::ImageView result;
41651
41652   if (!jarg1) {
41653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
41654     return 0;
41655   }
41656   std::string arg1_str(jarg1);
41657   arg1 = &arg1_str;
41658   argp2 = (Dali::ImageDimensions *)jarg2;
41659   if (!argp2) {
41660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41661     return 0;
41662   }
41663   arg2 = *argp2;
41664   {
41665     try {
41666       result = Dali::Toolkit::ImageView::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS, (std::string const &)*arg1,arg2);
41667     } CALL_CATCH_EXCEPTION(0);
41668   }
41669
41670   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
41671
41672   //argout typemap for const std::string&
41673
41674   return jresult;
41675 }
41676
41677
41678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
41679   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
41680
41681   arg1 = (Dali::Toolkit::ImageView *)jarg1;
41682   {
41683     try {
41684       delete arg1;
41685     } CALL_CATCH_EXCEPTION();
41686   }
41687
41688 }
41689
41690
41691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
41692   void * jresult ;
41693   Dali::Toolkit::ImageView *arg1 = 0 ;
41694   Dali::Toolkit::ImageView *result = 0 ;
41695
41696   arg1 = (Dali::Toolkit::ImageView *)jarg1;
41697   if (!arg1) {
41698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
41699     return 0;
41700   }
41701   {
41702     try {
41703       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
41704     } CALL_CATCH_EXCEPTION(0);
41705   }
41706
41707   jresult = (void *)result;
41708   return jresult;
41709 }
41710
41711
41712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
41713   void * jresult ;
41714   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
41715   Dali::Toolkit::ImageView *arg2 = 0 ;
41716   Dali::Toolkit::ImageView *result = 0 ;
41717
41718   arg1 = (Dali::Toolkit::ImageView *)jarg1;
41719   arg2 = (Dali::Toolkit::ImageView *)jarg2;
41720   if (!arg2) {
41721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
41722     return 0;
41723   }
41724   {
41725     try {
41726       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
41727     } CALL_CATCH_EXCEPTION(0);
41728   }
41729
41730   jresult = (void *)result;
41731   return jresult;
41732 }
41733
41734
41735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
41736   void * jresult ;
41737   Dali::BaseHandle arg1 ;
41738   Dali::BaseHandle *argp1 ;
41739   Dali::Toolkit::ImageView result;
41740
41741   argp1 = (Dali::BaseHandle *)jarg1;
41742   if (!argp1) {
41743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41744     return 0;
41745   }
41746   arg1 = *argp1;
41747   {
41748     try {
41749       result = Dali::Toolkit::ImageView::DownCast(arg1);
41750     } CALL_CATCH_EXCEPTION(0);
41751   }
41752
41753   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
41754   return jresult;
41755 }
41756
41757
41758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
41759   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
41760   std::string *arg2 = 0 ;
41761
41762   arg1 = (Dali::Toolkit::ImageView *)jarg1;
41763   if (!jarg2) {
41764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
41765     return ;
41766   }
41767   std::string arg2_str(jarg2);
41768   arg2 = &arg2_str;
41769   {
41770     try {
41771       (arg1)->SetImage((std::string const &)*arg2);
41772     } CALL_CATCH_EXCEPTION();
41773   }
41774
41775
41776   //argout typemap for const std::string&
41777
41778 }
41779
41780
41781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
41782   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
41783   std::string *arg2 = 0 ;
41784   Dali::ImageDimensions arg3 ;
41785   Dali::ImageDimensions *argp3 ;
41786
41787   arg1 = (Dali::Toolkit::ImageView *)jarg1;
41788   if (!jarg2) {
41789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
41790     return ;
41791   }
41792   std::string arg2_str(jarg2);
41793   arg2 = &arg2_str;
41794   argp3 = (Dali::ImageDimensions *)jarg3;
41795   if (!argp3) {
41796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41797     return ;
41798   }
41799   arg3 = *argp3;
41800   {
41801     try {
41802       (arg1)->SetImage((std::string const &)*arg2,arg3);
41803     } CALL_CATCH_EXCEPTION();
41804   }
41805
41806
41807   //argout typemap for const std::string&
41808
41809 }
41810
41811
41812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
41813   int jresult ;
41814   int result;
41815
41816   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
41817   jresult = (int)result;
41818   return jresult;
41819 }
41820
41821
41822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
41823   int jresult ;
41824   int result;
41825
41826   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
41827   jresult = (int)result;
41828   return jresult;
41829 }
41830
41831
41832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
41833   int jresult ;
41834   int result;
41835
41836   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
41837   jresult = (int)result;
41838   return jresult;
41839 }
41840
41841
41842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
41843   int jresult ;
41844   int result;
41845
41846   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
41847   jresult = (int)result;
41848   return jresult;
41849 }
41850
41851
41852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
41853   int jresult ;
41854   int result;
41855
41856   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
41857   jresult = (int)result;
41858   return jresult;
41859 }
41860
41861
41862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
41863   int jresult ;
41864   int result;
41865
41866   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
41867   jresult = (int)result;
41868   return jresult;
41869 }
41870
41871
41872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
41873   int jresult ;
41874   int result;
41875
41876   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
41877   jresult = (int)result;
41878   return jresult;
41879 }
41880
41881
41882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
41883   int jresult ;
41884   int result;
41885
41886   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
41887   jresult = (int)result;
41888   return jresult;
41889 }
41890
41891
41892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
41893   int jresult ;
41894   int result;
41895
41896   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
41897   jresult = (int)result;
41898   return jresult;
41899 }
41900
41901
41902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
41903   void * jresult ;
41904   Dali::Toolkit::ScrollBar::Property *result = 0 ;
41905
41906   {
41907     try {
41908       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
41909     } CALL_CATCH_EXCEPTION(0);
41910   }
41911
41912   jresult = (void *)result;
41913   return jresult;
41914 }
41915
41916
41917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
41918   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
41919
41920   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
41921   {
41922     try {
41923       delete arg1;
41924     } CALL_CATCH_EXCEPTION();
41925   }
41926
41927 }
41928
41929
41930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
41931   void * jresult ;
41932   Dali::Toolkit::ScrollBar *result = 0 ;
41933
41934   {
41935     try {
41936       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
41937     } CALL_CATCH_EXCEPTION(0);
41938   }
41939
41940   jresult = (void *)result;
41941   return jresult;
41942 }
41943
41944
41945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
41946   void * jresult ;
41947   Dali::Toolkit::ScrollBar *arg1 = 0 ;
41948   Dali::Toolkit::ScrollBar *result = 0 ;
41949
41950   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41951   if (!arg1) {
41952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
41953     return 0;
41954   }
41955   {
41956     try {
41957       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
41958     } CALL_CATCH_EXCEPTION(0);
41959   }
41960
41961   jresult = (void *)result;
41962   return jresult;
41963 }
41964
41965
41966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
41967   void * jresult ;
41968   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41969   Dali::Toolkit::ScrollBar *arg2 = 0 ;
41970   Dali::Toolkit::ScrollBar *result = 0 ;
41971
41972   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41973   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
41974   if (!arg2) {
41975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
41976     return 0;
41977   }
41978   {
41979     try {
41980       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
41981     } CALL_CATCH_EXCEPTION(0);
41982   }
41983
41984   jresult = (void *)result;
41985   return jresult;
41986 }
41987
41988
41989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
41990   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41991
41992   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41993   {
41994     try {
41995       delete arg1;
41996     } CALL_CATCH_EXCEPTION();
41997   }
41998
41999 }
42000
42001
42002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
42003   void * jresult ;
42004   Dali::Toolkit::ScrollBar::Direction arg1 ;
42005   Dali::Toolkit::ScrollBar result;
42006
42007   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
42008   {
42009     try {
42010       result = Dali::Toolkit::ScrollBar::New(arg1);
42011     } CALL_CATCH_EXCEPTION(0);
42012   }
42013
42014   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
42015   return jresult;
42016 }
42017
42018
42019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
42020   void * jresult ;
42021   Dali::Toolkit::ScrollBar result;
42022
42023   {
42024     try {
42025       result = Dali::Toolkit::ScrollBar::New();
42026     } CALL_CATCH_EXCEPTION(0);
42027   }
42028
42029   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
42030   return jresult;
42031 }
42032
42033
42034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
42035   void * jresult ;
42036   Dali::BaseHandle arg1 ;
42037   Dali::BaseHandle *argp1 ;
42038   Dali::Toolkit::ScrollBar result;
42039
42040   argp1 = (Dali::BaseHandle *)jarg1;
42041   if (!argp1) {
42042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42043     return 0;
42044   }
42045   arg1 = *argp1;
42046   {
42047     try {
42048       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
42049     } CALL_CATCH_EXCEPTION(0);
42050   }
42051
42052   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
42053   return jresult;
42054 }
42055
42056
42057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
42058   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42059   Dali::Handle arg2 ;
42060   Dali::Property::Index arg3 ;
42061   Dali::Property::Index arg4 ;
42062   Dali::Property::Index arg5 ;
42063   Dali::Property::Index arg6 ;
42064   Dali::Handle *argp2 ;
42065
42066   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42067   argp2 = (Dali::Handle *)jarg2;
42068   if (!argp2) {
42069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
42070     return ;
42071   }
42072   arg2 = *argp2;
42073   arg3 = (Dali::Property::Index)jarg3;
42074   arg4 = (Dali::Property::Index)jarg4;
42075   arg5 = (Dali::Property::Index)jarg5;
42076   arg6 = (Dali::Property::Index)jarg6;
42077   {
42078     try {
42079       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
42080     } CALL_CATCH_EXCEPTION();
42081   }
42082
42083 }
42084
42085
42086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
42087   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42088   Dali::Actor arg2 ;
42089   Dali::Actor *argp2 ;
42090
42091   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42092   argp2 = (Dali::Actor *)jarg2;
42093   if (!argp2) {
42094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
42095     return ;
42096   }
42097   arg2 = *argp2;
42098   {
42099     try {
42100       (arg1)->SetScrollIndicator(arg2);
42101     } CALL_CATCH_EXCEPTION();
42102   }
42103
42104 }
42105
42106
42107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
42108   void * jresult ;
42109   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42110   Dali::Actor result;
42111
42112   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42113   {
42114     try {
42115       result = (arg1)->GetScrollIndicator();
42116     } CALL_CATCH_EXCEPTION(0);
42117   }
42118
42119   jresult = new Dali::Actor((const Dali::Actor &)result);
42120   return jresult;
42121 }
42122
42123
42124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
42125   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42126   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
42127
42128   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42129   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
42130   if (!arg2) {
42131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
42132     return ;
42133   }
42134   {
42135     try {
42136       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
42137     } CALL_CATCH_EXCEPTION();
42138   }
42139
42140 }
42141
42142
42143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
42144   void * jresult ;
42145   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42146
42147   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42148   {
42149     try {
42150       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()));
42151     } CALL_CATCH_EXCEPTION(0);
42152   }
42153   return jresult;
42154 }
42155
42156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
42157   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42158   Dali::Toolkit::ScrollBar::Direction arg2 ;
42159
42160   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42161   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
42162   {
42163     try {
42164       (arg1)->SetScrollDirection(arg2);
42165     } CALL_CATCH_EXCEPTION();
42166   }
42167
42168 }
42169
42170
42171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
42172   int jresult ;
42173   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42174   Dali::Toolkit::ScrollBar::Direction result;
42175
42176   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42177   {
42178     try {
42179       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
42180     } CALL_CATCH_EXCEPTION(0);
42181   }
42182
42183   jresult = (int)result;
42184   return jresult;
42185 }
42186
42187
42188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
42189   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42190   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
42191
42192   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42193   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
42194   {
42195     try {
42196       (arg1)->SetIndicatorHeightPolicy(arg2);
42197     } CALL_CATCH_EXCEPTION();
42198   }
42199
42200 }
42201
42202
42203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
42204   int jresult ;
42205   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42206   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
42207
42208   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42209   {
42210     try {
42211       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
42212     } CALL_CATCH_EXCEPTION(0);
42213   }
42214
42215   jresult = (int)result;
42216   return jresult;
42217 }
42218
42219
42220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
42221   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42222   float arg2 ;
42223
42224   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42225   arg2 = (float)jarg2;
42226   {
42227     try {
42228       (arg1)->SetIndicatorFixedHeight(arg2);
42229     } CALL_CATCH_EXCEPTION();
42230   }
42231
42232 }
42233
42234
42235 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
42236   float jresult ;
42237   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42238   float result;
42239
42240   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42241   {
42242     try {
42243       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
42244     } CALL_CATCH_EXCEPTION(0);
42245   }
42246
42247   jresult = result;
42248   return jresult;
42249 }
42250
42251
42252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
42253   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42254   float arg2 ;
42255
42256   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42257   arg2 = (float)jarg2;
42258   {
42259     try {
42260       (arg1)->SetIndicatorShowDuration(arg2);
42261     } CALL_CATCH_EXCEPTION();
42262   }
42263
42264 }
42265
42266
42267 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
42268   float jresult ;
42269   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42270   float result;
42271
42272   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42273   {
42274     try {
42275       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
42276     } CALL_CATCH_EXCEPTION(0);
42277   }
42278
42279   jresult = result;
42280   return jresult;
42281 }
42282
42283
42284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
42285   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42286   float arg2 ;
42287
42288   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42289   arg2 = (float)jarg2;
42290   {
42291     try {
42292       (arg1)->SetIndicatorHideDuration(arg2);
42293     } CALL_CATCH_EXCEPTION();
42294   }
42295
42296 }
42297
42298
42299 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
42300   float jresult ;
42301   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42302   float result;
42303
42304   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42305   {
42306     try {
42307       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
42308     } CALL_CATCH_EXCEPTION(0);
42309   }
42310
42311   jresult = result;
42312   return jresult;
42313 }
42314
42315
42316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
42317   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42318
42319   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42320   {
42321     try {
42322       (arg1)->ShowIndicator();
42323     } CALL_CATCH_EXCEPTION();
42324   }
42325
42326 }
42327
42328
42329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
42330   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42331
42332   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42333   {
42334     try {
42335       (arg1)->HideIndicator();
42336     } CALL_CATCH_EXCEPTION();
42337   }
42338
42339 }
42340
42341
42342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
42343   void * jresult ;
42344   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42345   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
42346
42347   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42348   {
42349     try {
42350       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
42351     } CALL_CATCH_EXCEPTION(0);
42352   }
42353
42354   jresult = (void *)result;
42355   return jresult;
42356 }
42357
42358
42359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
42360   void * jresult ;
42361   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42362   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
42363
42364   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42365   {
42366     try {
42367       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
42368     } CALL_CATCH_EXCEPTION(0);
42369   }
42370
42371   jresult = (void *)result;
42372   return jresult;
42373 }
42374
42375
42376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
42377   int jresult ;
42378   int result;
42379
42380   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
42381   jresult = (int)result;
42382   return jresult;
42383 }
42384
42385
42386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
42387   int jresult ;
42388   int result;
42389
42390   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
42391   jresult = (int)result;
42392   return jresult;
42393 }
42394
42395
42396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
42397   int jresult ;
42398   int result;
42399
42400   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
42401   jresult = (int)result;
42402   return jresult;
42403 }
42404
42405
42406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
42407   int jresult ;
42408   int result;
42409
42410   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
42411   jresult = (int)result;
42412   return jresult;
42413 }
42414
42415
42416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
42417   int jresult ;
42418   int result;
42419
42420   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
42421   jresult = (int)result;
42422   return jresult;
42423 }
42424
42425
42426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
42427   int jresult ;
42428   int result;
42429
42430   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
42431   jresult = (int)result;
42432   return jresult;
42433 }
42434
42435
42436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
42437   int jresult ;
42438   int result;
42439
42440   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
42441   jresult = (int)result;
42442   return jresult;
42443 }
42444
42445
42446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
42447   int jresult ;
42448   int result;
42449
42450   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
42451   jresult = (int)result;
42452   return jresult;
42453 }
42454
42455
42456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
42457   int jresult ;
42458   int result;
42459
42460   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
42461   jresult = (int)result;
42462   return jresult;
42463 }
42464
42465
42466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
42467   int jresult ;
42468   int result;
42469
42470   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
42471   jresult = (int)result;
42472   return jresult;
42473 }
42474
42475
42476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
42477   int jresult ;
42478   int result;
42479
42480   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
42481   jresult = (int)result;
42482   return jresult;
42483 }
42484
42485
42486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
42487   int jresult ;
42488   int result;
42489
42490   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
42491   jresult = (int)result;
42492   return jresult;
42493 }
42494
42495
42496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
42497   int jresult ;
42498   int result;
42499
42500   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
42501   jresult = (int)result;
42502   return jresult;
42503 }
42504
42505
42506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
42507   int jresult ;
42508   int result;
42509
42510   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
42511   jresult = (int)result;
42512   return jresult;
42513 }
42514
42515
42516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
42517   void * jresult ;
42518   Dali::Toolkit::Scrollable::Property *result = 0 ;
42519
42520   {
42521     try {
42522       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
42523     } CALL_CATCH_EXCEPTION(0);
42524   }
42525
42526   jresult = (void *)result;
42527   return jresult;
42528 }
42529
42530
42531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
42532   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
42533
42534   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
42535   {
42536     try {
42537       delete arg1;
42538     } CALL_CATCH_EXCEPTION();
42539   }
42540
42541 }
42542
42543
42544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
42545   void * jresult ;
42546   Dali::Toolkit::Scrollable *result = 0 ;
42547
42548   {
42549     try {
42550       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
42551     } CALL_CATCH_EXCEPTION(0);
42552   }
42553
42554   jresult = (void *)result;
42555   return jresult;
42556 }
42557
42558
42559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
42560   void * jresult ;
42561   Dali::Toolkit::Scrollable *arg1 = 0 ;
42562   Dali::Toolkit::Scrollable *result = 0 ;
42563
42564   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
42565   if (!arg1) {
42566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
42567     return 0;
42568   }
42569   {
42570     try {
42571       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
42572     } CALL_CATCH_EXCEPTION(0);
42573   }
42574
42575   jresult = (void *)result;
42576   return jresult;
42577 }
42578
42579
42580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
42581   void * jresult ;
42582   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
42583   Dali::Toolkit::Scrollable *arg2 = 0 ;
42584   Dali::Toolkit::Scrollable *result = 0 ;
42585
42586   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
42587   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
42588   if (!arg2) {
42589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
42590     return 0;
42591   }
42592   {
42593     try {
42594       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
42595     } CALL_CATCH_EXCEPTION(0);
42596   }
42597
42598   jresult = (void *)result;
42599   return jresult;
42600 }
42601
42602
42603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
42604   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
42605
42606   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
42607   {
42608     try {
42609       delete arg1;
42610     } CALL_CATCH_EXCEPTION();
42611   }
42612
42613 }
42614
42615
42616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
42617   void * jresult ;
42618   Dali::BaseHandle arg1 ;
42619   Dali::BaseHandle *argp1 ;
42620   Dali::Toolkit::Scrollable result;
42621
42622   argp1 = (Dali::BaseHandle *)jarg1;
42623   if (!argp1) {
42624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42625     return 0;
42626   }
42627   arg1 = *argp1;
42628   {
42629     try {
42630       result = Dali::Toolkit::Scrollable::DownCast(arg1);
42631     } CALL_CATCH_EXCEPTION(0);
42632   }
42633
42634   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
42635   return jresult;
42636 }
42637
42638
42639 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
42640   bool jresult ;
42641   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
42642   bool result;
42643
42644   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
42645   {
42646     try {
42647       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
42648     } CALL_CATCH_EXCEPTION(0);
42649   }
42650
42651   jresult = result;
42652   return jresult;
42653 }
42654
42655
42656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, bool jarg2) {
42657   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
42658   bool arg2 ;
42659
42660   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
42661   arg2 = jarg2 ? true : false;
42662   {
42663     try {
42664       (arg1)->SetOvershootEnabled(arg2);
42665     } CALL_CATCH_EXCEPTION();
42666   }
42667
42668 }
42669
42670
42671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
42672   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
42673   Dali::Vector4 *arg2 = 0 ;
42674
42675   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
42676   arg2 = (Dali::Vector4 *)jarg2;
42677   if (!arg2) {
42678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
42679     return ;
42680   }
42681   {
42682     try {
42683       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
42684     } CALL_CATCH_EXCEPTION();
42685   }
42686
42687 }
42688
42689
42690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
42691   void * jresult ;
42692   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
42693   Dali::Vector4 result;
42694
42695   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
42696   {
42697     try {
42698       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
42699     } CALL_CATCH_EXCEPTION(0);
42700   }
42701
42702   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42703   return jresult;
42704 }
42705
42706
42707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
42708   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
42709   float arg2 ;
42710
42711   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
42712   arg2 = (float)jarg2;
42713   {
42714     try {
42715       (arg1)->SetOvershootAnimationSpeed(arg2);
42716     } CALL_CATCH_EXCEPTION();
42717   }
42718
42719 }
42720
42721
42722 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
42723   float jresult ;
42724   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
42725   float result;
42726
42727   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
42728   {
42729     try {
42730       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
42731     } CALL_CATCH_EXCEPTION(0);
42732   }
42733
42734   jresult = result;
42735   return jresult;
42736 }
42737
42738
42739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
42740   void * jresult ;
42741   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
42742   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
42743
42744   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
42745   {
42746     try {
42747       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
42748     } CALL_CATCH_EXCEPTION(0);
42749   }
42750
42751   jresult = (void *)result;
42752   return jresult;
42753 }
42754
42755
42756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
42757   void * jresult ;
42758   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
42759   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
42760
42761   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
42762   {
42763     try {
42764       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
42765     } CALL_CATCH_EXCEPTION(0);
42766   }
42767
42768   jresult = (void *)result;
42769   return jresult;
42770 }
42771
42772
42773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
42774   void * jresult ;
42775   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
42776   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
42777
42778   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
42779   {
42780     try {
42781       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
42782     } CALL_CATCH_EXCEPTION(0);
42783   }
42784
42785   jresult = (void *)result;
42786   return jresult;
42787 }
42788
42789
42790 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
42791   bool jresult ;
42792   Dali::Toolkit::ControlOrientation::Type arg1 ;
42793   bool result;
42794
42795   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
42796   {
42797     try {
42798       result = (bool)Dali::Toolkit::IsVertical(arg1);
42799     } CALL_CATCH_EXCEPTION(0);
42800   }
42801
42802   jresult = result;
42803   return jresult;
42804 }
42805
42806
42807 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
42808   bool jresult ;
42809   Dali::Toolkit::ControlOrientation::Type arg1 ;
42810   bool result;
42811
42812   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
42813   {
42814     try {
42815       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
42816     } CALL_CATCH_EXCEPTION(0);
42817   }
42818
42819   jresult = result;
42820   return jresult;
42821 }
42822
42823
42824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
42825   void * jresult ;
42826   unsigned int arg1 ;
42827   unsigned int arg2 ;
42828   Dali::Toolkit::ItemRange *result = 0 ;
42829
42830   arg1 = (unsigned int)jarg1;
42831   arg2 = (unsigned int)jarg2;
42832   {
42833     try {
42834       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
42835     } CALL_CATCH_EXCEPTION(0);
42836   }
42837
42838   jresult = (void *)result;
42839   return jresult;
42840 }
42841
42842
42843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
42844   void * jresult ;
42845   Dali::Toolkit::ItemRange *arg1 = 0 ;
42846   Dali::Toolkit::ItemRange *result = 0 ;
42847
42848   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
42849   if (!arg1) {
42850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
42851     return 0;
42852   }
42853   {
42854     try {
42855       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
42856     } CALL_CATCH_EXCEPTION(0);
42857   }
42858
42859   jresult = (void *)result;
42860   return jresult;
42861 }
42862
42863
42864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
42865   void * jresult ;
42866   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
42867   Dali::Toolkit::ItemRange *arg2 = 0 ;
42868   Dali::Toolkit::ItemRange *result = 0 ;
42869
42870   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
42871   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
42872   if (!arg2) {
42873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
42874     return 0;
42875   }
42876   {
42877     try {
42878       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
42879     } CALL_CATCH_EXCEPTION(0);
42880   }
42881
42882   jresult = (void *)result;
42883   return jresult;
42884 }
42885
42886
42887 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
42888   bool jresult ;
42889   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
42890   unsigned int arg2 ;
42891   bool result;
42892
42893   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
42894   arg2 = (unsigned int)jarg2;
42895   {
42896     try {
42897       result = (bool)(arg1)->Within(arg2);
42898     } CALL_CATCH_EXCEPTION(0);
42899   }
42900
42901   jresult = result;
42902   return jresult;
42903 }
42904
42905
42906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
42907   void * jresult ;
42908   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
42909   Dali::Toolkit::ItemRange *arg2 = 0 ;
42910   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
42911
42912   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
42913   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
42914   if (!arg2) {
42915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
42916     return 0;
42917   }
42918   {
42919     try {
42920       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
42921     } CALL_CATCH_EXCEPTION(0);
42922   }
42923
42924   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
42925   return jresult;
42926 }
42927
42928
42929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
42930   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
42931   unsigned int arg2 ;
42932
42933   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
42934   arg2 = (unsigned int)jarg2;
42935   if (arg1) (arg1)->begin = arg2;
42936 }
42937
42938
42939 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
42940   unsigned int jresult ;
42941   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
42942   unsigned int result;
42943
42944   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
42945   result = (unsigned int) ((arg1)->begin);
42946   jresult = result;
42947   return jresult;
42948 }
42949
42950
42951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
42952   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
42953   unsigned int arg2 ;
42954
42955   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
42956   arg2 = (unsigned int)jarg2;
42957   if (arg1) (arg1)->end = arg2;
42958 }
42959
42960
42961 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
42962   unsigned int jresult ;
42963   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
42964   unsigned int result;
42965
42966   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
42967   result = (unsigned int) ((arg1)->end);
42968   jresult = result;
42969   return jresult;
42970 }
42971
42972
42973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
42974   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
42975
42976   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
42977   {
42978     try {
42979       delete arg1;
42980     } CALL_CATCH_EXCEPTION();
42981   }
42982
42983 }
42984
42985
42986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
42987   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42988
42989   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42990   {
42991     try {
42992       delete arg1;
42993     } CALL_CATCH_EXCEPTION();
42994   }
42995
42996 }
42997
42998
42999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
43000   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43001   Dali::Toolkit::ControlOrientation::Type arg2 ;
43002
43003   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43004   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
43005   {
43006     try {
43007       (arg1)->SetOrientation(arg2);
43008     } CALL_CATCH_EXCEPTION();
43009   }
43010
43011 }
43012
43013
43014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
43015   int jresult ;
43016   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43017   Dali::Toolkit::ControlOrientation::Type result;
43018
43019   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43020   {
43021     try {
43022       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
43023     } CALL_CATCH_EXCEPTION(0);
43024   }
43025
43026   jresult = (int)result;
43027   return jresult;
43028 }
43029
43030
43031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
43032   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43033   Dali::Property::Map *arg2 = 0 ;
43034
43035   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43036   arg2 = (Dali::Property::Map *)jarg2;
43037   if (!arg2) {
43038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
43039     return ;
43040   }
43041   {
43042     try {
43043       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
43044     } CALL_CATCH_EXCEPTION();
43045   }
43046
43047 }
43048
43049
43050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
43051   void * jresult ;
43052   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43053   Dali::Property::Map result;
43054
43055   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43056   {
43057     try {
43058       result = (arg1)->GetLayoutProperties();
43059     } CALL_CATCH_EXCEPTION(0);
43060   }
43061
43062   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
43063   return jresult;
43064 }
43065
43066
43067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
43068   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43069   unsigned int arg2 ;
43070   Dali::Vector3 *arg3 = 0 ;
43071   Dali::Vector3 *arg4 = 0 ;
43072
43073   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43074   arg2 = (unsigned int)jarg2;
43075   arg3 = (Dali::Vector3 *)jarg3;
43076   if (!arg3) {
43077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43078     return ;
43079   }
43080   arg4 = (Dali::Vector3 *)jarg4;
43081   if (!arg4) {
43082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43083     return ;
43084   }
43085   {
43086     try {
43087       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
43088     } CALL_CATCH_EXCEPTION();
43089   }
43090
43091 }
43092
43093
43094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
43095   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43096   Dali::Vector3 *arg2 = 0 ;
43097
43098   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43099   arg2 = (Dali::Vector3 *)jarg2;
43100   if (!arg2) {
43101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43102     return ;
43103   }
43104   {
43105     try {
43106       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
43107     } CALL_CATCH_EXCEPTION();
43108   }
43109
43110 }
43111
43112
43113 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
43114   float jresult ;
43115   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43116   unsigned int arg2 ;
43117   Dali::Vector3 arg3 ;
43118   Dali::Vector3 *argp3 ;
43119   float result;
43120
43121   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43122   arg2 = (unsigned int)jarg2;
43123   argp3 = (Dali::Vector3 *)jarg3;
43124   if (!argp3) {
43125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
43126     return 0;
43127   }
43128   arg3 = *argp3;
43129   {
43130     try {
43131       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
43132     } CALL_CATCH_EXCEPTION(0);
43133   }
43134
43135   jresult = result;
43136   return jresult;
43137 }
43138
43139
43140 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
43141   float jresult ;
43142   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43143   float arg2 ;
43144   float result;
43145
43146   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43147   arg2 = (float)jarg2;
43148   {
43149     try {
43150       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
43151     } CALL_CATCH_EXCEPTION(0);
43152   }
43153
43154   jresult = result;
43155   return jresult;
43156 }
43157
43158
43159 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
43160   float jresult ;
43161   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43162   unsigned int arg2 ;
43163   float result;
43164
43165   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43166   arg2 = (unsigned int)jarg2;
43167   {
43168     try {
43169       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
43170     } CALL_CATCH_EXCEPTION(0);
43171   }
43172
43173   jresult = result;
43174   return jresult;
43175 }
43176
43177
43178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
43179   void * jresult ;
43180   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43181   float arg2 ;
43182   Dali::Vector3 arg3 ;
43183   Dali::Vector3 *argp3 ;
43184   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
43185
43186   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43187   arg2 = (float)jarg2;
43188   argp3 = (Dali::Vector3 *)jarg3;
43189   if (!argp3) {
43190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
43191     return 0;
43192   }
43193   arg3 = *argp3;
43194   {
43195     try {
43196       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
43197     } CALL_CATCH_EXCEPTION(0);
43198   }
43199
43200   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
43201   return jresult;
43202 }
43203
43204
43205 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
43206   float jresult ;
43207   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43208   int arg2 ;
43209   float arg3 ;
43210   Dali::Vector3 *arg4 = 0 ;
43211   float result;
43212
43213   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43214   arg2 = (int)jarg2;
43215   arg3 = (float)jarg3;
43216   arg4 = (Dali::Vector3 *)jarg4;
43217   if (!arg4) {
43218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43219     return 0;
43220   }
43221   {
43222     try {
43223       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
43224     } CALL_CATCH_EXCEPTION(0);
43225   }
43226
43227   jresult = result;
43228   return jresult;
43229 }
43230
43231
43232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
43233   unsigned int jresult ;
43234   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43235   Dali::Vector3 arg2 ;
43236   Dali::Vector3 *argp2 ;
43237   unsigned int result;
43238
43239   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43240   argp2 = (Dali::Vector3 *)jarg2;
43241   if (!argp2) {
43242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
43243     return 0;
43244   }
43245   arg2 = *argp2;
43246   {
43247     try {
43248       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
43249     } CALL_CATCH_EXCEPTION(0);
43250   }
43251
43252   jresult = result;
43253   return jresult;
43254 }
43255
43256
43257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
43258   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43259   unsigned int arg2 ;
43260   Dali::Vector3 *arg3 = 0 ;
43261   Dali::Vector3 *arg4 = 0 ;
43262
43263   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43264   arg2 = (unsigned int)jarg2;
43265   arg3 = (Dali::Vector3 *)jarg3;
43266   if (!arg3) {
43267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43268     return ;
43269   }
43270   arg4 = (Dali::Vector3 *)jarg4;
43271   if (!arg4) {
43272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43273     return ;
43274   }
43275   {
43276     try {
43277       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
43278     } CALL_CATCH_EXCEPTION();
43279   }
43280
43281 }
43282
43283
43284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
43285   void * jresult ;
43286   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43287   Dali::Degree result;
43288
43289   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43290   {
43291     try {
43292       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
43293     } CALL_CATCH_EXCEPTION(0);
43294   }
43295
43296   jresult = new Dali::Degree((const Dali::Degree &)result);
43297   return jresult;
43298 }
43299
43300
43301 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
43302   float jresult ;
43303   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43304   float result;
43305
43306   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43307   {
43308     try {
43309       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
43310     } CALL_CATCH_EXCEPTION(0);
43311   }
43312
43313   jresult = result;
43314   return jresult;
43315 }
43316
43317
43318 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
43319   float jresult ;
43320   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43321   float result;
43322
43323   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43324   {
43325     try {
43326       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
43327     } CALL_CATCH_EXCEPTION(0);
43328   }
43329
43330   jresult = result;
43331   return jresult;
43332 }
43333
43334
43335 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
43336   float jresult ;
43337   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43338   float result;
43339
43340   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43341   {
43342     try {
43343       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
43344     } CALL_CATCH_EXCEPTION(0);
43345   }
43346
43347   jresult = result;
43348   return jresult;
43349 }
43350
43351
43352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, bool jarg5) {
43353   int jresult ;
43354   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43355   int arg2 ;
43356   int arg3 ;
43357   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
43358   bool arg5 ;
43359   int result;
43360
43361   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43362   arg2 = (int)jarg2;
43363   arg3 = (int)jarg3;
43364   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
43365   arg5 = jarg5 ? true : false;
43366   {
43367     try {
43368       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
43369     } CALL_CATCH_EXCEPTION(0);
43370   }
43371
43372   jresult = result;
43373   return jresult;
43374 }
43375
43376
43377 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
43378   float jresult ;
43379   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43380   float result;
43381
43382   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43383   {
43384     try {
43385       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
43386     } CALL_CATCH_EXCEPTION(0);
43387   }
43388
43389   jresult = result;
43390   return jresult;
43391 }
43392
43393
43394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
43395   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43396   Dali::Actor *arg2 = 0 ;
43397   int arg3 ;
43398   Dali::Vector3 *arg4 = 0 ;
43399   Dali::Actor *arg5 = 0 ;
43400
43401   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43402   arg2 = (Dali::Actor *)jarg2;
43403   if (!arg2) {
43404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
43405     return ;
43406   }
43407   arg3 = (int)jarg3;
43408   arg4 = (Dali::Vector3 *)jarg4;
43409   if (!arg4) {
43410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43411     return ;
43412   }
43413   arg5 = (Dali::Actor *)jarg5;
43414   if (!arg5) {
43415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
43416     return ;
43417   }
43418   {
43419     try {
43420       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
43421     } CALL_CATCH_EXCEPTION();
43422   }
43423
43424 }
43425
43426
43427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
43428   void * jresult ;
43429   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43430   int arg2 ;
43431   float arg3 ;
43432   Dali::Vector3 *arg4 = 0 ;
43433   Dali::Vector3 result;
43434
43435   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43436   arg2 = (int)jarg2;
43437   arg3 = (float)jarg3;
43438   arg4 = (Dali::Vector3 *)jarg4;
43439   if (!arg4) {
43440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43441     return 0;
43442   }
43443   {
43444     try {
43445       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
43446     } CALL_CATCH_EXCEPTION(0);
43447   }
43448
43449   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
43450   return jresult;
43451 }
43452
43453
43454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
43455   void * jresult ;
43456   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
43457   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
43458
43459   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
43460   {
43461     try {
43462       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
43463     } CALL_CATCH_EXCEPTION(0);
43464   }
43465
43466   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
43467   return jresult;
43468 }
43469
43470
43471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
43472   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
43473
43474   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
43475   {
43476     try {
43477       delete arg1;
43478     } CALL_CATCH_EXCEPTION();
43479   }
43480
43481 }
43482
43483
43484 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
43485   unsigned int jresult ;
43486   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
43487   unsigned int result;
43488
43489   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
43490   {
43491     try {
43492       result = (unsigned int)(arg1)->GetNumberOfItems();
43493     } CALL_CATCH_EXCEPTION(0);
43494   }
43495
43496   jresult = result;
43497   return jresult;
43498 }
43499
43500
43501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
43502   void * jresult ;
43503   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
43504   unsigned int arg2 ;
43505   Dali::Actor result;
43506
43507   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
43508   arg2 = (unsigned int)jarg2;
43509   {
43510     try {
43511       result = (arg1)->NewItem(arg2);
43512     } CALL_CATCH_EXCEPTION(0);
43513   }
43514
43515   jresult = new Dali::Actor((const Dali::Actor &)result);
43516   return jresult;
43517 }
43518
43519
43520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
43521   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
43522   unsigned int arg2 ;
43523   Dali::Actor arg3 ;
43524   Dali::Actor *argp3 ;
43525
43526   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
43527   arg2 = (unsigned int)jarg2;
43528   argp3 = (Dali::Actor *)jarg3;
43529   if (!argp3) {
43530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
43531     return ;
43532   }
43533   arg3 = *argp3;
43534   {
43535     try {
43536       (arg1)->ItemReleased(arg2,arg3);
43537     } CALL_CATCH_EXCEPTION();
43538   }
43539
43540 }
43541
43542
43543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
43544   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
43545   unsigned int arg2 ;
43546   Dali::Actor arg3 ;
43547   Dali::Actor *argp3 ;
43548
43549   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
43550   arg2 = (unsigned int)jarg2;
43551   argp3 = (Dali::Actor *)jarg3;
43552   if (!argp3) {
43553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
43554     return ;
43555   }
43556   arg3 = *argp3;
43557   {
43558     try {
43559       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
43560     } CALL_CATCH_EXCEPTION();
43561   }
43562
43563 }
43564
43565
43566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
43567   void * jresult ;
43568   Dali::Toolkit::ItemFactory *result = 0 ;
43569
43570   {
43571     try {
43572       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
43573     } CALL_CATCH_EXCEPTION(0);
43574   }
43575
43576   jresult = (void *)result;
43577   return jresult;
43578 }
43579
43580
43581 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) {
43582   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
43583   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
43584   if (director) {
43585     director->swig_connect_director(callback0, callback1, callback2);
43586   }
43587 }
43588
43589
43590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
43591   int jresult ;
43592   int result;
43593
43594   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
43595   jresult = (int)result;
43596   return jresult;
43597 }
43598
43599
43600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
43601   int jresult ;
43602   int result;
43603
43604   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
43605   jresult = (int)result;
43606   return jresult;
43607 }
43608
43609
43610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
43611   int jresult ;
43612   int result;
43613
43614   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
43615   jresult = (int)result;
43616   return jresult;
43617 }
43618
43619
43620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
43621   int jresult ;
43622   int result;
43623
43624   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
43625   jresult = (int)result;
43626   return jresult;
43627 }
43628
43629
43630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
43631   int jresult ;
43632   int result;
43633
43634   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
43635   jresult = (int)result;
43636   return jresult;
43637 }
43638
43639
43640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
43641   int jresult ;
43642   int result;
43643
43644   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
43645   jresult = (int)result;
43646   return jresult;
43647 }
43648
43649
43650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
43651   int jresult ;
43652   int result;
43653
43654   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
43655   jresult = (int)result;
43656   return jresult;
43657 }
43658
43659
43660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
43661   int jresult ;
43662   int result;
43663
43664   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
43665   jresult = (int)result;
43666   return jresult;
43667 }
43668
43669
43670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
43671   int jresult ;
43672   int result;
43673
43674   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
43675   jresult = (int)result;
43676   return jresult;
43677 }
43678
43679
43680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
43681   int jresult ;
43682   int result;
43683
43684   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
43685   jresult = (int)result;
43686   return jresult;
43687 }
43688
43689
43690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
43691   int jresult ;
43692   int result;
43693
43694   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
43695   jresult = (int)result;
43696   return jresult;
43697 }
43698
43699
43700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
43701   void * jresult ;
43702   Dali::Toolkit::ItemView::Property *result = 0 ;
43703
43704   {
43705     try {
43706       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
43707     } CALL_CATCH_EXCEPTION(0);
43708   }
43709
43710   jresult = (void *)result;
43711   return jresult;
43712 }
43713
43714
43715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
43716   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
43717
43718   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
43719   {
43720     try {
43721       delete arg1;
43722     } CALL_CATCH_EXCEPTION();
43723   }
43724
43725 }
43726
43727
43728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
43729   void * jresult ;
43730   Dali::Toolkit::ItemView *result = 0 ;
43731
43732   {
43733     try {
43734       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
43735     } CALL_CATCH_EXCEPTION(0);
43736   }
43737
43738   jresult = (void *)result;
43739   return jresult;
43740 }
43741
43742
43743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
43744   void * jresult ;
43745   Dali::Toolkit::ItemView *arg1 = 0 ;
43746   Dali::Toolkit::ItemView *result = 0 ;
43747
43748   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43749   if (!arg1) {
43750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
43751     return 0;
43752   }
43753   {
43754     try {
43755       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
43756     } CALL_CATCH_EXCEPTION(0);
43757   }
43758
43759   jresult = (void *)result;
43760   return jresult;
43761 }
43762
43763
43764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
43765   void * jresult ;
43766   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43767   Dali::Toolkit::ItemView *arg2 = 0 ;
43768   Dali::Toolkit::ItemView *result = 0 ;
43769
43770   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43771   arg2 = (Dali::Toolkit::ItemView *)jarg2;
43772   if (!arg2) {
43773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
43774     return 0;
43775   }
43776   {
43777     try {
43778       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
43779     } CALL_CATCH_EXCEPTION(0);
43780   }
43781
43782   jresult = (void *)result;
43783   return jresult;
43784 }
43785
43786
43787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
43788   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43789
43790   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43791   {
43792     try {
43793       delete arg1;
43794     } CALL_CATCH_EXCEPTION();
43795   }
43796
43797 }
43798
43799
43800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
43801   void * jresult ;
43802   Dali::Toolkit::ItemFactory *arg1 = 0 ;
43803   Dali::Toolkit::ItemView result;
43804
43805   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
43806   if (!arg1) {
43807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
43808     return 0;
43809   }
43810   {
43811     try {
43812       result = Dali::Toolkit::ItemView::New(*arg1);
43813     } CALL_CATCH_EXCEPTION(0);
43814   }
43815
43816   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
43817   return jresult;
43818 }
43819
43820
43821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
43822   void * jresult ;
43823   Dali::BaseHandle arg1 ;
43824   Dali::BaseHandle *argp1 ;
43825   Dali::Toolkit::ItemView result;
43826
43827   argp1 = (Dali::BaseHandle *)jarg1;
43828   if (!argp1) {
43829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43830     return 0;
43831   }
43832   arg1 = *argp1;
43833   {
43834     try {
43835       result = Dali::Toolkit::ItemView::DownCast(arg1);
43836     } CALL_CATCH_EXCEPTION(0);
43837   }
43838
43839   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
43840   return jresult;
43841 }
43842
43843
43844 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
43845   unsigned int jresult ;
43846   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43847   unsigned int result;
43848
43849   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43850   {
43851     try {
43852       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
43853     } CALL_CATCH_EXCEPTION(0);
43854   }
43855
43856   jresult = result;
43857   return jresult;
43858 }
43859
43860
43861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
43862   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43863   Dali::Toolkit::ItemLayout *arg2 = 0 ;
43864
43865   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43866   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
43867   if (!arg2) {
43868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
43869     return ;
43870   }
43871   {
43872     try {
43873       (arg1)->AddLayout(*arg2);
43874     } CALL_CATCH_EXCEPTION();
43875   }
43876
43877 }
43878
43879
43880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
43881   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43882   unsigned int arg2 ;
43883
43884   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43885   arg2 = (unsigned int)jarg2;
43886   {
43887     try {
43888       (arg1)->RemoveLayout(arg2);
43889     } CALL_CATCH_EXCEPTION();
43890   }
43891
43892 }
43893
43894
43895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
43896   void * jresult ;
43897   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43898   unsigned int arg2 ;
43899   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
43900
43901   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43902   arg2 = (unsigned int)jarg2;
43903   {
43904     try {
43905       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
43906     } CALL_CATCH_EXCEPTION(0);
43907   }
43908
43909   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
43910   return jresult;
43911 }
43912
43913
43914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
43915   void * jresult ;
43916   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43917   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
43918
43919   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43920   {
43921     try {
43922       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
43923     } CALL_CATCH_EXCEPTION(0);
43924   }
43925
43926   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
43927   return jresult;
43928 }
43929
43930
43931 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
43932   float jresult ;
43933   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43934   Dali::Toolkit::ItemId arg2 ;
43935   float result;
43936
43937   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43938   arg2 = (Dali::Toolkit::ItemId)jarg2;
43939   {
43940     try {
43941       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
43942     } CALL_CATCH_EXCEPTION(0);
43943   }
43944
43945   jresult = result;
43946   return jresult;
43947 }
43948
43949
43950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
43951   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43952   unsigned int arg2 ;
43953   Dali::Vector3 arg3 ;
43954   float arg4 ;
43955   Dali::Vector3 *argp3 ;
43956
43957   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43958   arg2 = (unsigned int)jarg2;
43959   argp3 = (Dali::Vector3 *)jarg3;
43960   if (!argp3) {
43961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
43962     return ;
43963   }
43964   arg3 = *argp3;
43965   arg4 = (float)jarg4;
43966   {
43967     try {
43968       (arg1)->ActivateLayout(arg2,arg3,arg4);
43969     } CALL_CATCH_EXCEPTION();
43970   }
43971
43972 }
43973
43974
43975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
43976   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43977
43978   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43979   {
43980     try {
43981       (arg1)->DeactivateCurrentLayout();
43982     } CALL_CATCH_EXCEPTION();
43983   }
43984
43985 }
43986
43987
43988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
43989   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43990   float arg2 ;
43991
43992   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43993   arg2 = (float)jarg2;
43994   {
43995     try {
43996       (arg1)->SetMinimumSwipeSpeed(arg2);
43997     } CALL_CATCH_EXCEPTION();
43998   }
43999
44000 }
44001
44002
44003 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
44004   float jresult ;
44005   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44006   float result;
44007
44008   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44009   {
44010     try {
44011       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
44012     } CALL_CATCH_EXCEPTION(0);
44013   }
44014
44015   jresult = result;
44016   return jresult;
44017 }
44018
44019
44020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
44021   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44022   float arg2 ;
44023
44024   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44025   arg2 = (float)jarg2;
44026   {
44027     try {
44028       (arg1)->SetMinimumSwipeDistance(arg2);
44029     } CALL_CATCH_EXCEPTION();
44030   }
44031
44032 }
44033
44034
44035 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
44036   float jresult ;
44037   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44038   float result;
44039
44040   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44041   {
44042     try {
44043       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
44044     } CALL_CATCH_EXCEPTION(0);
44045   }
44046
44047   jresult = result;
44048   return jresult;
44049 }
44050
44051
44052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
44053   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44054   float arg2 ;
44055
44056   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44057   arg2 = (float)jarg2;
44058   {
44059     try {
44060       (arg1)->SetWheelScrollDistanceStep(arg2);
44061     } CALL_CATCH_EXCEPTION();
44062   }
44063
44064 }
44065
44066
44067 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
44068   float jresult ;
44069   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44070   float result;
44071
44072   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44073   {
44074     try {
44075       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
44076     } CALL_CATCH_EXCEPTION(0);
44077   }
44078
44079   jresult = result;
44080   return jresult;
44081 }
44082
44083
44084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, bool jarg2) {
44085   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44086   bool arg2 ;
44087
44088   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44089   arg2 = jarg2 ? true : false;
44090   {
44091     try {
44092       (arg1)->SetAnchoring(arg2);
44093     } CALL_CATCH_EXCEPTION();
44094   }
44095
44096 }
44097
44098 //// ========================= end of part 3 =============================
44099
44100 //// ========================== start part 4 ===============================
44101
44102
44103 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
44104   bool jresult ;
44105   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44106   bool result;
44107
44108   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44109   {
44110     try {
44111       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
44112     } CALL_CATCH_EXCEPTION(0);
44113   }
44114
44115   jresult = result;
44116   return jresult;
44117 }
44118
44119
44120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
44121   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44122   float arg2 ;
44123
44124   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44125   arg2 = (float)jarg2;
44126   {
44127     try {
44128       (arg1)->SetAnchoringDuration(arg2);
44129     } CALL_CATCH_EXCEPTION();
44130   }
44131
44132 }
44133
44134
44135 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
44136   float jresult ;
44137   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44138   float result;
44139
44140   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44141   {
44142     try {
44143       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
44144     } CALL_CATCH_EXCEPTION(0);
44145   }
44146
44147   jresult = result;
44148   return jresult;
44149 }
44150
44151
44152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
44153   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44154   Dali::Toolkit::ItemId arg2 ;
44155   float arg3 ;
44156
44157   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44158   arg2 = (Dali::Toolkit::ItemId)jarg2;
44159   arg3 = (float)jarg3;
44160   {
44161     try {
44162       (arg1)->ScrollToItem(arg2,arg3);
44163     } CALL_CATCH_EXCEPTION();
44164   }
44165
44166 }
44167
44168
44169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
44170   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44171   float arg2 ;
44172
44173   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44174   arg2 = (float)jarg2;
44175   {
44176     try {
44177       (arg1)->SetRefreshInterval(arg2);
44178     } CALL_CATCH_EXCEPTION();
44179   }
44180
44181 }
44182
44183
44184 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
44185   float jresult ;
44186   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44187   float result;
44188
44189   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44190   {
44191     try {
44192       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
44193     } CALL_CATCH_EXCEPTION(0);
44194   }
44195
44196   jresult = result;
44197   return jresult;
44198 }
44199
44200
44201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
44202   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44203
44204   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44205   {
44206     try {
44207       (arg1)->Refresh();
44208     } CALL_CATCH_EXCEPTION();
44209   }
44210
44211 }
44212
44213
44214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
44215   void * jresult ;
44216   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44217   Dali::Toolkit::ItemId arg2 ;
44218   Dali::Actor result;
44219
44220   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44221   arg2 = (Dali::Toolkit::ItemId)jarg2;
44222   {
44223     try {
44224       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
44225     } CALL_CATCH_EXCEPTION(0);
44226   }
44227
44228   jresult = new Dali::Actor((const Dali::Actor &)result);
44229   return jresult;
44230 }
44231
44232
44233 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
44234   unsigned int jresult ;
44235   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44236   Dali::Actor arg2 ;
44237   Dali::Actor *argp2 ;
44238   Dali::Toolkit::ItemId result;
44239
44240   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44241   argp2 = (Dali::Actor *)jarg2;
44242   if (!argp2) {
44243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
44244     return 0;
44245   }
44246   arg2 = *argp2;
44247   {
44248     try {
44249       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
44250     } CALL_CATCH_EXCEPTION(0);
44251   }
44252
44253   jresult = result;
44254   return jresult;
44255 }
44256
44257
44258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
44259   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44260   Dali::Toolkit::Item arg2 ;
44261   float arg3 ;
44262   Dali::Toolkit::Item *argp2 ;
44263
44264   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44265   argp2 = (Dali::Toolkit::Item *)jarg2;
44266   if (!argp2) {
44267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
44268     return ;
44269   }
44270   arg2 = *argp2;
44271   arg3 = (float)jarg3;
44272   {
44273     try {
44274       (arg1)->InsertItem(arg2,arg3);
44275     } CALL_CATCH_EXCEPTION();
44276   }
44277
44278 }
44279
44280
44281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
44282   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44283   Dali::Toolkit::ItemContainer *arg2 = 0 ;
44284   float arg3 ;
44285
44286   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44287   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
44288   if (!arg2) {
44289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
44290     return ;
44291   }
44292   arg3 = (float)jarg3;
44293   {
44294     try {
44295       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
44296     } CALL_CATCH_EXCEPTION();
44297   }
44298
44299 }
44300
44301
44302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
44303   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44304   Dali::Toolkit::ItemId arg2 ;
44305   float arg3 ;
44306
44307   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44308   arg2 = (Dali::Toolkit::ItemId)jarg2;
44309   arg3 = (float)jarg3;
44310   {
44311     try {
44312       (arg1)->RemoveItem(arg2,arg3);
44313     } CALL_CATCH_EXCEPTION();
44314   }
44315
44316 }
44317
44318
44319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
44320   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44321   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
44322   float arg3 ;
44323
44324   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44325   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
44326   if (!arg2) {
44327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
44328     return ;
44329   }
44330   arg3 = (float)jarg3;
44331   {
44332     try {
44333       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
44334     } CALL_CATCH_EXCEPTION();
44335   }
44336
44337 }
44338
44339
44340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
44341   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44342   Dali::Toolkit::Item arg2 ;
44343   float arg3 ;
44344   Dali::Toolkit::Item *argp2 ;
44345
44346   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44347   argp2 = (Dali::Toolkit::Item *)jarg2;
44348   if (!argp2) {
44349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
44350     return ;
44351   }
44352   arg2 = *argp2;
44353   arg3 = (float)jarg3;
44354   {
44355     try {
44356       (arg1)->ReplaceItem(arg2,arg3);
44357     } CALL_CATCH_EXCEPTION();
44358   }
44359
44360 }
44361
44362
44363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
44364   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44365   Dali::Toolkit::ItemContainer *arg2 = 0 ;
44366   float arg3 ;
44367
44368   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44369   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
44370   if (!arg2) {
44371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
44372     return ;
44373   }
44374   arg3 = (float)jarg3;
44375   {
44376     try {
44377       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
44378     } CALL_CATCH_EXCEPTION();
44379   }
44380
44381 }
44382
44383
44384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
44385   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44386   Dali::Vector3 *arg2 = 0 ;
44387
44388   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44389   arg2 = (Dali::Vector3 *)jarg2;
44390   if (!arg2) {
44391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44392     return ;
44393   }
44394   {
44395     try {
44396       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
44397     } CALL_CATCH_EXCEPTION();
44398   }
44399
44400 }
44401
44402
44403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
44404   void * jresult ;
44405   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44406   Dali::Vector3 result;
44407
44408   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44409   {
44410     try {
44411       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
44412     } CALL_CATCH_EXCEPTION(0);
44413   }
44414
44415   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
44416   return jresult;
44417 }
44418
44419
44420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
44421   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44422   Dali::Vector3 *arg2 = 0 ;
44423
44424   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44425   arg2 = (Dali::Vector3 *)jarg2;
44426   if (!arg2) {
44427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44428     return ;
44429   }
44430   {
44431     try {
44432       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
44433     } CALL_CATCH_EXCEPTION();
44434   }
44435
44436 }
44437
44438
44439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
44440   void * jresult ;
44441   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44442   Dali::Vector3 result;
44443
44444   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44445   {
44446     try {
44447       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
44448     } CALL_CATCH_EXCEPTION(0);
44449   }
44450
44451   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
44452   return jresult;
44453 }
44454
44455
44456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
44457   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44458   Dali::Toolkit::ItemRange *arg2 = 0 ;
44459
44460   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44461   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
44462   if (!arg2) {
44463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
44464     return ;
44465   }
44466   {
44467     try {
44468       (arg1)->GetItemsRange(*arg2);
44469     } CALL_CATCH_EXCEPTION();
44470   }
44471
44472 }
44473
44474
44475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
44476   void * jresult ;
44477   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44478   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
44479
44480   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44481   {
44482     try {
44483       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
44484     } CALL_CATCH_EXCEPTION(0);
44485   }
44486
44487   jresult = (void *)result;
44488   return jresult;
44489 }
44490
44491
44492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
44493   Dali::Vector3 *arg1 = 0 ;
44494   PropertyInputContainer *arg2 = 0 ;
44495
44496   arg1 = (Dali::Vector3 *)jarg1;
44497   if (!arg1) {
44498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
44499     return ;
44500   }
44501   arg2 = (PropertyInputContainer *)jarg2;
44502   if (!arg2) {
44503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
44504     return ;
44505   }
44506   {
44507     try {
44508       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
44509     } CALL_CATCH_EXCEPTION();
44510   }
44511
44512 }
44513
44514
44515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
44516   Dali::Vector3 *arg1 = 0 ;
44517   PropertyInputContainer *arg2 = 0 ;
44518
44519   arg1 = (Dali::Vector3 *)jarg1;
44520   if (!arg1) {
44521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
44522     return ;
44523   }
44524   arg2 = (PropertyInputContainer *)jarg2;
44525   if (!arg2) {
44526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
44527     return ;
44528   }
44529   {
44530     try {
44531       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
44532     } CALL_CATCH_EXCEPTION();
44533   }
44534
44535 }
44536
44537
44538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
44539   void * jresult ;
44540   Dali::Toolkit::ScrollViewEffect *result = 0 ;
44541
44542   {
44543     try {
44544       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
44545     } CALL_CATCH_EXCEPTION(0);
44546   }
44547
44548   jresult = (void *)result;
44549   return jresult;
44550 }
44551
44552
44553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
44554   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
44555
44556   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
44557   {
44558     try {
44559       delete arg1;
44560     } CALL_CATCH_EXCEPTION();
44561   }
44562
44563 }
44564
44565
44566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
44567   void * jresult ;
44568   Dali::Path arg1 ;
44569   Dali::Vector3 *arg2 = 0 ;
44570   Dali::Property::Index arg3 ;
44571   Dali::Vector3 *arg4 = 0 ;
44572   unsigned int arg5 ;
44573   Dali::Path *argp1 ;
44574   Dali::Toolkit::ScrollViewPagePathEffect result;
44575
44576   argp1 = (Dali::Path *)jarg1;
44577   if (!argp1) {
44578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
44579     return 0;
44580   }
44581   arg1 = *argp1;
44582   arg2 = (Dali::Vector3 *)jarg2;
44583   if (!arg2) {
44584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44585     return 0;
44586   }
44587   arg3 = (Dali::Property::Index)jarg3;
44588   arg4 = (Dali::Vector3 *)jarg4;
44589   if (!arg4) {
44590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44591     return 0;
44592   }
44593   arg5 = (unsigned int)jarg5;
44594   {
44595     try {
44596       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
44597     } CALL_CATCH_EXCEPTION(0);
44598   }
44599
44600   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
44601   return jresult;
44602 }
44603
44604
44605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
44606   void * jresult ;
44607   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
44608
44609   {
44610     try {
44611       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
44612     } CALL_CATCH_EXCEPTION(0);
44613   }
44614
44615   jresult = (void *)result;
44616   return jresult;
44617 }
44618
44619
44620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
44621   void * jresult ;
44622   Dali::BaseHandle arg1 ;
44623   Dali::BaseHandle *argp1 ;
44624   Dali::Toolkit::ScrollViewPagePathEffect result;
44625
44626   argp1 = (Dali::BaseHandle *)jarg1;
44627   if (!argp1) {
44628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44629     return 0;
44630   }
44631   arg1 = *argp1;
44632   {
44633     try {
44634       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
44635     } CALL_CATCH_EXCEPTION(0);
44636   }
44637
44638   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
44639   return jresult;
44640 }
44641
44642
44643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
44644   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
44645   Dali::Actor arg2 ;
44646   unsigned int arg3 ;
44647   Dali::Actor *argp2 ;
44648
44649   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
44650   argp2 = (Dali::Actor *)jarg2;
44651   if (!argp2) {
44652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
44653     return ;
44654   }
44655   arg2 = *argp2;
44656   arg3 = (unsigned int)jarg3;
44657   {
44658     try {
44659       (arg1)->ApplyToPage(arg2,arg3);
44660     } CALL_CATCH_EXCEPTION();
44661   }
44662
44663 }
44664
44665
44666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
44667   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
44668
44669   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
44670   {
44671     try {
44672       delete arg1;
44673     } CALL_CATCH_EXCEPTION();
44674   }
44675
44676 }
44677
44678
44679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
44680   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
44681   Dali::Toolkit::ClampState arg2 ;
44682
44683   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
44684   arg2 = (Dali::Toolkit::ClampState)jarg2;
44685   if (arg1) (arg1)->x = arg2;
44686 }
44687
44688
44689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
44690   int jresult ;
44691   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
44692   Dali::Toolkit::ClampState result;
44693
44694   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
44695   result = (Dali::Toolkit::ClampState) ((arg1)->x);
44696   jresult = (int)result;
44697   return jresult;
44698 }
44699
44700
44701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
44702   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
44703   Dali::Toolkit::ClampState arg2 ;
44704
44705   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
44706   arg2 = (Dali::Toolkit::ClampState)jarg2;
44707   if (arg1) (arg1)->y = arg2;
44708 }
44709
44710
44711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
44712   int jresult ;
44713   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
44714   Dali::Toolkit::ClampState result;
44715
44716   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
44717   result = (Dali::Toolkit::ClampState) ((arg1)->y);
44718   jresult = (int)result;
44719   return jresult;
44720 }
44721
44722
44723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
44724   void * jresult ;
44725   Dali::Toolkit::ClampState2D *result = 0 ;
44726
44727   {
44728     try {
44729       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
44730     } CALL_CATCH_EXCEPTION(0);
44731   }
44732
44733   jresult = (void *)result;
44734   return jresult;
44735 }
44736
44737
44738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
44739   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
44740
44741   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
44742   {
44743     try {
44744       delete arg1;
44745     } CALL_CATCH_EXCEPTION();
44746   }
44747
44748 }
44749
44750
44751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, bool jarg3) {
44752   void * jresult ;
44753   float arg1 ;
44754   float arg2 ;
44755   bool arg3 ;
44756   Dali::Toolkit::RulerDomain *result = 0 ;
44757
44758   arg1 = (float)jarg1;
44759   arg2 = (float)jarg2;
44760   arg3 = jarg3 ? true : false;
44761   {
44762     try {
44763       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
44764     } CALL_CATCH_EXCEPTION(0);
44765   }
44766
44767   jresult = (void *)result;
44768   return jresult;
44769 }
44770
44771
44772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
44773   void * jresult ;
44774   float arg1 ;
44775   float arg2 ;
44776   Dali::Toolkit::RulerDomain *result = 0 ;
44777
44778   arg1 = (float)jarg1;
44779   arg2 = (float)jarg2;
44780   {
44781     try {
44782       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
44783     } CALL_CATCH_EXCEPTION(0);
44784   }
44785
44786   jresult = (void *)result;
44787   return jresult;
44788 }
44789
44790
44791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
44792   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
44793   float arg2 ;
44794
44795   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
44796   arg2 = (float)jarg2;
44797   if (arg1) (arg1)->min = arg2;
44798 }
44799
44800
44801 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
44802   float jresult ;
44803   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
44804   float result;
44805
44806   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
44807   result = (float) ((arg1)->min);
44808   jresult = result;
44809   return jresult;
44810 }
44811
44812
44813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
44814   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
44815   float arg2 ;
44816
44817   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
44818   arg2 = (float)jarg2;
44819   if (arg1) (arg1)->max = arg2;
44820 }
44821
44822
44823 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
44824   float jresult ;
44825   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
44826   float result;
44827
44828   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
44829   result = (float) ((arg1)->max);
44830   jresult = result;
44831   return jresult;
44832 }
44833
44834
44835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, bool jarg2) {
44836   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
44837   bool arg2 ;
44838
44839   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
44840   arg2 = jarg2 ? true : false;
44841   if (arg1) (arg1)->enabled = arg2;
44842 }
44843
44844
44845 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
44846   bool jresult ;
44847   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
44848   bool result;
44849
44850   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
44851   result = (bool) ((arg1)->enabled);
44852   jresult = result;
44853   return jresult;
44854 }
44855
44856
44857 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
44858   float jresult ;
44859   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
44860   float arg2 ;
44861   float arg3 ;
44862   float arg4 ;
44863   float result;
44864
44865   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
44866   arg2 = (float)jarg2;
44867   arg3 = (float)jarg3;
44868   arg4 = (float)jarg4;
44869   {
44870     try {
44871       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
44872     } CALL_CATCH_EXCEPTION(0);
44873   }
44874
44875   jresult = result;
44876   return jresult;
44877 }
44878
44879
44880 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
44881   float jresult ;
44882   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
44883   float arg2 ;
44884   float arg3 ;
44885   float result;
44886
44887   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
44888   arg2 = (float)jarg2;
44889   arg3 = (float)jarg3;
44890   {
44891     try {
44892       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
44893     } CALL_CATCH_EXCEPTION(0);
44894   }
44895
44896   jresult = result;
44897   return jresult;
44898 }
44899
44900
44901 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
44902   float jresult ;
44903   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
44904   float arg2 ;
44905   float result;
44906
44907   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
44908   arg2 = (float)jarg2;
44909   {
44910     try {
44911       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
44912     } CALL_CATCH_EXCEPTION(0);
44913   }
44914
44915   jresult = result;
44916   return jresult;
44917 }
44918
44919
44920 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
44921   float jresult ;
44922   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
44923   float arg2 ;
44924   float arg3 ;
44925   float arg4 ;
44926   Dali::Toolkit::ClampState *arg5 = 0 ;
44927   float result;
44928
44929   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
44930   arg2 = (float)jarg2;
44931   arg3 = (float)jarg3;
44932   arg4 = (float)jarg4;
44933   arg5 = (Dali::Toolkit::ClampState *)jarg5;
44934   if (!arg5) {
44935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
44936     return 0;
44937   }
44938   {
44939     try {
44940       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
44941     } CALL_CATCH_EXCEPTION(0);
44942   }
44943
44944   jresult = result;
44945   return jresult;
44946 }
44947
44948
44949 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
44950   float jresult ;
44951   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
44952   float result;
44953
44954   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
44955   {
44956     try {
44957       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
44958     } CALL_CATCH_EXCEPTION(0);
44959   }
44960
44961   jresult = result;
44962   return jresult;
44963 }
44964
44965
44966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
44967   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
44968
44969   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
44970   {
44971     try {
44972       delete arg1;
44973     } CALL_CATCH_EXCEPTION();
44974   }
44975
44976 }
44977
44978
44979 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
44980   float jresult ;
44981   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44982   float arg2 ;
44983   float arg3 ;
44984   float result;
44985
44986   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44987   arg2 = (float)jarg2;
44988   arg3 = (float)jarg3;
44989   {
44990     try {
44991       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
44992     } CALL_CATCH_EXCEPTION(0);
44993   }
44994
44995   jresult = result;
44996   return jresult;
44997 }
44998
44999
45000 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
45001   float jresult ;
45002   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45003   float arg2 ;
45004   float result;
45005
45006   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45007   arg2 = (float)jarg2;
45008   {
45009     try {
45010       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
45011     } CALL_CATCH_EXCEPTION(0);
45012   }
45013
45014   jresult = result;
45015   return jresult;
45016 }
45017
45018
45019 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) {
45020   float jresult ;
45021   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45022   unsigned int arg2 ;
45023   unsigned int *arg3 = 0 ;
45024   bool arg4 ;
45025   float result;
45026
45027   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45028   arg2 = (unsigned int)jarg2;
45029   arg3 = (unsigned int *)jarg3;
45030   arg4 = jarg4 ? true : false;
45031   {
45032     try {
45033       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
45034     } CALL_CATCH_EXCEPTION(0);
45035   }
45036
45037   jresult = result;
45038   return jresult;
45039 }
45040
45041
45042 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) {
45043   unsigned int jresult ;
45044   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45045   float arg2 ;
45046   bool arg3 ;
45047   unsigned int result;
45048
45049   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45050   arg2 = (float)jarg2;
45051   arg3 = jarg3 ? true : false;
45052   {
45053     try {
45054       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
45055     } CALL_CATCH_EXCEPTION(0);
45056   }
45057
45058   jresult = result;
45059   return jresult;
45060 }
45061
45062
45063 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
45064   unsigned int jresult ;
45065   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45066   unsigned int result;
45067
45068   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45069   {
45070     try {
45071       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
45072     } CALL_CATCH_EXCEPTION(0);
45073   }
45074
45075   jresult = result;
45076   return jresult;
45077 }
45078
45079
45080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
45081   int jresult ;
45082   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45083   Dali::Toolkit::Ruler::RulerType result;
45084
45085   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45086   {
45087     try {
45088       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
45089     } CALL_CATCH_EXCEPTION(0);
45090   }
45091
45092   jresult = (int)result;
45093   return jresult;
45094 }
45095
45096
45097 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
45098   bool jresult ;
45099   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45100   bool result;
45101
45102   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45103   {
45104     try {
45105       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
45106     } CALL_CATCH_EXCEPTION(0);
45107   }
45108
45109   jresult = result;
45110   return jresult;
45111 }
45112
45113
45114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
45115   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45116
45117   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45118   {
45119     try {
45120       (arg1)->Enable();
45121     } CALL_CATCH_EXCEPTION();
45122   }
45123
45124 }
45125
45126
45127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
45128   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45129
45130   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45131   {
45132     try {
45133       (arg1)->Disable();
45134     } CALL_CATCH_EXCEPTION();
45135   }
45136
45137 }
45138
45139
45140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
45141   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45142   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
45143   Dali::Toolkit::RulerDomain *argp2 ;
45144
45145   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45146   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
45147   if (!argp2) {
45148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
45149     return ;
45150   }
45151   arg2 = *argp2;
45152   {
45153     try {
45154       (arg1)->SetDomain(arg2);
45155     } CALL_CATCH_EXCEPTION();
45156   }
45157
45158 }
45159
45160
45161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
45162   void * jresult ;
45163   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45164   Dali::Toolkit::RulerDomain *result = 0 ;
45165
45166   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45167   {
45168     try {
45169       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
45170     } CALL_CATCH_EXCEPTION(0);
45171   }
45172
45173   jresult = (void *)result;
45174   return jresult;
45175 }
45176
45177
45178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
45179   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45180
45181   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45182   {
45183     try {
45184       (arg1)->DisableDomain();
45185     } CALL_CATCH_EXCEPTION();
45186   }
45187
45188 }
45189
45190
45191 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
45192   float jresult ;
45193   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45194   float arg2 ;
45195   float arg3 ;
45196   float arg4 ;
45197   float result;
45198
45199   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45200   arg2 = (float)jarg2;
45201   arg3 = (float)jarg3;
45202   arg4 = (float)jarg4;
45203   {
45204     try {
45205       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
45206     } CALL_CATCH_EXCEPTION(0);
45207   }
45208
45209   jresult = result;
45210   return jresult;
45211 }
45212
45213
45214 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
45215   float jresult ;
45216   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45217   float arg2 ;
45218   float arg3 ;
45219   float result;
45220
45221   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45222   arg2 = (float)jarg2;
45223   arg3 = (float)jarg3;
45224   {
45225     try {
45226       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
45227     } CALL_CATCH_EXCEPTION(0);
45228   }
45229
45230   jresult = result;
45231   return jresult;
45232 }
45233
45234
45235 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
45236   float jresult ;
45237   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45238   float arg2 ;
45239   float result;
45240
45241   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45242   arg2 = (float)jarg2;
45243   {
45244     try {
45245       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
45246     } CALL_CATCH_EXCEPTION(0);
45247   }
45248
45249   jresult = result;
45250   return jresult;
45251 }
45252
45253
45254 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
45255   float jresult ;
45256   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45257   float arg2 ;
45258   float arg3 ;
45259   float arg4 ;
45260   Dali::Toolkit::ClampState *arg5 = 0 ;
45261   float result;
45262
45263   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45264   arg2 = (float)jarg2;
45265   arg3 = (float)jarg3;
45266   arg4 = (float)jarg4;
45267   arg5 = (Dali::Toolkit::ClampState *)jarg5;
45268   if (!arg5) {
45269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
45270     return 0;
45271   }
45272   {
45273     try {
45274       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
45275     } CALL_CATCH_EXCEPTION(0);
45276   }
45277
45278   jresult = result;
45279   return jresult;
45280 }
45281
45282
45283 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
45284   float jresult ;
45285   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45286   float arg2 ;
45287   float arg3 ;
45288   float arg4 ;
45289   float arg5 ;
45290   float result;
45291
45292   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45293   arg2 = (float)jarg2;
45294   arg3 = (float)jarg3;
45295   arg4 = (float)jarg4;
45296   arg5 = (float)jarg5;
45297   {
45298     try {
45299       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
45300     } CALL_CATCH_EXCEPTION(0);
45301   }
45302
45303   jresult = result;
45304   return jresult;
45305 }
45306
45307
45308 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
45309   float jresult ;
45310   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45311   float arg2 ;
45312   float arg3 ;
45313   float arg4 ;
45314   float result;
45315
45316   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45317   arg2 = (float)jarg2;
45318   arg3 = (float)jarg3;
45319   arg4 = (float)jarg4;
45320   {
45321     try {
45322       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
45323     } CALL_CATCH_EXCEPTION(0);
45324   }
45325
45326   jresult = result;
45327   return jresult;
45328 }
45329
45330
45331 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
45332   float jresult ;
45333   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45334   float arg2 ;
45335   float arg3 ;
45336   float result;
45337
45338   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45339   arg2 = (float)jarg2;
45340   arg3 = (float)jarg3;
45341   {
45342     try {
45343       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
45344     } CALL_CATCH_EXCEPTION(0);
45345   }
45346
45347   jresult = result;
45348   return jresult;
45349 }
45350
45351
45352 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
45353   float jresult ;
45354   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45355   float arg2 ;
45356   float result;
45357
45358   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45359   arg2 = (float)jarg2;
45360   {
45361     try {
45362       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
45363     } CALL_CATCH_EXCEPTION(0);
45364   }
45365
45366   jresult = result;
45367   return jresult;
45368 }
45369
45370
45371 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
45372   float jresult ;
45373   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45374   float arg2 ;
45375   float arg3 ;
45376   float arg4 ;
45377   float arg5 ;
45378   Dali::Toolkit::ClampState *arg6 = 0 ;
45379   float result;
45380
45381   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45382   arg2 = (float)jarg2;
45383   arg3 = (float)jarg3;
45384   arg4 = (float)jarg4;
45385   arg5 = (float)jarg5;
45386   arg6 = (Dali::Toolkit::ClampState *)jarg6;
45387   if (!arg6) {
45388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
45389     return 0;
45390   }
45391   {
45392     try {
45393       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
45394     } CALL_CATCH_EXCEPTION(0);
45395   }
45396
45397   jresult = result;
45398   return jresult;
45399 }
45400
45401
45402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
45403   void * jresult ;
45404   Dali::Toolkit::DefaultRuler *result = 0 ;
45405
45406   {
45407     try {
45408       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
45409     } CALL_CATCH_EXCEPTION(0);
45410   }
45411
45412   jresult = (void *)result;
45413   return jresult;
45414 }
45415
45416
45417 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
45418   float jresult ;
45419   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
45420   float arg2 ;
45421   float arg3 ;
45422   float result;
45423
45424   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
45425   arg2 = (float)jarg2;
45426   arg3 = (float)jarg3;
45427   {
45428     try {
45429       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
45430     } CALL_CATCH_EXCEPTION(0);
45431   }
45432
45433   jresult = result;
45434   return jresult;
45435 }
45436
45437
45438 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) {
45439   float jresult ;
45440   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
45441   unsigned int arg2 ;
45442   unsigned int *arg3 = 0 ;
45443   bool arg4 ;
45444   float result;
45445
45446   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
45447   arg2 = (unsigned int)jarg2;
45448   arg3 = (unsigned int *)jarg3;
45449   arg4 = jarg4 ? true : false;
45450   {
45451     try {
45452       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
45453     } CALL_CATCH_EXCEPTION(0);
45454   }
45455
45456   jresult = result;
45457   return jresult;
45458 }
45459
45460
45461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) {
45462   unsigned int jresult ;
45463   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
45464   float arg2 ;
45465   bool arg3 ;
45466   unsigned int result;
45467
45468   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
45469   arg2 = (float)jarg2;
45470   arg3 = jarg3 ? true : false;
45471   {
45472     try {
45473       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
45474     } CALL_CATCH_EXCEPTION(0);
45475   }
45476
45477   jresult = result;
45478   return jresult;
45479 }
45480
45481
45482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
45483   unsigned int jresult ;
45484   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
45485   unsigned int result;
45486
45487   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
45488   {
45489     try {
45490       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
45491     } CALL_CATCH_EXCEPTION(0);
45492   }
45493
45494   jresult = result;
45495   return jresult;
45496 }
45497
45498
45499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
45500   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
45501
45502   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
45503   {
45504     try {
45505       delete arg1;
45506     } CALL_CATCH_EXCEPTION();
45507   }
45508
45509 }
45510
45511
45512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
45513   void * jresult ;
45514   float arg1 ;
45515   Dali::Toolkit::FixedRuler *result = 0 ;
45516
45517   arg1 = (float)jarg1;
45518   {
45519     try {
45520       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
45521     } CALL_CATCH_EXCEPTION(0);
45522   }
45523
45524   jresult = (void *)result;
45525   return jresult;
45526 }
45527
45528
45529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
45530   void * jresult ;
45531   Dali::Toolkit::FixedRuler *result = 0 ;
45532
45533   {
45534     try {
45535       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
45536     } CALL_CATCH_EXCEPTION(0);
45537   }
45538
45539   jresult = (void *)result;
45540   return jresult;
45541 }
45542
45543
45544 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
45545   float jresult ;
45546   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
45547   float arg2 ;
45548   float arg3 ;
45549   float result;
45550
45551   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
45552   arg2 = (float)jarg2;
45553   arg3 = (float)jarg3;
45554   {
45555     try {
45556       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
45557     } CALL_CATCH_EXCEPTION(0);
45558   }
45559
45560   jresult = result;
45561   return jresult;
45562 }
45563
45564
45565 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) {
45566   float jresult ;
45567   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
45568   unsigned int arg2 ;
45569   unsigned int *arg3 = 0 ;
45570   bool arg4 ;
45571   float result;
45572
45573   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
45574   arg2 = (unsigned int)jarg2;
45575   arg3 = (unsigned int *)jarg3;
45576   arg4 = jarg4 ? true : false;
45577   {
45578     try {
45579       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
45580     } CALL_CATCH_EXCEPTION(0);
45581   }
45582
45583   jresult = result;
45584   return jresult;
45585 }
45586
45587
45588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) {
45589   unsigned int jresult ;
45590   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
45591   float arg2 ;
45592   bool arg3 ;
45593   unsigned int result;
45594
45595   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
45596   arg2 = (float)jarg2;
45597   arg3 = jarg3 ? true : false;
45598   {
45599     try {
45600       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
45601     } CALL_CATCH_EXCEPTION(0);
45602   }
45603
45604   jresult = result;
45605   return jresult;
45606 }
45607
45608
45609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
45610   unsigned int jresult ;
45611   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
45612   unsigned int result;
45613
45614   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
45615   {
45616     try {
45617       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
45618     } CALL_CATCH_EXCEPTION(0);
45619   }
45620
45621   jresult = result;
45622   return jresult;
45623 }
45624
45625
45626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
45627   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
45628
45629   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
45630   {
45631     try {
45632       delete arg1;
45633     } CALL_CATCH_EXCEPTION();
45634   }
45635
45636 }
45637
45638
45639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
45640   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
45641   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
45642
45643   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
45644   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
45645   if (arg1) (arg1)->scale = *arg2;
45646 }
45647
45648
45649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
45650   void * jresult ;
45651   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
45652   Dali::Toolkit::ClampState2D *result = 0 ;
45653
45654   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
45655   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
45656   jresult = (void *)result;
45657   return jresult;
45658 }
45659
45660
45661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
45662   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
45663   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
45664
45665   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
45666   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
45667   if (arg1) (arg1)->position = *arg2;
45668 }
45669
45670
45671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
45672   void * jresult ;
45673   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
45674   Dali::Toolkit::ClampState2D *result = 0 ;
45675
45676   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
45677   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
45678   jresult = (void *)result;
45679   return jresult;
45680 }
45681
45682
45683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
45684   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
45685   Dali::Toolkit::ClampState arg2 ;
45686
45687   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
45688   arg2 = (Dali::Toolkit::ClampState)jarg2;
45689   if (arg1) (arg1)->rotation = arg2;
45690 }
45691
45692
45693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
45694   int jresult ;
45695   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
45696   Dali::Toolkit::ClampState result;
45697
45698   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
45699   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
45700   jresult = (int)result;
45701   return jresult;
45702 }
45703
45704
45705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
45706   void * jresult ;
45707   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
45708
45709   {
45710     try {
45711       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
45712     } CALL_CATCH_EXCEPTION(0);
45713   }
45714
45715   jresult = (void *)result;
45716   return jresult;
45717 }
45718
45719
45720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
45721   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
45722
45723   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
45724   {
45725     try {
45726       delete arg1;
45727     } CALL_CATCH_EXCEPTION();
45728   }
45729
45730 }
45731
45732
45733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
45734   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
45735   Dali::Toolkit::SnapType arg2 ;
45736
45737   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
45738   arg2 = (Dali::Toolkit::SnapType)jarg2;
45739   if (arg1) (arg1)->type = arg2;
45740 }
45741
45742
45743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
45744   int jresult ;
45745   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
45746   Dali::Toolkit::SnapType result;
45747
45748   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
45749   result = (Dali::Toolkit::SnapType) ((arg1)->type);
45750   jresult = (int)result;
45751   return jresult;
45752 }
45753
45754
45755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
45756   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
45757   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
45758
45759   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
45760   arg2 = (Dali::Vector2 *)jarg2;
45761   if (arg1) (arg1)->position = *arg2;
45762 }
45763
45764
45765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
45766   void * jresult ;
45767   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
45768   Dali::Vector2 *result = 0 ;
45769
45770   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
45771   result = (Dali::Vector2 *)& ((arg1)->position);
45772   jresult = (void *)result;
45773   return jresult;
45774 }
45775
45776
45777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
45778   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
45779   float arg2 ;
45780
45781   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
45782   arg2 = (float)jarg2;
45783   if (arg1) (arg1)->duration = arg2;
45784 }
45785
45786
45787 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
45788   float jresult ;
45789   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
45790   float result;
45791
45792   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
45793   result = (float) ((arg1)->duration);
45794   jresult = result;
45795   return jresult;
45796 }
45797
45798
45799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
45800   void * jresult ;
45801   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
45802
45803   {
45804     try {
45805       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
45806     } CALL_CATCH_EXCEPTION(0);
45807   }
45808
45809   jresult = (void *)result;
45810   return jresult;
45811 }
45812
45813
45814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
45815   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
45816
45817   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
45818   {
45819     try {
45820       delete arg1;
45821     } CALL_CATCH_EXCEPTION();
45822   }
45823
45824 }
45825
45826
45827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
45828   int jresult ;
45829   int result;
45830
45831   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
45832   jresult = (int)result;
45833   return jresult;
45834 }
45835
45836
45837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
45838   int jresult ;
45839   int result;
45840
45841   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
45842   jresult = (int)result;
45843   return jresult;
45844 }
45845
45846
45847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
45848   int jresult ;
45849   int result;
45850
45851   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
45852   jresult = (int)result;
45853   return jresult;
45854 }
45855
45856
45857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
45858   int jresult ;
45859   int result;
45860
45861   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
45862   jresult = (int)result;
45863   return jresult;
45864 }
45865
45866
45867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
45868   int jresult ;
45869   int result;
45870
45871   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
45872   jresult = (int)result;
45873   return jresult;
45874 }
45875
45876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
45877   int jresult ;
45878   int result;
45879
45880   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
45881   jresult = (int)result;
45882   return jresult;
45883 }
45884
45885
45886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
45887   int jresult ;
45888   int result;
45889
45890   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
45891   jresult = (int)result;
45892   return jresult;
45893 }
45894
45895
45896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
45897   int jresult ;
45898   int result;
45899
45900   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
45901   jresult = (int)result;
45902   return jresult;
45903 }
45904
45905
45906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
45907   int jresult ;
45908   int result;
45909
45910   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
45911   jresult = (int)result;
45912   return jresult;
45913 }
45914
45915
45916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
45917   int jresult ;
45918   int result;
45919
45920   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
45921   jresult = (int)result;
45922   return jresult;
45923 }
45924
45925
45926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
45927   int jresult ;
45928   int result;
45929
45930   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
45931   jresult = (int)result;
45932   return jresult;
45933 }
45934
45935
45936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
45937   int jresult ;
45938   int result;
45939
45940   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
45941   jresult = (int)result;
45942   return jresult;
45943 }
45944
45945
45946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
45947   int jresult ;
45948   int result;
45949
45950   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
45951   jresult = (int)result;
45952   return jresult;
45953 }
45954
45955
45956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
45957   int jresult ;
45958   int result;
45959
45960   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
45961   jresult = (int)result;
45962   return jresult;
45963 }
45964
45965
45966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
45967   int jresult ;
45968   int result;
45969
45970   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
45971   jresult = (int)result;
45972   return jresult;
45973 }
45974
45975
45976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
45977   int jresult ;
45978   int result;
45979
45980   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
45981   jresult = (int)result;
45982   return jresult;
45983 }
45984
45985
45986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
45987   int jresult ;
45988   int result;
45989
45990   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
45991   jresult = (int)result;
45992   return jresult;
45993 }
45994
45995
45996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
45997   int jresult ;
45998   int result;
45999
46000   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
46001   jresult = (int)result;
46002   return jresult;
46003 }
46004
46005
46006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
46007   int jresult ;
46008   int result;
46009
46010   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
46011   jresult = (int)result;
46012   return jresult;
46013 }
46014
46015
46016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
46017   int jresult ;
46018   int result;
46019
46020   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
46021   jresult = (int)result;
46022   return jresult;
46023 }
46024
46025
46026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
46027   int jresult ;
46028   int result;
46029
46030   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
46031   jresult = (int)result;
46032   return jresult;
46033 }
46034
46035
46036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
46037   int jresult ;
46038   int result;
46039
46040   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
46041   jresult = (int)result;
46042   return jresult;
46043 }
46044
46045
46046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
46047   int jresult ;
46048   int result;
46049
46050   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
46051   jresult = (int)result;
46052   return jresult;
46053 }
46054
46055
46056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
46057   int jresult ;
46058   int result;
46059
46060   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
46061   jresult = (int)result;
46062   return jresult;
46063 }
46064
46065
46066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
46067   int jresult ;
46068   int result;
46069
46070   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
46071   jresult = (int)result;
46072   return jresult;
46073 }
46074
46075
46076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
46077   int jresult ;
46078   int result;
46079
46080   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
46081   jresult = (int)result;
46082   return jresult;
46083 }
46084
46085
46086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
46087   void * jresult ;
46088   Dali::Toolkit::ScrollView::Property *result = 0 ;
46089
46090   {
46091     try {
46092       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
46093     } CALL_CATCH_EXCEPTION(0);
46094   }
46095
46096   jresult = (void *)result;
46097   return jresult;
46098 }
46099
46100
46101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
46102   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
46103
46104   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
46105   {
46106     try {
46107       delete arg1;
46108     } CALL_CATCH_EXCEPTION();
46109   }
46110
46111 }
46112
46113
46114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
46115   void * jresult ;
46116   Dali::Toolkit::ScrollView *result = 0 ;
46117
46118   {
46119     try {
46120       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
46121     } CALL_CATCH_EXCEPTION(0);
46122   }
46123
46124   jresult = (void *)result;
46125   return jresult;
46126 }
46127
46128
46129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
46130   void * jresult ;
46131   Dali::Toolkit::ScrollView *arg1 = 0 ;
46132   Dali::Toolkit::ScrollView *result = 0 ;
46133
46134   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46135   if (!arg1) {
46136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
46137     return 0;
46138   }
46139   {
46140     try {
46141       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
46142     } CALL_CATCH_EXCEPTION(0);
46143   }
46144
46145   jresult = (void *)result;
46146   return jresult;
46147 }
46148
46149
46150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
46151   void * jresult ;
46152   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46153   Dali::Toolkit::ScrollView *arg2 = 0 ;
46154   Dali::Toolkit::ScrollView *result = 0 ;
46155
46156   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46157   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
46158   if (!arg2) {
46159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
46160     return 0;
46161   }
46162   {
46163     try {
46164       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
46165     } CALL_CATCH_EXCEPTION(0);
46166   }
46167
46168   jresult = (void *)result;
46169   return jresult;
46170 }
46171
46172
46173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
46174   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46175
46176   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46177   {
46178     try {
46179       delete arg1;
46180     } CALL_CATCH_EXCEPTION();
46181   }
46182
46183 }
46184
46185
46186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
46187   void * jresult ;
46188   Dali::Toolkit::ScrollView result;
46189
46190   {
46191     try {
46192       result = Dali::Toolkit::ScrollView::New();
46193     } CALL_CATCH_EXCEPTION(0);
46194   }
46195
46196   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
46197   return jresult;
46198 }
46199
46200
46201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
46202   void * jresult ;
46203   Dali::BaseHandle arg1 ;
46204   Dali::BaseHandle *argp1 ;
46205   Dali::Toolkit::ScrollView result;
46206
46207   argp1 = (Dali::BaseHandle *)jarg1;
46208   if (!argp1) {
46209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46210     return 0;
46211   }
46212   arg1 = *argp1;
46213   {
46214     try {
46215       result = Dali::Toolkit::ScrollView::DownCast(arg1);
46216     } CALL_CATCH_EXCEPTION(0);
46217   }
46218
46219   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
46220   return jresult;
46221 }
46222
46223
46224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
46225   void * jresult ;
46226   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46227   Dali::AlphaFunction result;
46228
46229   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46230   {
46231     try {
46232       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
46233     } CALL_CATCH_EXCEPTION(0);
46234   }
46235
46236   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
46237   return jresult;
46238 }
46239
46240
46241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
46242   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46243   Dali::AlphaFunction arg2 ;
46244   Dali::AlphaFunction *argp2 ;
46245
46246   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46247   argp2 = (Dali::AlphaFunction *)jarg2;
46248   if (!argp2) {
46249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
46250     return ;
46251   }
46252   arg2 = *argp2;
46253   {
46254     try {
46255       (arg1)->SetScrollSnapAlphaFunction(arg2);
46256     } CALL_CATCH_EXCEPTION();
46257   }
46258
46259 }
46260
46261
46262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
46263   void * jresult ;
46264   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46265   Dali::AlphaFunction result;
46266
46267   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46268   {
46269     try {
46270       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
46271     } CALL_CATCH_EXCEPTION(0);
46272   }
46273
46274   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
46275   return jresult;
46276 }
46277
46278
46279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
46280   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46281   Dali::AlphaFunction arg2 ;
46282   Dali::AlphaFunction *argp2 ;
46283
46284   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46285   argp2 = (Dali::AlphaFunction *)jarg2;
46286   if (!argp2) {
46287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
46288     return ;
46289   }
46290   arg2 = *argp2;
46291   {
46292     try {
46293       (arg1)->SetScrollFlickAlphaFunction(arg2);
46294     } CALL_CATCH_EXCEPTION();
46295   }
46296
46297 }
46298
46299
46300 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
46301   float jresult ;
46302   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46303   float result;
46304
46305   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46306   {
46307     try {
46308       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
46309     } CALL_CATCH_EXCEPTION(0);
46310   }
46311
46312   jresult = result;
46313   return jresult;
46314 }
46315
46316
46317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
46318   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46319   float arg2 ;
46320
46321   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46322   arg2 = (float)jarg2;
46323   {
46324     try {
46325       (arg1)->SetScrollSnapDuration(arg2);
46326     } CALL_CATCH_EXCEPTION();
46327   }
46328
46329 }
46330
46331
46332 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
46333   float jresult ;
46334   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46335   float result;
46336
46337   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46338   {
46339     try {
46340       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
46341     } CALL_CATCH_EXCEPTION(0);
46342   }
46343
46344   jresult = result;
46345   return jresult;
46346 }
46347
46348
46349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
46350   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46351   float arg2 ;
46352
46353   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46354   arg2 = (float)jarg2;
46355   {
46356     try {
46357       (arg1)->SetScrollFlickDuration(arg2);
46358     } CALL_CATCH_EXCEPTION();
46359   }
46360
46361 }
46362
46363
46364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
46365   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46366   Dali::Toolkit::RulerPtr arg2 ;
46367   Dali::Toolkit::RulerPtr *argp2 ;
46368
46369   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46370   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
46371   if (!argp2) {
46372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
46373     return ;
46374   }
46375   arg2 = *argp2;
46376   {
46377     try {
46378       (arg1)->SetRulerX(arg2);
46379     } CALL_CATCH_EXCEPTION();
46380   }
46381
46382 }
46383
46384
46385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
46386   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46387   Dali::Toolkit::RulerPtr arg2 ;
46388   Dali::Toolkit::RulerPtr *argp2 ;
46389
46390   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46391   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
46392   if (!argp2) {
46393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
46394     return ;
46395   }
46396   arg2 = *argp2;
46397   {
46398     try {
46399       (arg1)->SetRulerY(arg2);
46400     } CALL_CATCH_EXCEPTION();
46401   }
46402
46403 }
46404
46405
46406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, bool jarg2) {
46407   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46408   bool arg2 ;
46409
46410   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46411   arg2 = jarg2 ? true : false;
46412   {
46413     try {
46414       (arg1)->SetScrollSensitive(arg2);
46415     } CALL_CATCH_EXCEPTION();
46416   }
46417
46418 }
46419
46420
46421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
46422   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46423   float arg2 ;
46424   float arg3 ;
46425
46426   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46427   arg2 = (float)jarg2;
46428   arg3 = (float)jarg3;
46429   {
46430     try {
46431       (arg1)->SetMaxOvershoot(arg2,arg3);
46432     } CALL_CATCH_EXCEPTION();
46433   }
46434
46435 }
46436
46437
46438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
46439   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46440   Dali::AlphaFunction arg2 ;
46441   Dali::AlphaFunction *argp2 ;
46442
46443   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46444   argp2 = (Dali::AlphaFunction *)jarg2;
46445   if (!argp2) {
46446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
46447     return ;
46448   }
46449   arg2 = *argp2;
46450   {
46451     try {
46452       (arg1)->SetSnapOvershootAlphaFunction(arg2);
46453     } CALL_CATCH_EXCEPTION();
46454   }
46455
46456 }
46457
46458
46459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
46460   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46461   float arg2 ;
46462
46463   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46464   arg2 = (float)jarg2;
46465   {
46466     try {
46467       (arg1)->SetSnapOvershootDuration(arg2);
46468     } CALL_CATCH_EXCEPTION();
46469   }
46470
46471 }
46472
46473
46474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, bool jarg2) {
46475   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46476   bool arg2 ;
46477
46478   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46479   arg2 = jarg2 ? true : false;
46480   {
46481     try {
46482       (arg1)->SetActorAutoSnap(arg2);
46483     } CALL_CATCH_EXCEPTION();
46484   }
46485
46486 }
46487
46488
46489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, bool jarg2) {
46490   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46491   bool arg2 ;
46492
46493   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46494   arg2 = jarg2 ? true : false;
46495   {
46496     try {
46497       (arg1)->SetWrapMode(arg2);
46498     } CALL_CATCH_EXCEPTION();
46499   }
46500
46501 }
46502
46503
46504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
46505   int jresult ;
46506   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46507   int result;
46508
46509   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46510   {
46511     try {
46512       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
46513     } CALL_CATCH_EXCEPTION(0);
46514   }
46515
46516   jresult = result;
46517   return jresult;
46518 }
46519
46520
46521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
46522   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46523   int arg2 ;
46524
46525   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46526   arg2 = (int)jarg2;
46527   {
46528     try {
46529       (arg1)->SetScrollUpdateDistance(arg2);
46530     } CALL_CATCH_EXCEPTION();
46531   }
46532
46533 }
46534
46535
46536 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
46537   bool jresult ;
46538   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46539   bool result;
46540
46541   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46542   {
46543     try {
46544       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
46545     } CALL_CATCH_EXCEPTION(0);
46546   }
46547
46548   jresult = result;
46549   return jresult;
46550 }
46551
46552
46553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, bool jarg2) {
46554   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46555   bool arg2 ;
46556
46557   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46558   arg2 = jarg2 ? true : false;
46559   {
46560     try {
46561       (arg1)->SetAxisAutoLock(arg2);
46562     } CALL_CATCH_EXCEPTION();
46563   }
46564
46565 }
46566
46567
46568 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
46569   float jresult ;
46570   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46571   float result;
46572
46573   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46574   {
46575     try {
46576       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
46577     } CALL_CATCH_EXCEPTION(0);
46578   }
46579
46580   jresult = result;
46581   return jresult;
46582 }
46583
46584
46585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
46586   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46587   float arg2 ;
46588
46589   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46590   arg2 = (float)jarg2;
46591   {
46592     try {
46593       (arg1)->SetAxisAutoLockGradient(arg2);
46594     } CALL_CATCH_EXCEPTION();
46595   }
46596
46597 }
46598
46599
46600 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
46601   float jresult ;
46602   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46603   float result;
46604
46605   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46606   {
46607     try {
46608       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
46609     } CALL_CATCH_EXCEPTION(0);
46610   }
46611
46612   jresult = result;
46613   return jresult;
46614 }
46615
46616
46617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
46618   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46619   float arg2 ;
46620
46621   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46622   arg2 = (float)jarg2;
46623   {
46624     try {
46625       (arg1)->SetFrictionCoefficient(arg2);
46626     } CALL_CATCH_EXCEPTION();
46627   }
46628
46629 }
46630
46631
46632 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
46633   float jresult ;
46634   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46635   float result;
46636
46637   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46638   {
46639     try {
46640       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
46641     } CALL_CATCH_EXCEPTION(0);
46642   }
46643
46644   jresult = result;
46645   return jresult;
46646 }
46647
46648
46649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
46650   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46651   float arg2 ;
46652
46653   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46654   arg2 = (float)jarg2;
46655   {
46656     try {
46657       (arg1)->SetFlickSpeedCoefficient(arg2);
46658     } CALL_CATCH_EXCEPTION();
46659   }
46660
46661 }
46662
46663
46664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
46665   void * jresult ;
46666   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46667   Dali::Vector2 result;
46668
46669   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46670   {
46671     try {
46672       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
46673     } CALL_CATCH_EXCEPTION(0);
46674   }
46675
46676   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
46677   return jresult;
46678 }
46679
46680
46681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
46682   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46683   Dali::Vector2 *arg2 = 0 ;
46684
46685   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46686   arg2 = (Dali::Vector2 *)jarg2;
46687   if (!arg2) {
46688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
46689     return ;
46690   }
46691   {
46692     try {
46693       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
46694     } CALL_CATCH_EXCEPTION();
46695   }
46696
46697 }
46698
46699
46700 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
46701   float jresult ;
46702   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46703   float result;
46704
46705   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46706   {
46707     try {
46708       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
46709     } CALL_CATCH_EXCEPTION(0);
46710   }
46711
46712   jresult = result;
46713   return jresult;
46714 }
46715
46716
46717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
46718   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46719   float arg2 ;
46720
46721   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46722   arg2 = (float)jarg2;
46723   {
46724     try {
46725       (arg1)->SetMinimumSpeedForFlick(arg2);
46726     } CALL_CATCH_EXCEPTION();
46727   }
46728
46729 }
46730
46731
46732 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
46733   float jresult ;
46734   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46735   float result;
46736
46737   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46738   {
46739     try {
46740       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
46741     } CALL_CATCH_EXCEPTION(0);
46742   }
46743
46744   jresult = result;
46745   return jresult;
46746 }
46747
46748
46749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
46750   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46751   float arg2 ;
46752
46753   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46754   arg2 = (float)jarg2;
46755   {
46756     try {
46757       (arg1)->SetMaxFlickSpeed(arg2);
46758     } CALL_CATCH_EXCEPTION();
46759   }
46760
46761 }
46762
46763
46764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
46765   void * jresult ;
46766   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46767   Dali::Vector2 result;
46768
46769   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46770   {
46771     try {
46772       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
46773     } CALL_CATCH_EXCEPTION(0);
46774   }
46775
46776   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
46777   return jresult;
46778 }
46779
46780
46781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
46782   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46783   Dali::Vector2 arg2 ;
46784   Dali::Vector2 *argp2 ;
46785
46786   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46787   argp2 = (Dali::Vector2 *)jarg2;
46788   if (!argp2) {
46789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
46790     return ;
46791   }
46792   arg2 = *argp2;
46793   {
46794     try {
46795       (arg1)->SetWheelScrollDistanceStep(arg2);
46796     } CALL_CATCH_EXCEPTION();
46797   }
46798
46799 }
46800
46801
46802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
46803   void * jresult ;
46804   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46805   Dali::Vector2 result;
46806
46807   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46808   {
46809     try {
46810       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
46811     } CALL_CATCH_EXCEPTION(0);
46812   }
46813
46814   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
46815   return jresult;
46816 }
46817
46818
46819 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
46820   unsigned int jresult ;
46821   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46822   unsigned int result;
46823
46824   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46825   {
46826     try {
46827       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
46828     } CALL_CATCH_EXCEPTION(0);
46829   }
46830
46831   jresult = result;
46832   return jresult;
46833 }
46834
46835
46836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
46837   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46838   Dali::Vector2 *arg2 = 0 ;
46839
46840   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46841   arg2 = (Dali::Vector2 *)jarg2;
46842   if (!arg2) {
46843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
46844     return ;
46845   }
46846   {
46847     try {
46848       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
46849     } CALL_CATCH_EXCEPTION();
46850   }
46851
46852 }
46853
46854
46855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
46856   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46857   Dali::Vector2 *arg2 = 0 ;
46858   float arg3 ;
46859
46860   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46861   arg2 = (Dali::Vector2 *)jarg2;
46862   if (!arg2) {
46863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
46864     return ;
46865   }
46866   arg3 = (float)jarg3;
46867   {
46868     try {
46869       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
46870     } CALL_CATCH_EXCEPTION();
46871   }
46872
46873 }
46874
46875
46876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
46877   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46878   Dali::Vector2 *arg2 = 0 ;
46879   float arg3 ;
46880   Dali::AlphaFunction arg4 ;
46881   Dali::AlphaFunction *argp4 ;
46882
46883   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46884   arg2 = (Dali::Vector2 *)jarg2;
46885   if (!arg2) {
46886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
46887     return ;
46888   }
46889   arg3 = (float)jarg3;
46890   argp4 = (Dali::AlphaFunction *)jarg4;
46891   if (!argp4) {
46892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
46893     return ;
46894   }
46895   arg4 = *argp4;
46896   {
46897     try {
46898       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
46899     } CALL_CATCH_EXCEPTION();
46900   }
46901
46902 }
46903
46904
46905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
46906   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46907   Dali::Vector2 *arg2 = 0 ;
46908   float arg3 ;
46909   Dali::Toolkit::DirectionBias arg4 ;
46910   Dali::Toolkit::DirectionBias arg5 ;
46911
46912   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46913   arg2 = (Dali::Vector2 *)jarg2;
46914   if (!arg2) {
46915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
46916     return ;
46917   }
46918   arg3 = (float)jarg3;
46919   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
46920   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
46921   {
46922     try {
46923       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
46924     } CALL_CATCH_EXCEPTION();
46925   }
46926
46927 }
46928
46929
46930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
46931   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46932   Dali::Vector2 *arg2 = 0 ;
46933   float arg3 ;
46934   Dali::AlphaFunction arg4 ;
46935   Dali::Toolkit::DirectionBias arg5 ;
46936   Dali::Toolkit::DirectionBias arg6 ;
46937   Dali::AlphaFunction *argp4 ;
46938
46939   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46940   arg2 = (Dali::Vector2 *)jarg2;
46941   if (!arg2) {
46942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
46943     return ;
46944   }
46945   arg3 = (float)jarg3;
46946   argp4 = (Dali::AlphaFunction *)jarg4;
46947   if (!argp4) {
46948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
46949     return ;
46950   }
46951   arg4 = *argp4;
46952   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
46953   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
46954   {
46955     try {
46956       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
46957     } CALL_CATCH_EXCEPTION();
46958   }
46959
46960 }
46961
46962
46963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
46964   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46965   unsigned int arg2 ;
46966
46967   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46968   arg2 = (unsigned int)jarg2;
46969   {
46970     try {
46971       (arg1)->ScrollTo(arg2);
46972     } CALL_CATCH_EXCEPTION();
46973   }
46974
46975 }
46976
46977
46978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
46979   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46980   unsigned int arg2 ;
46981   float arg3 ;
46982
46983   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46984   arg2 = (unsigned int)jarg2;
46985   arg3 = (float)jarg3;
46986   {
46987     try {
46988       (arg1)->ScrollTo(arg2,arg3);
46989     } CALL_CATCH_EXCEPTION();
46990   }
46991
46992 }
46993
46994
46995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
46996   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46997   unsigned int arg2 ;
46998   float arg3 ;
46999   Dali::Toolkit::DirectionBias arg4 ;
47000
47001   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47002   arg2 = (unsigned int)jarg2;
47003   arg3 = (float)jarg3;
47004   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
47005   {
47006     try {
47007       (arg1)->ScrollTo(arg2,arg3,arg4);
47008     } CALL_CATCH_EXCEPTION();
47009   }
47010
47011 }
47012
47013
47014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
47015   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47016   Dali::Actor *arg2 = 0 ;
47017
47018   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47019   arg2 = (Dali::Actor *)jarg2;
47020   if (!arg2) {
47021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
47022     return ;
47023   }
47024   {
47025     try {
47026       (arg1)->ScrollTo(*arg2);
47027     } CALL_CATCH_EXCEPTION();
47028   }
47029
47030 }
47031
47032
47033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
47034   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47035   Dali::Actor *arg2 = 0 ;
47036   float arg3 ;
47037
47038   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47039   arg2 = (Dali::Actor *)jarg2;
47040   if (!arg2) {
47041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
47042     return ;
47043   }
47044   arg3 = (float)jarg3;
47045   {
47046     try {
47047       (arg1)->ScrollTo(*arg2,arg3);
47048     } CALL_CATCH_EXCEPTION();
47049   }
47050
47051 }
47052
47053
47054 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
47055   bool jresult ;
47056   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47057   bool result;
47058
47059   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47060   {
47061     try {
47062       result = (bool)(arg1)->ScrollToSnapPoint();
47063     } CALL_CATCH_EXCEPTION(0);
47064   }
47065
47066   jresult = result;
47067   return jresult;
47068 }
47069
47070
47071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
47072   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47073   Dali::Constraint arg2 ;
47074   Dali::Constraint *argp2 ;
47075
47076   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47077   argp2 = (Dali::Constraint *)jarg2;
47078   if (!argp2) {
47079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
47080     return ;
47081   }
47082   arg2 = *argp2;
47083   {
47084     try {
47085       (arg1)->ApplyConstraintToChildren(arg2);
47086     } CALL_CATCH_EXCEPTION();
47087   }
47088
47089 }
47090
47091
47092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
47093   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47094
47095   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47096   {
47097     try {
47098       (arg1)->RemoveConstraintsFromChildren();
47099     } CALL_CATCH_EXCEPTION();
47100   }
47101
47102 }
47103
47104
47105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
47106   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47107   Dali::Toolkit::ScrollViewEffect arg2 ;
47108   Dali::Toolkit::ScrollViewEffect *argp2 ;
47109
47110   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47111   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
47112   if (!argp2) {
47113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
47114     return ;
47115   }
47116   arg2 = *argp2;
47117   {
47118     try {
47119       (arg1)->ApplyEffect(arg2);
47120     } CALL_CATCH_EXCEPTION();
47121   }
47122
47123 }
47124
47125
47126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
47127   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47128   Dali::Toolkit::ScrollViewEffect arg2 ;
47129   Dali::Toolkit::ScrollViewEffect *argp2 ;
47130
47131   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47132   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
47133   if (!argp2) {
47134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
47135     return ;
47136   }
47137   arg2 = *argp2;
47138   {
47139     try {
47140       (arg1)->RemoveEffect(arg2);
47141     } CALL_CATCH_EXCEPTION();
47142   }
47143
47144 }
47145
47146
47147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
47148   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47149
47150   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47151   {
47152     try {
47153       (arg1)->RemoveAllEffects();
47154     } CALL_CATCH_EXCEPTION();
47155   }
47156
47157 }
47158
47159
47160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
47161   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47162   Dali::Actor arg2 ;
47163   Dali::Actor *argp2 ;
47164
47165   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47166   argp2 = (Dali::Actor *)jarg2;
47167   if (!argp2) {
47168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47169     return ;
47170   }
47171   arg2 = *argp2;
47172   {
47173     try {
47174       (arg1)->BindActor(arg2);
47175     } CALL_CATCH_EXCEPTION();
47176   }
47177
47178 }
47179
47180
47181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
47182   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47183   Dali::Actor arg2 ;
47184   Dali::Actor *argp2 ;
47185
47186   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47187   argp2 = (Dali::Actor *)jarg2;
47188   if (!argp2) {
47189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47190     return ;
47191   }
47192   arg2 = *argp2;
47193   {
47194     try {
47195       (arg1)->UnbindActor(arg2);
47196     } CALL_CATCH_EXCEPTION();
47197   }
47198
47199 }
47200
47201
47202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
47203   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47204   Dali::Radian arg2 ;
47205   Dali::Radian arg3 ;
47206   Dali::Radian *argp2 ;
47207   Dali::Radian *argp3 ;
47208
47209   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47210   argp2 = (Dali::Radian *)jarg2;
47211   if (!argp2) {
47212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
47213     return ;
47214   }
47215   arg2 = *argp2;
47216   argp3 = (Dali::Radian *)jarg3;
47217   if (!argp3) {
47218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
47219     return ;
47220   }
47221   arg3 = *argp3;
47222   {
47223     try {
47224       (arg1)->SetScrollingDirection(arg2,arg3);
47225     } CALL_CATCH_EXCEPTION();
47226   }
47227
47228 }
47229
47230
47231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
47232   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47233   Dali::Radian arg2 ;
47234   Dali::Radian *argp2 ;
47235
47236   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47237   argp2 = (Dali::Radian *)jarg2;
47238   if (!argp2) {
47239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
47240     return ;
47241   }
47242   arg2 = *argp2;
47243   {
47244     try {
47245       (arg1)->SetScrollingDirection(arg2);
47246     } CALL_CATCH_EXCEPTION();
47247   }
47248
47249 }
47250
47251
47252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
47253   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47254   Dali::Radian arg2 ;
47255   Dali::Radian *argp2 ;
47256
47257   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47258   argp2 = (Dali::Radian *)jarg2;
47259   if (!argp2) {
47260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
47261     return ;
47262   }
47263   arg2 = *argp2;
47264   {
47265     try {
47266       (arg1)->RemoveScrollingDirection(arg2);
47267     } CALL_CATCH_EXCEPTION();
47268   }
47269
47270 }
47271
47272
47273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
47274   void * jresult ;
47275   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47276   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
47277
47278   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47279   {
47280     try {
47281       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
47282     } CALL_CATCH_EXCEPTION(0);
47283   }
47284
47285   jresult = (void *)result;
47286   return jresult;
47287 }
47288
47289
47290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
47291   int jresult ;
47292   int result;
47293
47294   result = (int)Dali::Toolkit::TableView::Property::ROWS;
47295   jresult = (int)result;
47296   return jresult;
47297 }
47298
47299
47300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
47301   int jresult ;
47302   int result;
47303
47304   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
47305   jresult = (int)result;
47306   return jresult;
47307 }
47308
47309
47310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
47311   int jresult ;
47312   int result;
47313
47314   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
47315   jresult = (int)result;
47316   return jresult;
47317 }
47318
47319
47320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
47321   int jresult ;
47322   int result;
47323
47324   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
47325   jresult = (int)result;
47326   return jresult;
47327 }
47328
47329
47330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
47331   int jresult ;
47332   int result;
47333
47334   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
47335   jresult = (int)result;
47336   return jresult;
47337 }
47338
47339
47340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
47341   void * jresult ;
47342   Dali::Toolkit::TableView::Property *result = 0 ;
47343
47344   {
47345     try {
47346       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
47347     } CALL_CATCH_EXCEPTION(0);
47348   }
47349
47350   jresult = (void *)result;
47351   return jresult;
47352 }
47353
47354
47355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
47356   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
47357
47358   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
47359   {
47360     try {
47361       delete arg1;
47362     } CALL_CATCH_EXCEPTION();
47363   }
47364
47365 }
47366
47367
47368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
47369   int jresult ;
47370   int result;
47371
47372   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
47373   jresult = (int)result;
47374   return jresult;
47375 }
47376
47377
47378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
47379   int jresult ;
47380   int result;
47381
47382   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
47383   jresult = (int)result;
47384   return jresult;
47385 }
47386
47387
47388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
47389   int jresult ;
47390   int result;
47391
47392   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
47393   jresult = (int)result;
47394   return jresult;
47395 }
47396
47397
47398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
47399   int jresult ;
47400   int result;
47401
47402   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
47403   jresult = (int)result;
47404   return jresult;
47405 }
47406
47407
47408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
47409   int jresult ;
47410   int result;
47411
47412   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
47413   jresult = (int)result;
47414   return jresult;
47415 }
47416
47417
47418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
47419   void * jresult ;
47420   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
47421
47422   {
47423     try {
47424       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
47425     } CALL_CATCH_EXCEPTION(0);
47426   }
47427
47428   jresult = (void *)result;
47429   return jresult;
47430 }
47431
47432
47433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
47434   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
47435
47436   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
47437   {
47438     try {
47439       delete arg1;
47440     } CALL_CATCH_EXCEPTION();
47441   }
47442
47443 }
47444
47445
47446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
47447   void * jresult ;
47448   unsigned int arg1 ;
47449   unsigned int arg2 ;
47450   unsigned int arg3 ;
47451   unsigned int arg4 ;
47452   Dali::Toolkit::TableView::CellPosition *result = 0 ;
47453
47454   arg1 = (unsigned int)jarg1;
47455   arg2 = (unsigned int)jarg2;
47456   arg3 = (unsigned int)jarg3;
47457   arg4 = (unsigned int)jarg4;
47458   {
47459     try {
47460       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
47461     } CALL_CATCH_EXCEPTION(0);
47462   }
47463
47464   jresult = (void *)result;
47465   return jresult;
47466 }
47467
47468
47469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
47470   void * jresult ;
47471   unsigned int arg1 ;
47472   unsigned int arg2 ;
47473   unsigned int arg3 ;
47474   Dali::Toolkit::TableView::CellPosition *result = 0 ;
47475
47476   arg1 = (unsigned int)jarg1;
47477   arg2 = (unsigned int)jarg2;
47478   arg3 = (unsigned int)jarg3;
47479   {
47480     try {
47481       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
47482     } CALL_CATCH_EXCEPTION(0);
47483   }
47484
47485   jresult = (void *)result;
47486   return jresult;
47487 }
47488
47489
47490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47491   void * jresult ;
47492   unsigned int arg1 ;
47493   unsigned int arg2 ;
47494   Dali::Toolkit::TableView::CellPosition *result = 0 ;
47495
47496   arg1 = (unsigned int)jarg1;
47497   arg2 = (unsigned int)jarg2;
47498   {
47499     try {
47500       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
47501     } CALL_CATCH_EXCEPTION(0);
47502   }
47503
47504   jresult = (void *)result;
47505   return jresult;
47506 }
47507
47508
47509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
47510   void * jresult ;
47511   unsigned int arg1 ;
47512   Dali::Toolkit::TableView::CellPosition *result = 0 ;
47513
47514   arg1 = (unsigned int)jarg1;
47515   {
47516     try {
47517       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
47518     } CALL_CATCH_EXCEPTION(0);
47519   }
47520
47521   jresult = (void *)result;
47522   return jresult;
47523 }
47524
47525
47526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
47527   void * jresult ;
47528   Dali::Toolkit::TableView::CellPosition *result = 0 ;
47529
47530   {
47531     try {
47532       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
47533     } CALL_CATCH_EXCEPTION(0);
47534   }
47535
47536   jresult = (void *)result;
47537   return jresult;
47538 }
47539
47540
47541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
47542   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
47543   unsigned int arg2 ;
47544
47545   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
47546   arg2 = (unsigned int)jarg2;
47547   if (arg1) (arg1)->rowIndex = arg2;
47548 }
47549
47550
47551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
47552   unsigned int jresult ;
47553   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
47554   unsigned int result;
47555
47556   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
47557   result = (unsigned int) ((arg1)->rowIndex);
47558   jresult = result;
47559   return jresult;
47560 }
47561
47562
47563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
47564   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
47565   unsigned int arg2 ;
47566
47567   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
47568   arg2 = (unsigned int)jarg2;
47569   if (arg1) (arg1)->columnIndex = arg2;
47570 }
47571
47572
47573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
47574   unsigned int jresult ;
47575   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
47576   unsigned int result;
47577
47578   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
47579   result = (unsigned int) ((arg1)->columnIndex);
47580   jresult = result;
47581   return jresult;
47582 }
47583
47584
47585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
47586   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
47587   unsigned int arg2 ;
47588
47589   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
47590   arg2 = (unsigned int)jarg2;
47591   if (arg1) (arg1)->rowSpan = arg2;
47592 }
47593
47594
47595 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
47596   unsigned int jresult ;
47597   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
47598   unsigned int result;
47599
47600   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
47601   result = (unsigned int) ((arg1)->rowSpan);
47602   jresult = result;
47603   return jresult;
47604 }
47605
47606
47607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
47608   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
47609   unsigned int arg2 ;
47610
47611   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
47612   arg2 = (unsigned int)jarg2;
47613   if (arg1) (arg1)->columnSpan = arg2;
47614 }
47615
47616
47617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
47618   unsigned int jresult ;
47619   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
47620   unsigned int result;
47621
47622   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
47623   result = (unsigned int) ((arg1)->columnSpan);
47624   jresult = result;
47625   return jresult;
47626 }
47627
47628
47629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
47630   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
47631
47632   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
47633   {
47634     try {
47635       delete arg1;
47636     } CALL_CATCH_EXCEPTION();
47637   }
47638
47639 }
47640
47641
47642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
47643   void * jresult ;
47644   Dali::Toolkit::TableView *result = 0 ;
47645
47646   {
47647     try {
47648       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
47649     } CALL_CATCH_EXCEPTION(0);
47650   }
47651
47652   jresult = (void *)result;
47653   return jresult;
47654 }
47655
47656
47657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
47658   void * jresult ;
47659   Dali::Toolkit::TableView *arg1 = 0 ;
47660   Dali::Toolkit::TableView *result = 0 ;
47661
47662   arg1 = (Dali::Toolkit::TableView *)jarg1;
47663   if (!arg1) {
47664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
47665     return 0;
47666   }
47667   {
47668     try {
47669       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
47670     } CALL_CATCH_EXCEPTION(0);
47671   }
47672
47673   jresult = (void *)result;
47674   return jresult;
47675 }
47676
47677
47678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
47679   void * jresult ;
47680   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47681   Dali::Toolkit::TableView *arg2 = 0 ;
47682   Dali::Toolkit::TableView *result = 0 ;
47683
47684   arg1 = (Dali::Toolkit::TableView *)jarg1;
47685   arg2 = (Dali::Toolkit::TableView *)jarg2;
47686   if (!arg2) {
47687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
47688     return 0;
47689   }
47690   {
47691     try {
47692       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
47693     } CALL_CATCH_EXCEPTION(0);
47694   }
47695
47696   jresult = (void *)result;
47697   return jresult;
47698 }
47699
47700
47701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
47702   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47703
47704   arg1 = (Dali::Toolkit::TableView *)jarg1;
47705   {
47706     try {
47707       delete arg1;
47708     } CALL_CATCH_EXCEPTION();
47709   }
47710
47711 }
47712
47713
47714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
47715   void * jresult ;
47716   unsigned int arg1 ;
47717   unsigned int arg2 ;
47718   Dali::Toolkit::TableView result;
47719
47720   arg1 = (unsigned int)jarg1;
47721   arg2 = (unsigned int)jarg2;
47722   {
47723     try {
47724       result = Dali::Toolkit::TableView::New(arg1,arg2);
47725     } CALL_CATCH_EXCEPTION(0);
47726   }
47727
47728   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
47729   return jresult;
47730 }
47731
47732
47733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
47734   void * jresult ;
47735   Dali::BaseHandle arg1 ;
47736   Dali::BaseHandle *argp1 ;
47737   Dali::Toolkit::TableView result;
47738
47739   argp1 = (Dali::BaseHandle *)jarg1;
47740   if (!argp1) {
47741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47742     return 0;
47743   }
47744   arg1 = *argp1;
47745   {
47746     try {
47747       result = Dali::Toolkit::TableView::DownCast(arg1);
47748     } CALL_CATCH_EXCEPTION(0);
47749   }
47750
47751   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
47752   return jresult;
47753 }
47754
47755
47756 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
47757   bool jresult ;
47758   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47759   Dali::Actor arg2 ;
47760   Dali::Toolkit::TableView::CellPosition arg3 ;
47761   Dali::Actor *argp2 ;
47762   Dali::Toolkit::TableView::CellPosition *argp3 ;
47763   bool result;
47764
47765   arg1 = (Dali::Toolkit::TableView *)jarg1;
47766   argp2 = (Dali::Actor *)jarg2;
47767   if (!argp2) {
47768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47769     return 0;
47770   }
47771   arg2 = *argp2;
47772   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
47773   if (!argp3) {
47774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
47775     return 0;
47776   }
47777   arg3 = *argp3;
47778   {
47779     try {
47780       result = (bool)(arg1)->AddChild(arg2,arg3);
47781     } CALL_CATCH_EXCEPTION(0);
47782   }
47783
47784   jresult = result;
47785   return jresult;
47786 }
47787
47788
47789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
47790   void * jresult ;
47791   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47792   Dali::Toolkit::TableView::CellPosition arg2 ;
47793   Dali::Toolkit::TableView::CellPosition *argp2 ;
47794   Dali::Actor result;
47795
47796   arg1 = (Dali::Toolkit::TableView *)jarg1;
47797   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
47798   if (!argp2) {
47799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
47800     return 0;
47801   }
47802   arg2 = *argp2;
47803   {
47804     try {
47805       result = (arg1)->GetChildAt(arg2);
47806     } CALL_CATCH_EXCEPTION(0);
47807   }
47808
47809   jresult = new Dali::Actor((const Dali::Actor &)result);
47810   return jresult;
47811 }
47812
47813
47814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
47815   void * jresult ;
47816   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47817   Dali::Toolkit::TableView::CellPosition arg2 ;
47818   Dali::Toolkit::TableView::CellPosition *argp2 ;
47819   Dali::Actor result;
47820
47821   arg1 = (Dali::Toolkit::TableView *)jarg1;
47822   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
47823   if (!argp2) {
47824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
47825     return 0;
47826   }
47827   arg2 = *argp2;
47828   {
47829     try {
47830       result = (arg1)->RemoveChildAt(arg2);
47831     } CALL_CATCH_EXCEPTION(0);
47832   }
47833
47834   jresult = new Dali::Actor((const Dali::Actor &)result);
47835   return jresult;
47836 }
47837
47838
47839 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
47840   bool jresult ;
47841   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47842   Dali::Actor arg2 ;
47843   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
47844   Dali::Actor *argp2 ;
47845   bool result;
47846
47847   arg1 = (Dali::Toolkit::TableView *)jarg1;
47848   argp2 = (Dali::Actor *)jarg2;
47849   if (!argp2) {
47850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47851     return 0;
47852   }
47853   arg2 = *argp2;
47854   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
47855   if (!arg3) {
47856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
47857     return 0;
47858   }
47859   {
47860     try {
47861       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
47862     } CALL_CATCH_EXCEPTION(0);
47863   }
47864
47865   jresult = result;
47866   return jresult;
47867 }
47868
47869
47870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
47871   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47872   unsigned int arg2 ;
47873
47874   arg1 = (Dali::Toolkit::TableView *)jarg1;
47875   arg2 = (unsigned int)jarg2;
47876   {
47877     try {
47878       (arg1)->InsertRow(arg2);
47879     } CALL_CATCH_EXCEPTION();
47880   }
47881
47882 }
47883
47884
47885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
47886   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47887   unsigned int arg2 ;
47888
47889   arg1 = (Dali::Toolkit::TableView *)jarg1;
47890   arg2 = (unsigned int)jarg2;
47891   {
47892     try {
47893       (arg1)->DeleteRow(arg2);
47894     } CALL_CATCH_EXCEPTION();
47895   }
47896
47897 }
47898
47899
47900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
47901   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47902   unsigned int arg2 ;
47903   std::vector< Dali::Actor > *arg3 = 0 ;
47904
47905   arg1 = (Dali::Toolkit::TableView *)jarg1;
47906   arg2 = (unsigned int)jarg2;
47907   arg3 = (std::vector< Dali::Actor > *)jarg3;
47908   if (!arg3) {
47909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
47910     return ;
47911   }
47912   {
47913     try {
47914       (arg1)->DeleteRow(arg2,*arg3);
47915     } CALL_CATCH_EXCEPTION();
47916   }
47917
47918 }
47919
47920
47921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
47922   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47923   unsigned int arg2 ;
47924
47925   arg1 = (Dali::Toolkit::TableView *)jarg1;
47926   arg2 = (unsigned int)jarg2;
47927   {
47928     try {
47929       (arg1)->InsertColumn(arg2);
47930     } CALL_CATCH_EXCEPTION();
47931   }
47932
47933 }
47934
47935
47936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
47937   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47938   unsigned int arg2 ;
47939
47940   arg1 = (Dali::Toolkit::TableView *)jarg1;
47941   arg2 = (unsigned int)jarg2;
47942   {
47943     try {
47944       (arg1)->DeleteColumn(arg2);
47945     } CALL_CATCH_EXCEPTION();
47946   }
47947
47948 }
47949
47950
47951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
47952   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47953   unsigned int arg2 ;
47954   std::vector< Dali::Actor > *arg3 = 0 ;
47955
47956   arg1 = (Dali::Toolkit::TableView *)jarg1;
47957   arg2 = (unsigned int)jarg2;
47958   arg3 = (std::vector< Dali::Actor > *)jarg3;
47959   if (!arg3) {
47960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
47961     return ;
47962   }
47963   {
47964     try {
47965       (arg1)->DeleteColumn(arg2,*arg3);
47966     } CALL_CATCH_EXCEPTION();
47967   }
47968
47969 }
47970
47971
47972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
47973   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47974   unsigned int arg2 ;
47975   unsigned int arg3 ;
47976
47977   arg1 = (Dali::Toolkit::TableView *)jarg1;
47978   arg2 = (unsigned int)jarg2;
47979   arg3 = (unsigned int)jarg3;
47980   {
47981     try {
47982       (arg1)->Resize(arg2,arg3);
47983     } CALL_CATCH_EXCEPTION();
47984   }
47985
47986 }
47987
47988
47989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
47990   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47991   unsigned int arg2 ;
47992   unsigned int arg3 ;
47993   std::vector< Dali::Actor > *arg4 = 0 ;
47994
47995   arg1 = (Dali::Toolkit::TableView *)jarg1;
47996   arg2 = (unsigned int)jarg2;
47997   arg3 = (unsigned int)jarg3;
47998   arg4 = (std::vector< Dali::Actor > *)jarg4;
47999   if (!arg4) {
48000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
48001     return ;
48002   }
48003   {
48004     try {
48005       (arg1)->Resize(arg2,arg3,*arg4);
48006     } CALL_CATCH_EXCEPTION();
48007   }
48008
48009 }
48010
48011
48012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
48013   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48014   Dali::Size arg2 ;
48015   Dali::Size *argp2 ;
48016
48017   arg1 = (Dali::Toolkit::TableView *)jarg1;
48018   argp2 = (Dali::Size *)jarg2;
48019   if (!argp2) {
48020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
48021     return ;
48022   }
48023   arg2 = *argp2;
48024   {
48025     try {
48026       (arg1)->SetCellPadding(arg2);
48027     } CALL_CATCH_EXCEPTION();
48028   }
48029
48030 }
48031
48032
48033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
48034   void * jresult ;
48035   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48036   Dali::Size result;
48037
48038   arg1 = (Dali::Toolkit::TableView *)jarg1;
48039   {
48040     try {
48041       result = (arg1)->GetCellPadding();
48042     } CALL_CATCH_EXCEPTION(0);
48043   }
48044
48045   jresult = new Dali::Size((const Dali::Size &)result);
48046   return jresult;
48047 }
48048
48049
48050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
48051   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48052   unsigned int arg2 ;
48053
48054   arg1 = (Dali::Toolkit::TableView *)jarg1;
48055   arg2 = (unsigned int)jarg2;
48056   {
48057     try {
48058       (arg1)->SetFitHeight(arg2);
48059     } CALL_CATCH_EXCEPTION();
48060   }
48061
48062 }
48063
48064
48065 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
48066   bool jresult ;
48067   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48068   unsigned int arg2 ;
48069   bool result;
48070
48071   arg1 = (Dali::Toolkit::TableView *)jarg1;
48072   arg2 = (unsigned int)jarg2;
48073   {
48074     try {
48075       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
48076     } CALL_CATCH_EXCEPTION(0);
48077   }
48078
48079   jresult = result;
48080   return jresult;
48081 }
48082
48083
48084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
48085   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48086   unsigned int arg2 ;
48087
48088   arg1 = (Dali::Toolkit::TableView *)jarg1;
48089   arg2 = (unsigned int)jarg2;
48090   {
48091     try {
48092       (arg1)->SetFitWidth(arg2);
48093     } CALL_CATCH_EXCEPTION();
48094   }
48095
48096 }
48097
48098
48099 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
48100   bool jresult ;
48101   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48102   unsigned int arg2 ;
48103   bool result;
48104
48105   arg1 = (Dali::Toolkit::TableView *)jarg1;
48106   arg2 = (unsigned int)jarg2;
48107   {
48108     try {
48109       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
48110     } CALL_CATCH_EXCEPTION(0);
48111   }
48112
48113   jresult = result;
48114   return jresult;
48115 }
48116
48117
48118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
48119   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48120   unsigned int arg2 ;
48121   float arg3 ;
48122
48123   arg1 = (Dali::Toolkit::TableView *)jarg1;
48124   arg2 = (unsigned int)jarg2;
48125   arg3 = (float)jarg3;
48126   {
48127     try {
48128       (arg1)->SetFixedHeight(arg2,arg3);
48129     } CALL_CATCH_EXCEPTION();
48130   }
48131
48132 }
48133
48134
48135 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
48136   float jresult ;
48137   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48138   unsigned int arg2 ;
48139   float result;
48140
48141   arg1 = (Dali::Toolkit::TableView *)jarg1;
48142   arg2 = (unsigned int)jarg2;
48143   {
48144     try {
48145       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
48146     } CALL_CATCH_EXCEPTION(0);
48147   }
48148
48149   jresult = result;
48150   return jresult;
48151 }
48152
48153
48154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
48155   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48156   unsigned int arg2 ;
48157   float arg3 ;
48158
48159   arg1 = (Dali::Toolkit::TableView *)jarg1;
48160   arg2 = (unsigned int)jarg2;
48161   arg3 = (float)jarg3;
48162   {
48163     try {
48164       (arg1)->SetRelativeHeight(arg2,arg3);
48165     } CALL_CATCH_EXCEPTION();
48166   }
48167
48168 }
48169
48170
48171 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
48172   float jresult ;
48173   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48174   unsigned int arg2 ;
48175   float result;
48176
48177   arg1 = (Dali::Toolkit::TableView *)jarg1;
48178   arg2 = (unsigned int)jarg2;
48179   {
48180     try {
48181       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
48182     } CALL_CATCH_EXCEPTION(0);
48183   }
48184
48185   jresult = result;
48186   return jresult;
48187 }
48188
48189
48190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
48191   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48192   unsigned int arg2 ;
48193   float arg3 ;
48194
48195   arg1 = (Dali::Toolkit::TableView *)jarg1;
48196   arg2 = (unsigned int)jarg2;
48197   arg3 = (float)jarg3;
48198   {
48199     try {
48200       (arg1)->SetFixedWidth(arg2,arg3);
48201     } CALL_CATCH_EXCEPTION();
48202   }
48203
48204 }
48205
48206
48207 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
48208   float jresult ;
48209   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48210   unsigned int arg2 ;
48211   float result;
48212
48213   arg1 = (Dali::Toolkit::TableView *)jarg1;
48214   arg2 = (unsigned int)jarg2;
48215   {
48216     try {
48217       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
48218     } CALL_CATCH_EXCEPTION(0);
48219   }
48220
48221   jresult = result;
48222   return jresult;
48223 }
48224
48225
48226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
48227   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48228   unsigned int arg2 ;
48229   float arg3 ;
48230
48231   arg1 = (Dali::Toolkit::TableView *)jarg1;
48232   arg2 = (unsigned int)jarg2;
48233   arg3 = (float)jarg3;
48234   {
48235     try {
48236       (arg1)->SetRelativeWidth(arg2,arg3);
48237     } CALL_CATCH_EXCEPTION();
48238   }
48239
48240 }
48241
48242
48243 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
48244   float jresult ;
48245   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48246   unsigned int arg2 ;
48247   float result;
48248
48249   arg1 = (Dali::Toolkit::TableView *)jarg1;
48250   arg2 = (unsigned int)jarg2;
48251   {
48252     try {
48253       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
48254     } CALL_CATCH_EXCEPTION(0);
48255   }
48256
48257   jresult = result;
48258   return jresult;
48259 }
48260
48261
48262 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
48263   unsigned int jresult ;
48264   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48265   unsigned int result;
48266
48267   arg1 = (Dali::Toolkit::TableView *)jarg1;
48268   {
48269     try {
48270       result = (unsigned int)(arg1)->GetRows();
48271     } CALL_CATCH_EXCEPTION(0);
48272   }
48273
48274   jresult = result;
48275   return jresult;
48276 }
48277
48278
48279 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
48280   unsigned int jresult ;
48281   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48282   unsigned int result;
48283
48284   arg1 = (Dali::Toolkit::TableView *)jarg1;
48285   {
48286     try {
48287       result = (unsigned int)(arg1)->GetColumns();
48288     } CALL_CATCH_EXCEPTION(0);
48289   }
48290
48291   jresult = result;
48292   return jresult;
48293 }
48294
48295
48296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
48297   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48298   Dali::Toolkit::TableView::CellPosition arg2 ;
48299   Dali::HorizontalAlignment::Type arg3 ;
48300   Dali::VerticalAlignment::Type arg4 ;
48301   Dali::Toolkit::TableView::CellPosition *argp2 ;
48302
48303   arg1 = (Dali::Toolkit::TableView *)jarg1;
48304   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
48305   if (!argp2) {
48306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
48307     return ;
48308   }
48309   arg2 = *argp2;
48310   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
48311   arg4 = (Dali::VerticalAlignment::Type)jarg4;
48312   {
48313     try {
48314       (arg1)->SetCellAlignment(arg2,arg3,arg4);
48315     } CALL_CATCH_EXCEPTION();
48316   }
48317
48318 }
48319
48320
48321 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
48322   unsigned int jresult ;
48323   unsigned int result;
48324
48325   result = (unsigned int)(unsigned int)Dali::Toolkit::DevelText::DEFAULT_RENDERING_BACKEND;
48326   jresult = result;
48327   return jresult;
48328 }
48329
48330
48331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
48332   int jresult ;
48333   int result;
48334
48335   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
48336   jresult = (int)result;
48337   return jresult;
48338 }
48339
48340
48341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
48342   int jresult ;
48343   int result;
48344
48345   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
48346   jresult = (int)result;
48347   return jresult;
48348 }
48349
48350
48351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
48352   int jresult ;
48353   int result;
48354
48355   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
48356   jresult = (int)result;
48357   return jresult;
48358 }
48359
48360
48361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
48362   int jresult ;
48363   int result;
48364
48365   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
48366   jresult = (int)result;
48367   return jresult;
48368 }
48369
48370
48371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
48372   int jresult ;
48373   int result;
48374
48375   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
48376   jresult = (int)result;
48377   return jresult;
48378 }
48379
48380
48381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
48382   int jresult ;
48383   int result;
48384
48385   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
48386   jresult = (int)result;
48387   return jresult;
48388 }
48389
48390
48391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
48392   int jresult ;
48393   int result;
48394
48395   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
48396   jresult = (int)result;
48397   return jresult;
48398 }
48399
48400
48401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
48402   int jresult ;
48403   int result;
48404
48405   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
48406   jresult = (int)result;
48407   return jresult;
48408 }
48409
48410
48411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
48412   int jresult ;
48413   int result;
48414
48415   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
48416   jresult = (int)result;
48417   return jresult;
48418 }
48419
48420
48421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
48422   int jresult ;
48423   int result;
48424
48425   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
48426   jresult = (int)result;
48427   return jresult;
48428 }
48429
48430
48431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
48432   int jresult ;
48433   int result;
48434
48435   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
48436   jresult = (int)result;
48437   return jresult;
48438 }
48439
48440
48441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
48442   int jresult ;
48443   int result;
48444
48445   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
48446   jresult = (int)result;
48447   return jresult;
48448 }
48449
48450
48451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
48452   int jresult ;
48453   int result;
48454
48455   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
48456   jresult = (int)result;
48457   return jresult;
48458 }
48459
48460
48461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
48462   int jresult ;
48463   int result;
48464
48465   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
48466   jresult = (int)result;
48467   return jresult;
48468 }
48469
48470
48471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
48472   int jresult ;
48473   int result;
48474
48475   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
48476   jresult = (int)result;
48477   return jresult;
48478 }
48479
48480
48481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
48482   int jresult ;
48483   int result;
48484
48485   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
48486   jresult = (int)result;
48487   return jresult;
48488 }
48489
48490
48491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
48492   int jresult ;
48493   int result;
48494
48495   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
48496   jresult = (int)result;
48497   return jresult;
48498 }
48499
48500
48501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
48502   int jresult ;
48503   int result;
48504
48505   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
48506   jresult = (int)result;
48507   return jresult;
48508 }
48509
48510
48511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
48512   void * jresult ;
48513   Dali::Toolkit::TextLabel::Property *result = 0 ;
48514
48515   {
48516     try {
48517       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
48518     } CALL_CATCH_EXCEPTION(0);
48519   }
48520
48521   jresult = (void *)result;
48522   return jresult;
48523 }
48524
48525
48526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
48527   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
48528
48529   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
48530   {
48531     try {
48532       delete arg1;
48533     } CALL_CATCH_EXCEPTION();
48534   }
48535
48536 }
48537
48538
48539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
48540   void * jresult ;
48541   Dali::Toolkit::TextLabel result;
48542
48543   {
48544     try {
48545       result = Dali::Toolkit::TextLabel::New();
48546     } CALL_CATCH_EXCEPTION(0);
48547   }
48548
48549   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
48550   return jresult;
48551 }
48552
48553
48554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * text) {
48555   void * jresult ;
48556   std::string *arg1 = 0 ;
48557   Dali::Toolkit::TextLabel result;
48558
48559   if (!text) {
48560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48561     return 0;
48562   }
48563   std::string arg1_str(text);
48564   arg1 = &arg1_str;
48565   {
48566     try {
48567       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
48568     } CALL_CATCH_EXCEPTION(0);
48569   }
48570
48571   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
48572
48573   //argout typemap for const std::string&
48574
48575   return jresult;
48576 }
48577
48578
48579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New_With_Style(bool hasStyle) {
48580   void * jresult ;
48581   Dali::Toolkit::TextLabel result;
48582
48583   {
48584     try {
48585       if (hasStyle) {
48586         result = Dali::Toolkit::TextLabel::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
48587       } else {
48588         result = Dali::Toolkit::TextLabel::New();
48589       }
48590     } CALL_CATCH_EXCEPTION(0);
48591   }
48592
48593   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
48594   return jresult;
48595 }
48596
48597
48598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New_With_String_Style(char * text, bool hasStyle) {
48599   void * jresult ;
48600   std::string *arg1 = 0 ;
48601   Dali::Toolkit::TextLabel result;
48602
48603   if (!text) {
48604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48605     return 0;
48606   }
48607   std::string arg1_str(text);
48608   arg1 = &arg1_str;
48609   {
48610     try {
48611       if (hasStyle) {
48612         result = Dali::Toolkit::TextLabel::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS, (std::string const &)*arg1);
48613       } else {
48614         result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
48615       }
48616     } CALL_CATCH_EXCEPTION(0);
48617   }
48618
48619   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
48620
48621   //argout typemap for const std::string&
48622
48623   return jresult;
48624 }
48625
48626
48627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
48628   void * jresult ;
48629   Dali::Toolkit::TextLabel *result = 0 ;
48630
48631   {
48632     try {
48633       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
48634     } CALL_CATCH_EXCEPTION(0);
48635   }
48636
48637   jresult = (void *)result;
48638   return jresult;
48639 }
48640
48641
48642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
48643   void * jresult ;
48644   Dali::Toolkit::TextLabel *arg1 = 0 ;
48645   Dali::Toolkit::TextLabel *result = 0 ;
48646
48647   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
48648   if (!arg1) {
48649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
48650     return 0;
48651   }
48652   {
48653     try {
48654       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
48655     } CALL_CATCH_EXCEPTION(0);
48656   }
48657
48658   jresult = (void *)result;
48659   return jresult;
48660 }
48661
48662
48663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
48664   void * jresult ;
48665   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
48666   Dali::Toolkit::TextLabel *arg2 = 0 ;
48667   Dali::Toolkit::TextLabel *result = 0 ;
48668
48669   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
48670   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
48671   if (!arg2) {
48672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
48673     return 0;
48674   }
48675   {
48676     try {
48677       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
48678     } CALL_CATCH_EXCEPTION(0);
48679   }
48680
48681   jresult = (void *)result;
48682   return jresult;
48683 }
48684
48685
48686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
48687   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
48688
48689   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
48690   {
48691     try {
48692       delete arg1;
48693     } CALL_CATCH_EXCEPTION();
48694   }
48695
48696 }
48697
48698
48699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
48700   void * jresult ;
48701   Dali::BaseHandle arg1 ;
48702   Dali::BaseHandle *argp1 ;
48703   Dali::Toolkit::TextLabel result;
48704
48705   argp1 = (Dali::BaseHandle *)jarg1;
48706   if (!argp1) {
48707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48708     return 0;
48709   }
48710   arg1 = *argp1;
48711   {
48712     try {
48713       result = Dali::Toolkit::TextLabel::DownCast(arg1);
48714     } CALL_CATCH_EXCEPTION(0);
48715   }
48716
48717   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
48718   return jresult;
48719 }
48720
48721
48722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
48723   void * jresult ;
48724   Dali::Toolkit::AccessibilityManager *result = 0 ;
48725
48726   {
48727     try {
48728       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
48729     } CALL_CATCH_EXCEPTION(0);
48730   }
48731
48732   jresult = (void *)result;
48733   return jresult;
48734 }
48735
48736
48737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
48738   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48739
48740   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48741   {
48742     try {
48743       delete arg1;
48744     } CALL_CATCH_EXCEPTION();
48745   }
48746
48747 }
48748
48749
48750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
48751   void * jresult ;
48752   Dali::Toolkit::AccessibilityManager result;
48753
48754   {
48755     try {
48756       result = Dali::Toolkit::AccessibilityManager::Get();
48757     } CALL_CATCH_EXCEPTION(0);
48758   }
48759
48760   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
48761   return jresult;
48762 }
48763
48764
48765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
48766   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48767   Dali::Actor arg2 ;
48768   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
48769   std::string *arg4 = 0 ;
48770   Dali::Actor *argp2 ;
48771
48772   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48773   argp2 = (Dali::Actor *)jarg2;
48774   if (!argp2) {
48775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48776     return ;
48777   }
48778   arg2 = *argp2;
48779   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
48780   if (!jarg4) {
48781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48782     return ;
48783   }
48784   std::string arg4_str(jarg4);
48785   arg4 = &arg4_str;
48786   {
48787     try {
48788       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
48789     } CALL_CATCH_EXCEPTION();
48790   }
48791
48792
48793   //argout typemap for const std::string&
48794
48795 }
48796
48797
48798 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
48799   char * jresult ;
48800   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48801   Dali::Actor arg2 ;
48802   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
48803   Dali::Actor *argp2 ;
48804   std::string result;
48805
48806   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48807   argp2 = (Dali::Actor *)jarg2;
48808   if (!argp2) {
48809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48810     return 0;
48811   }
48812   arg2 = *argp2;
48813   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
48814   {
48815     try {
48816       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
48817     } CALL_CATCH_EXCEPTION(0);
48818   }
48819
48820   jresult = SWIG_csharp_string_callback((&result)->c_str());
48821   return jresult;
48822 }
48823
48824
48825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
48826   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48827   Dali::Actor arg2 ;
48828   unsigned int arg3 ;
48829   Dali::Actor *argp2 ;
48830
48831   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48832   argp2 = (Dali::Actor *)jarg2;
48833   if (!argp2) {
48834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48835     return ;
48836   }
48837   arg2 = *argp2;
48838   arg3 = (unsigned int)jarg3;
48839   {
48840     try {
48841       (arg1)->SetFocusOrder(arg2,arg3);
48842     } CALL_CATCH_EXCEPTION();
48843   }
48844
48845 }
48846
48847
48848 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
48849   unsigned int jresult ;
48850   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48851   Dali::Actor arg2 ;
48852   Dali::Actor *argp2 ;
48853   unsigned int result;
48854
48855   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48856   argp2 = (Dali::Actor *)jarg2;
48857   if (!argp2) {
48858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48859     return 0;
48860   }
48861   arg2 = *argp2;
48862   {
48863     try {
48864       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
48865     } CALL_CATCH_EXCEPTION(0);
48866   }
48867
48868   jresult = result;
48869   return jresult;
48870 }
48871
48872
48873 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
48874   unsigned int jresult ;
48875   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48876   unsigned int result;
48877
48878   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48879   {
48880     try {
48881       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
48882     } CALL_CATCH_EXCEPTION(0);
48883   }
48884
48885   jresult = result;
48886   return jresult;
48887 }
48888
48889
48890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
48891   void * jresult ;
48892   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48893   unsigned int arg2 ;
48894   Dali::Actor result;
48895
48896   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48897   arg2 = (unsigned int)jarg2;
48898   {
48899     try {
48900       result = (arg1)->GetActorByFocusOrder(arg2);
48901     } CALL_CATCH_EXCEPTION(0);
48902   }
48903
48904   jresult = new Dali::Actor((const Dali::Actor &)result);
48905   return jresult;
48906 }
48907
48908
48909 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
48910   bool jresult ;
48911   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48912   Dali::Actor arg2 ;
48913   Dali::Actor *argp2 ;
48914   bool result;
48915
48916   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48917   argp2 = (Dali::Actor *)jarg2;
48918   if (!argp2) {
48919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48920     return 0;
48921   }
48922   arg2 = *argp2;
48923   {
48924     try {
48925       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
48926     } CALL_CATCH_EXCEPTION(0);
48927   }
48928
48929   jresult = result;
48930   return jresult;
48931 }
48932
48933
48934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
48935   void * jresult ;
48936   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48937   Dali::Actor result;
48938
48939   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48940   {
48941     try {
48942       result = (arg1)->GetCurrentFocusActor();
48943     } CALL_CATCH_EXCEPTION(0);
48944   }
48945
48946   jresult = new Dali::Actor((const Dali::Actor &)result);
48947   return jresult;
48948 }
48949
48950
48951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
48952   void * jresult ;
48953   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48954   Dali::Actor result;
48955
48956   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48957   {
48958     try {
48959       result = (arg1)->GetCurrentFocusGroup();
48960     } CALL_CATCH_EXCEPTION(0);
48961   }
48962
48963   jresult = new Dali::Actor((const Dali::Actor &)result);
48964   return jresult;
48965 }
48966
48967
48968 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
48969   unsigned int jresult ;
48970   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48971   unsigned int result;
48972
48973   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48974   {
48975     try {
48976       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
48977     } CALL_CATCH_EXCEPTION(0);
48978   }
48979
48980   jresult = result;
48981   return jresult;
48982 }
48983
48984
48985 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
48986   bool jresult ;
48987   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48988   bool result;
48989
48990   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48991   {
48992     try {
48993       result = (bool)(arg1)->MoveFocusForward();
48994     } CALL_CATCH_EXCEPTION(0);
48995   }
48996
48997   jresult = result;
48998   return jresult;
48999 }
49000
49001
49002 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
49003   bool jresult ;
49004   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49005   bool result;
49006
49007   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49008   {
49009     try {
49010       result = (bool)(arg1)->MoveFocusBackward();
49011     } CALL_CATCH_EXCEPTION(0);
49012   }
49013
49014   jresult = result;
49015   return jresult;
49016 }
49017
49018
49019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
49020   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49021
49022   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49023   {
49024     try {
49025       (arg1)->ClearFocus();
49026     } CALL_CATCH_EXCEPTION();
49027   }
49028
49029 }
49030
49031
49032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
49033   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49034
49035   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49036   {
49037     try {
49038       (arg1)->Reset();
49039     } CALL_CATCH_EXCEPTION();
49040   }
49041
49042 }
49043
49044
49045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, bool jarg3) {
49046   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49047   Dali::Actor arg2 ;
49048   bool arg3 ;
49049   Dali::Actor *argp2 ;
49050
49051   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49052   argp2 = (Dali::Actor *)jarg2;
49053   if (!argp2) {
49054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49055     return ;
49056   }
49057   arg2 = *argp2;
49058   arg3 = jarg3 ? true : false;
49059   {
49060     try {
49061       (arg1)->SetFocusGroup(arg2,arg3);
49062     } CALL_CATCH_EXCEPTION();
49063   }
49064
49065 }
49066
49067
49068 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
49069   bool jresult ;
49070   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49071   Dali::Actor arg2 ;
49072   Dali::Actor *argp2 ;
49073   bool result;
49074
49075   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49076   argp2 = (Dali::Actor *)jarg2;
49077   if (!argp2) {
49078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49079     return 0;
49080   }
49081   arg2 = *argp2;
49082   {
49083     try {
49084       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
49085     } CALL_CATCH_EXCEPTION(0);
49086   }
49087
49088   jresult = result;
49089   return jresult;
49090 }
49091
49092
49093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, bool jarg2) {
49094   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49095   bool arg2 ;
49096
49097   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49098   arg2 = jarg2 ? true : false;
49099   {
49100     try {
49101       (arg1)->SetGroupMode(arg2);
49102     } CALL_CATCH_EXCEPTION();
49103   }
49104
49105 }
49106
49107
49108 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
49109   bool jresult ;
49110   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49111   bool result;
49112
49113   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49114   {
49115     try {
49116       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
49117     } CALL_CATCH_EXCEPTION(0);
49118   }
49119
49120   jresult = result;
49121   return jresult;
49122 }
49123
49124
49125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, bool jarg2) {
49126   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49127   bool arg2 ;
49128
49129   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49130   arg2 = jarg2 ? true : false;
49131   {
49132     try {
49133       (arg1)->SetWrapMode(arg2);
49134     } CALL_CATCH_EXCEPTION();
49135   }
49136
49137 }
49138
49139
49140 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
49141   bool jresult ;
49142   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49143   bool result;
49144
49145   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49146   {
49147     try {
49148       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
49149     } CALL_CATCH_EXCEPTION(0);
49150   }
49151
49152   jresult = result;
49153   return jresult;
49154 }
49155
49156
49157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
49158   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49159   Dali::Actor arg2 ;
49160   Dali::Actor *argp2 ;
49161
49162   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49163   argp2 = (Dali::Actor *)jarg2;
49164   if (!argp2) {
49165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49166     return ;
49167   }
49168   arg2 = *argp2;
49169   {
49170     try {
49171       (arg1)->SetFocusIndicatorActor(arg2);
49172     } CALL_CATCH_EXCEPTION();
49173   }
49174
49175 }
49176
49177
49178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
49179   void * jresult ;
49180   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49181   Dali::Actor result;
49182
49183   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49184   {
49185     try {
49186       result = (arg1)->GetFocusIndicatorActor();
49187     } CALL_CATCH_EXCEPTION(0);
49188   }
49189
49190   jresult = new Dali::Actor((const Dali::Actor &)result);
49191   return jresult;
49192 }
49193
49194
49195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
49196   void * jresult ;
49197   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49198   Dali::Actor arg2 ;
49199   Dali::Actor *argp2 ;
49200   Dali::Actor result;
49201
49202   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49203   argp2 = (Dali::Actor *)jarg2;
49204   if (!argp2) {
49205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49206     return 0;
49207   }
49208   arg2 = *argp2;
49209   {
49210     try {
49211       result = (arg1)->GetFocusGroup(arg2);
49212     } CALL_CATCH_EXCEPTION(0);
49213   }
49214
49215   jresult = new Dali::Actor((const Dali::Actor &)result);
49216   return jresult;
49217 }
49218
49219
49220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
49221   void * jresult ;
49222   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49223   Dali::Vector2 result;
49224
49225   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49226   {
49227     try {
49228       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
49229     } CALL_CATCH_EXCEPTION(0);
49230   }
49231
49232   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
49233   return jresult;
49234 }
49235
49236
49237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
49238   void * jresult ;
49239   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49240   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
49241
49242   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49243   {
49244     try {
49245       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
49246     } CALL_CATCH_EXCEPTION(0);
49247   }
49248
49249   jresult = (void *)result;
49250   return jresult;
49251 }
49252
49253
49254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
49255   void * jresult ;
49256   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49257   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
49258
49259   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49260   {
49261     try {
49262       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
49263     } CALL_CATCH_EXCEPTION(0);
49264   }
49265
49266   jresult = (void *)result;
49267   return jresult;
49268 }
49269
49270
49271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
49272   void * jresult ;
49273   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49274   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
49275
49276   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49277   {
49278     try {
49279       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
49280     } CALL_CATCH_EXCEPTION(0);
49281   }
49282
49283   jresult = (void *)result;
49284   return jresult;
49285 }
49286
49287
49288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
49289   void * jresult ;
49290   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49291   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49292
49293   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49294   {
49295     try {
49296       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
49297     } CALL_CATCH_EXCEPTION(0);
49298   }
49299
49300   jresult = (void *)result;
49301   return jresult;
49302 }
49303
49304
49305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
49306   void * jresult ;
49307   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49308   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49309
49310   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49311   {
49312     try {
49313       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
49314     } CALL_CATCH_EXCEPTION(0);
49315   }
49316
49317   jresult = (void *)result;
49318   return jresult;
49319 }
49320
49321
49322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
49323   void * jresult ;
49324   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49325   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49326
49327   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49328   {
49329     try {
49330       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
49331     } CALL_CATCH_EXCEPTION(0);
49332   }
49333
49334   jresult = (void *)result;
49335   return jresult;
49336 }
49337
49338
49339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
49340   void * jresult ;
49341   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49342   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49343
49344   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49345   {
49346     try {
49347       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
49348     } CALL_CATCH_EXCEPTION(0);
49349   }
49350
49351   jresult = (void *)result;
49352   return jresult;
49353 }
49354
49355
49356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
49357   void * jresult ;
49358   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49359   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49360
49361   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49362   {
49363     try {
49364       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
49365     } CALL_CATCH_EXCEPTION(0);
49366   }
49367
49368   jresult = (void *)result;
49369   return jresult;
49370 }
49371
49372
49373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
49374   void * jresult ;
49375   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49376   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49377
49378   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49379   {
49380     try {
49381       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
49382     } CALL_CATCH_EXCEPTION(0);
49383   }
49384
49385   jresult = (void *)result;
49386   return jresult;
49387 }
49388
49389
49390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
49391   void * jresult ;
49392   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49393   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49394
49395   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49396   {
49397     try {
49398       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
49399     } CALL_CATCH_EXCEPTION(0);
49400   }
49401
49402   jresult = (void *)result;
49403   return jresult;
49404 }
49405
49406
49407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
49408   void * jresult ;
49409   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49410   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49411
49412   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49413   {
49414     try {
49415       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
49416     } CALL_CATCH_EXCEPTION(0);
49417   }
49418
49419   jresult = (void *)result;
49420   return jresult;
49421 }
49422
49423
49424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
49425   void * jresult ;
49426   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49427   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49428
49429   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49430   {
49431     try {
49432       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
49433     } CALL_CATCH_EXCEPTION(0);
49434   }
49435
49436   jresult = (void *)result;
49437   return jresult;
49438 }
49439
49440
49441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
49442   void * jresult ;
49443   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49444   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49445
49446   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49447   {
49448     try {
49449       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
49450     } CALL_CATCH_EXCEPTION(0);
49451   }
49452
49453   jresult = (void *)result;
49454   return jresult;
49455 }
49456
49457
49458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
49459   void * jresult ;
49460   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49461   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49462
49463   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49464   {
49465     try {
49466       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
49467     } CALL_CATCH_EXCEPTION(0);
49468   }
49469
49470   jresult = (void *)result;
49471   return jresult;
49472 }
49473
49474
49475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
49476   void * jresult ;
49477   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49478   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49479
49480   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49481   {
49482     try {
49483       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
49484     } CALL_CATCH_EXCEPTION(0);
49485   }
49486
49487   jresult = (void *)result;
49488   return jresult;
49489 }
49490
49491
49492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
49493   void * jresult ;
49494   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49495   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49496
49497   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49498   {
49499     try {
49500       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
49501     } CALL_CATCH_EXCEPTION(0);
49502   }
49503
49504   jresult = (void *)result;
49505   return jresult;
49506 }
49507
49508
49509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
49510   void * jresult ;
49511   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49512   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49513
49514   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49515   {
49516     try {
49517       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
49518     } CALL_CATCH_EXCEPTION(0);
49519   }
49520
49521   jresult = (void *)result;
49522   return jresult;
49523 }
49524
49525
49526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
49527   void * jresult ;
49528   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49529   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49530
49531   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49532   {
49533     try {
49534       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
49535     } CALL_CATCH_EXCEPTION(0);
49536   }
49537
49538   jresult = (void *)result;
49539   return jresult;
49540 }
49541
49542
49543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
49544   void * jresult ;
49545   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49546   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49547
49548   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49549   {
49550     try {
49551       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
49552     } CALL_CATCH_EXCEPTION(0);
49553   }
49554
49555   jresult = (void *)result;
49556   return jresult;
49557 }
49558
49559
49560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
49561   void * jresult ;
49562   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49563   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49564
49565   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49566   {
49567     try {
49568       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
49569     } CALL_CATCH_EXCEPTION(0);
49570   }
49571
49572   jresult = (void *)result;
49573   return jresult;
49574 }
49575
49576
49577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
49578   void * jresult ;
49579   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49580   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49581
49582   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49583   {
49584     try {
49585       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
49586     } CALL_CATCH_EXCEPTION(0);
49587   }
49588
49589   jresult = (void *)result;
49590   return jresult;
49591 }
49592
49593
49594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
49595   void * jresult ;
49596   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49597   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49598
49599   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49600   {
49601     try {
49602       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
49603     } CALL_CATCH_EXCEPTION(0);
49604   }
49605
49606   jresult = (void *)result;
49607   return jresult;
49608 }
49609
49610
49611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
49612   void * jresult ;
49613   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49614   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49615
49616   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49617   {
49618     try {
49619       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
49620     } CALL_CATCH_EXCEPTION(0);
49621   }
49622
49623   jresult = (void *)result;
49624   return jresult;
49625 }
49626
49627
49628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
49629   void * jresult ;
49630   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49631   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49632
49633   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49634   {
49635     try {
49636       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
49637     } CALL_CATCH_EXCEPTION(0);
49638   }
49639
49640   jresult = (void *)result;
49641   return jresult;
49642 }
49643
49644
49645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
49646   void * jresult ;
49647   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49648   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49649
49650   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49651   {
49652     try {
49653       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
49654     } CALL_CATCH_EXCEPTION(0);
49655   }
49656
49657   jresult = (void *)result;
49658   return jresult;
49659 }
49660
49661
49662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
49663   void * jresult ;
49664   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49665   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49666
49667   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49668   {
49669     try {
49670       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
49671     } CALL_CATCH_EXCEPTION(0);
49672   }
49673
49674   jresult = (void *)result;
49675   return jresult;
49676 }
49677
49678
49679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
49680   void * jresult ;
49681   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49682   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49683
49684   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49685   {
49686     try {
49687       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
49688     } CALL_CATCH_EXCEPTION(0);
49689   }
49690
49691   jresult = (void *)result;
49692   return jresult;
49693 }
49694
49695
49696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
49697   void * jresult ;
49698   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49699   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49700
49701   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49702   {
49703     try {
49704       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
49705     } CALL_CATCH_EXCEPTION(0);
49706   }
49707
49708   jresult = (void *)result;
49709   return jresult;
49710 }
49711
49712
49713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
49714   void * jresult ;
49715   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49716   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
49717
49718   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49719   {
49720     try {
49721       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
49722     } CALL_CATCH_EXCEPTION(0);
49723   }
49724
49725   jresult = (void *)result;
49726   return jresult;
49727 }
49728
49729
49730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
49731   void * jresult ;
49732   Dali::Toolkit::StyleManager *result = 0 ;
49733
49734   {
49735     try {
49736       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
49737     } CALL_CATCH_EXCEPTION(0);
49738   }
49739
49740   jresult = (void *)result;
49741   return jresult;
49742 }
49743
49744
49745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
49746   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
49747
49748   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
49749   {
49750     try {
49751       delete arg1;
49752     } CALL_CATCH_EXCEPTION();
49753   }
49754
49755 }
49756
49757
49758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
49759   void * jresult ;
49760   Dali::Toolkit::StyleManager result;
49761
49762   {
49763     try {
49764       result = Dali::Toolkit::StyleManager::Get();
49765     } CALL_CATCH_EXCEPTION(0);
49766   }
49767
49768   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
49769   return jresult;
49770 }
49771
49772
49773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
49774   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
49775   std::string *arg2 = 0 ;
49776
49777   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
49778   if (!jarg2) {
49779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49780     return ;
49781   }
49782   std::string arg2_str(jarg2);
49783   arg2 = &arg2_str;
49784   {
49785     try {
49786       (arg1)->ApplyTheme((std::string const &)*arg2);
49787     } CALL_CATCH_EXCEPTION();
49788   }
49789
49790
49791   //argout typemap for const std::string&
49792
49793 }
49794
49795
49796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
49797   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
49798
49799   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
49800   {
49801     try {
49802       (arg1)->ApplyDefaultTheme();
49803     } CALL_CATCH_EXCEPTION();
49804   }
49805
49806 }
49807
49808
49809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
49810   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
49811   std::string *arg2 = 0 ;
49812   Dali::Property::Value *arg3 = 0 ;
49813
49814   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
49815   if (!jarg2) {
49816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49817     return ;
49818   }
49819   std::string arg2_str(jarg2);
49820   arg2 = &arg2_str;
49821   arg3 = (Dali::Property::Value *)jarg3;
49822   if (!arg3) {
49823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
49824     return ;
49825   }
49826   {
49827     try {
49828       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
49829     } CALL_CATCH_EXCEPTION();
49830   }
49831
49832
49833   //argout typemap for const std::string&
49834
49835 }
49836
49837
49838 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
49839   bool jresult ;
49840   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
49841   std::string *arg2 = 0 ;
49842   Dali::Property::Value *arg3 = 0 ;
49843   bool result;
49844
49845   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
49846   if (!jarg2) {
49847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49848     return 0;
49849   }
49850   std::string arg2_str(jarg2);
49851   arg2 = &arg2_str;
49852   arg3 = (Dali::Property::Value *)jarg3;
49853   if (!arg3) {
49854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
49855     return 0;
49856   }
49857   {
49858     try {
49859       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
49860     } CALL_CATCH_EXCEPTION(0);
49861   }
49862
49863   jresult = result;
49864
49865   //argout typemap for const std::string&
49866
49867   return jresult;
49868 }
49869
49870
49871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
49872   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
49873   Dali::Toolkit::Control arg2 ;
49874   std::string *arg3 = 0 ;
49875   std::string *arg4 = 0 ;
49876   Dali::Toolkit::Control *argp2 ;
49877
49878   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
49879   argp2 = (Dali::Toolkit::Control *)jarg2;
49880   if (!argp2) {
49881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
49882     return ;
49883   }
49884   arg2 = *argp2;
49885   if (!jarg3) {
49886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49887     return ;
49888   }
49889   std::string arg3_str(jarg3);
49890   arg3 = &arg3_str;
49891   if (!jarg4) {
49892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49893     return ;
49894   }
49895   std::string arg4_str(jarg4);
49896   arg4 = &arg4_str;
49897   {
49898     try {
49899       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
49900     } CALL_CATCH_EXCEPTION();
49901   }
49902
49903
49904   //argout typemap for const std::string&
49905
49906
49907   //argout typemap for const std::string&
49908
49909 }
49910
49911
49912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
49913   void * jresult ;
49914   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
49915   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
49916
49917   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
49918   {
49919     try {
49920       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
49921     } CALL_CATCH_EXCEPTION(0);
49922   }
49923
49924   jresult = (void *)result;
49925   return jresult;
49926 }
49927
49928
49929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
49930   int jresult ;
49931   int result;
49932
49933   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
49934   jresult = (int)result;
49935   return jresult;
49936 }
49937
49938
49939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
49940   int jresult ;
49941   int result;
49942
49943   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
49944   jresult = (int)result;
49945   return jresult;
49946 }
49947
49948
49949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
49950   int jresult ;
49951   int result;
49952
49953   result = (int)Dali::Toolkit::Slider::Property::VALUE;
49954   jresult = (int)result;
49955   return jresult;
49956 }
49957
49958
49959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
49960   int jresult ;
49961   int result;
49962
49963   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
49964   jresult = (int)result;
49965   return jresult;
49966 }
49967
49968
49969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
49970   int jresult ;
49971   int result;
49972
49973   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
49974   jresult = (int)result;
49975   return jresult;
49976 }
49977
49978
49979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
49980   int jresult ;
49981   int result;
49982
49983   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
49984   jresult = (int)result;
49985   return jresult;
49986 }
49987
49988
49989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
49990   int jresult ;
49991   int result;
49992
49993   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
49994   jresult = (int)result;
49995   return jresult;
49996 }
49997
49998
49999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
50000   int jresult ;
50001   int result;
50002
50003   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
50004   jresult = (int)result;
50005   return jresult;
50006 }
50007
50008
50009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
50010   int jresult ;
50011   int result;
50012
50013   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
50014   jresult = (int)result;
50015   return jresult;
50016 }
50017
50018
50019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
50020   int jresult ;
50021   int result;
50022
50023   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
50024   jresult = (int)result;
50025   return jresult;
50026 }
50027
50028
50029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
50030   int jresult ;
50031   int result;
50032
50033   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
50034   jresult = (int)result;
50035   return jresult;
50036 }
50037
50038
50039 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
50040   int jresult ;
50041   int result;
50042
50043   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
50044   jresult = (int)result;
50045   return jresult;
50046 }
50047
50048
50049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
50050   int jresult ;
50051   int result;
50052
50053   result = (int)Dali::Toolkit::Slider::Property::MARKS;
50054   jresult = (int)result;
50055   return jresult;
50056 }
50057
50058
50059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
50060   int jresult ;
50061   int result;
50062
50063   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
50064   jresult = (int)result;
50065   return jresult;
50066 }
50067
50068
50069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
50070   int jresult ;
50071   int result;
50072
50073   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
50074   jresult = (int)result;
50075   return jresult;
50076 }
50077
50078
50079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
50080   void * jresult ;
50081   Dali::Toolkit::Slider::Property *result = 0 ;
50082
50083   {
50084     try {
50085       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
50086     } CALL_CATCH_EXCEPTION(0);
50087   }
50088
50089   jresult = (void *)result;
50090   return jresult;
50091 }
50092
50093
50094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
50095   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
50096
50097   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
50098   {
50099     try {
50100       delete arg1;
50101     } CALL_CATCH_EXCEPTION();
50102   }
50103
50104 }
50105
50106
50107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
50108   void * jresult ;
50109   Dali::Toolkit::Slider result;
50110
50111   {
50112     try {
50113       result = Dali::Toolkit::Slider::New();
50114     } CALL_CATCH_EXCEPTION(0);
50115   }
50116
50117   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
50118   return jresult;
50119 }
50120
50121
50122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
50123   void * jresult ;
50124   Dali::Toolkit::Slider *result = 0 ;
50125
50126   {
50127     try {
50128       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
50129     } CALL_CATCH_EXCEPTION(0);
50130   }
50131
50132   jresult = (void *)result;
50133   return jresult;
50134 }
50135
50136
50137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
50138   void * jresult ;
50139   Dali::Toolkit::Slider *arg1 = 0 ;
50140   Dali::Toolkit::Slider *result = 0 ;
50141
50142   arg1 = (Dali::Toolkit::Slider *)jarg1;
50143   if (!arg1) {
50144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
50145     return 0;
50146   }
50147   {
50148     try {
50149       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
50150     } CALL_CATCH_EXCEPTION(0);
50151   }
50152
50153   jresult = (void *)result;
50154   return jresult;
50155 }
50156
50157
50158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
50159   void * jresult ;
50160   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
50161   Dali::Toolkit::Slider *arg2 = 0 ;
50162   Dali::Toolkit::Slider *result = 0 ;
50163
50164   arg1 = (Dali::Toolkit::Slider *)jarg1;
50165   arg2 = (Dali::Toolkit::Slider *)jarg2;
50166   if (!arg2) {
50167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
50168     return 0;
50169   }
50170   {
50171     try {
50172       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
50173     } CALL_CATCH_EXCEPTION(0);
50174   }
50175
50176   jresult = (void *)result;
50177   return jresult;
50178 }
50179
50180
50181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
50182   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
50183
50184   arg1 = (Dali::Toolkit::Slider *)jarg1;
50185   {
50186     try {
50187       delete arg1;
50188     } CALL_CATCH_EXCEPTION();
50189   }
50190
50191 }
50192
50193
50194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
50195   void * jresult ;
50196   Dali::BaseHandle arg1 ;
50197   Dali::BaseHandle *argp1 ;
50198   Dali::Toolkit::Slider result;
50199
50200   argp1 = (Dali::BaseHandle *)jarg1;
50201   if (!argp1) {
50202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50203     return 0;
50204   }
50205   arg1 = *argp1;
50206   {
50207     try {
50208       result = Dali::Toolkit::Slider::DownCast(arg1);
50209     } CALL_CATCH_EXCEPTION(0);
50210   }
50211
50212   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
50213   return jresult;
50214 }
50215
50216
50217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
50218   void * jresult ;
50219   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
50220   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
50221
50222   arg1 = (Dali::Toolkit::Slider *)jarg1;
50223   {
50224     try {
50225       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
50226     } CALL_CATCH_EXCEPTION(0);
50227   }
50228
50229   jresult = (void *)result;
50230   return jresult;
50231 }
50232
50233
50234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
50235   void * jresult ;
50236   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
50237   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
50238
50239   arg1 = (Dali::Toolkit::Slider *)jarg1;
50240   {
50241     try {
50242       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
50243     } CALL_CATCH_EXCEPTION(0);
50244   }
50245
50246   jresult = (void *)result;
50247   return jresult;
50248 }
50249
50250
50251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
50252   void * jresult ;
50253   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
50254   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
50255
50256   arg1 = (Dali::Toolkit::Slider *)jarg1;
50257   {
50258     try {
50259       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
50260     } CALL_CATCH_EXCEPTION(0);
50261   }
50262
50263   jresult = (void *)result;
50264   return jresult;
50265 }
50266
50267
50268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
50269   int jresult ;
50270   int result;
50271
50272   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
50273   jresult = (int)result;
50274   return jresult;
50275 }
50276
50277
50278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
50279   int jresult ;
50280   int result;
50281
50282   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
50283   jresult = (int)result;
50284   return jresult;
50285 }
50286
50287
50288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
50289   int jresult ;
50290   int result;
50291
50292   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
50293   jresult = (int)result;
50294   return jresult;
50295 }
50296
50297
50298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
50299   int jresult ;
50300   int result;
50301
50302   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
50303   jresult = (int)result;
50304   return jresult;
50305 }
50306
50307
50308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
50309   int result;
50310
50311   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
50312
50313   return result;
50314 }
50315
50316
50317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
50318   void * jresult ;
50319   Dali::Toolkit::VideoView::Property *result = 0 ;
50320
50321   {
50322     try {
50323       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
50324     } CALL_CATCH_EXCEPTION(0);
50325   }
50326
50327   jresult = (void *)result;
50328   return jresult;
50329 }
50330
50331
50332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
50333   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
50334
50335   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
50336   {
50337     try {
50338       delete arg1;
50339     } CALL_CATCH_EXCEPTION();
50340   }
50341
50342 }
50343
50344
50345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
50346   void * jresult ;
50347   Dali::Toolkit::VideoView result;
50348
50349   {
50350     try {
50351       result = Dali::Toolkit::VideoView::New();
50352     } CALL_CATCH_EXCEPTION(0);
50353   }
50354
50355   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
50356   return jresult;
50357 }
50358
50359
50360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
50361   void * jresult ;
50362   std::string *arg1 = 0 ;
50363   Dali::Toolkit::VideoView result;
50364
50365   if (!jarg1) {
50366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
50367     return 0;
50368   }
50369   std::string arg1_str(jarg1);
50370   arg1 = &arg1_str;
50371   {
50372     try {
50373       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
50374     } CALL_CATCH_EXCEPTION(0);
50375   }
50376
50377   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
50378
50379   //argout typemap for const std::string&
50380
50381   return jresult;
50382 }
50383
50384
50385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
50386   void * jresult ;
50387   Dali::Toolkit::VideoView result;
50388   {
50389     try {
50390       result = Dali::Toolkit::VideoView::New(swCodec);
50391     } CALL_CATCH_EXCEPTION(0);
50392   }
50393
50394   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
50395
50396   //argout typemap for const std::string&
50397
50398   return jresult;
50399 }
50400
50401
50402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
50403   void * jresult ;
50404   std::string *arg1 = 0 ;
50405   Dali::Toolkit::VideoView result;
50406
50407   if (!jarg1) {
50408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
50409     return 0;
50410   }
50411   std::string arg1_str(jarg1);
50412   arg1 = &arg1_str;
50413   {
50414     try {
50415       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
50416     } CALL_CATCH_EXCEPTION(0);
50417   }
50418
50419   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
50420
50421   //argout typemap for const std::string&
50422
50423   return jresult;
50424 }
50425
50426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_4(unsigned int jarg1) {
50427   void * jresult ;
50428   Dali::VideoSyncMode syncMode;
50429   Dali::Toolkit::VideoView result;
50430
50431   syncMode = static_cast<Dali::VideoSyncMode>(jarg1);
50432
50433   {
50434     try {
50435       result = Dali::Toolkit::DevelVideoView::New(syncMode);
50436     } CALL_CATCH_EXCEPTION(0);
50437   }
50438
50439   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
50440
50441   return jresult;
50442 }
50443
50444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
50445   void * jresult ;
50446   Dali::Toolkit::VideoView *result = 0 ;
50447
50448   {
50449     try {
50450       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
50451     } CALL_CATCH_EXCEPTION(0);
50452   }
50453
50454   jresult = (void *)result;
50455   return jresult;
50456 }
50457
50458
50459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
50460   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
50461
50462   arg1 = (Dali::Toolkit::VideoView *)jarg1;
50463   {
50464     try {
50465       delete arg1;
50466     } CALL_CATCH_EXCEPTION();
50467   }
50468
50469 }
50470
50471
50472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
50473   void * jresult ;
50474   Dali::Toolkit::VideoView *arg1 = 0 ;
50475   Dali::Toolkit::VideoView *result = 0 ;
50476
50477   arg1 = (Dali::Toolkit::VideoView *)jarg1;
50478   if (!arg1) {
50479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
50480     return 0;
50481   }
50482   {
50483     try {
50484       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
50485     } CALL_CATCH_EXCEPTION(0);
50486   }
50487
50488   jresult = (void *)result;
50489   return jresult;
50490 }
50491
50492
50493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
50494   void * jresult ;
50495   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
50496   Dali::Toolkit::VideoView *arg2 = 0 ;
50497   Dali::Toolkit::VideoView *result = 0 ;
50498
50499   arg1 = (Dali::Toolkit::VideoView *)jarg1;
50500   arg2 = (Dali::Toolkit::VideoView *)jarg2;
50501   if (!arg2) {
50502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
50503     return 0;
50504   }
50505   {
50506     try {
50507       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
50508     } CALL_CATCH_EXCEPTION(0);
50509   }
50510
50511   jresult = (void *)result;
50512   return jresult;
50513 }
50514
50515
50516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
50517   void * jresult ;
50518   Dali::BaseHandle arg1 ;
50519   Dali::BaseHandle *argp1 ;
50520   Dali::Toolkit::VideoView result;
50521
50522   argp1 = (Dali::BaseHandle *)jarg1;
50523   if (!argp1) {
50524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50525     return 0;
50526   }
50527   arg1 = *argp1;
50528   {
50529     try {
50530       result = Dali::Toolkit::VideoView::DownCast(arg1);
50531     } CALL_CATCH_EXCEPTION(0);
50532   }
50533
50534   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
50535   return jresult;
50536 }
50537
50538
50539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
50540   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
50541
50542   arg1 = (Dali::Toolkit::VideoView *)jarg1;
50543   {
50544     try {
50545       (arg1)->Play();
50546     } CALL_CATCH_EXCEPTION();
50547   }
50548
50549 }
50550
50551
50552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
50553   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
50554
50555   arg1 = (Dali::Toolkit::VideoView *)jarg1;
50556   {
50557     try {
50558       (arg1)->Pause();
50559     } CALL_CATCH_EXCEPTION();
50560   }
50561
50562 }
50563
50564
50565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
50566   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
50567
50568   arg1 = (Dali::Toolkit::VideoView *)jarg1;
50569   {
50570     try {
50571       (arg1)->Stop();
50572     } CALL_CATCH_EXCEPTION();
50573   }
50574
50575 }
50576
50577
50578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
50579   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
50580   int arg2 ;
50581
50582   arg1 = (Dali::Toolkit::VideoView *)jarg1;
50583   arg2 = (int)jarg2;
50584   {
50585     try {
50586       (arg1)->Forward(arg2);
50587     } CALL_CATCH_EXCEPTION();
50588   }
50589
50590 }
50591
50592
50593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
50594   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
50595   int arg2 ;
50596
50597   arg1 = (Dali::Toolkit::VideoView *)jarg1;
50598   arg2 = (int)jarg2;
50599   {
50600     try {
50601       (arg1)->Backward(arg2);
50602     } CALL_CATCH_EXCEPTION();
50603   }
50604
50605 }
50606
50607
50608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
50609   void * jresult ;
50610   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
50611   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
50612
50613   arg1 = (Dali::Toolkit::VideoView *)jarg1;
50614   {
50615     try {
50616       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
50617     } CALL_CATCH_EXCEPTION(0);
50618   }
50619
50620   jresult = (void *)result;
50621   return jresult;
50622 }
50623
50624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle(void * jarg1)
50625 {
50626   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
50627   if( arg1 == nullptr )
50628   {
50629     DALI_LOG_ERROR("VideoView is nullptr!");
50630     return nullptr;
50631   }
50632   void * ret = nullptr;
50633   {
50634     try{
50635
50636       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
50637       ret = Dali::AnyCast< void * >( result );
50638
50639     } CALL_CATCH_EXCEPTION(0);
50640   }
50641   return ret;
50642 }
50643
50644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraView_New__SWIG_0(void * jarg1, int jarg2) {
50645   void * jresult ;
50646   Dali::Toolkit::CameraView result;
50647
50648   Dali::Any arg1(jarg1);
50649   Dali::Toolkit::CameraView::DisplayType arg2 = static_cast<Dali::Toolkit::CameraView::DisplayType>(jarg2);
50650   {
50651     try {
50652       result = Dali::Toolkit::CameraView::New(arg1, arg2);
50653     } CALL_CATCH_EXCEPTION(0);
50654   }
50655
50656   jresult = new Dali::Toolkit::CameraView((const Dali::Toolkit::CameraView &)result);
50657   return jresult;
50658 }
50659
50660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraView__SWIG_0() {
50661   void * jresult ;
50662   Dali::Toolkit::CameraView *result = 0 ;
50663
50664   {
50665     try {
50666       result = (Dali::Toolkit::CameraView *)new Dali::Toolkit::CameraView();
50667     } CALL_CATCH_EXCEPTION(0);
50668   }
50669
50670   jresult = (void *)result;
50671   return jresult;
50672 }
50673
50674
50675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraView(void * jarg1) {
50676   Dali::Toolkit::CameraView *arg1 = (Dali::Toolkit::CameraView *) 0 ;
50677
50678   arg1 = (Dali::Toolkit::CameraView *)jarg1;
50679   {
50680     try {
50681       delete arg1;
50682     } CALL_CATCH_EXCEPTION();
50683   }
50684
50685 }
50686
50687
50688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraView__SWIG_1(void * jarg1) {
50689   void * jresult ;
50690   Dali::Toolkit::CameraView *arg1 = 0 ;
50691   Dali::Toolkit::CameraView *result = 0 ;
50692
50693   arg1 = (Dali::Toolkit::CameraView *)jarg1;
50694   if (!arg1) {
50695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CameraView const & type is null", 0);
50696     return 0;
50697   }
50698   {
50699     try {
50700       result = (Dali::Toolkit::CameraView *)new Dali::Toolkit::CameraView((Dali::Toolkit::CameraView const &)*arg1);
50701     } CALL_CATCH_EXCEPTION(0);
50702   }
50703
50704   jresult = (void *)result;
50705   return jresult;
50706 }
50707
50708
50709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraView_Assign(void * jarg1, void * jarg2) {
50710   void * jresult ;
50711   Dali::Toolkit::CameraView *arg1 = (Dali::Toolkit::CameraView *) 0 ;
50712   Dali::Toolkit::CameraView *arg2 = 0 ;
50713   Dali::Toolkit::CameraView *result = 0 ;
50714
50715   arg1 = (Dali::Toolkit::CameraView *)jarg1;
50716   arg2 = (Dali::Toolkit::CameraView *)jarg2;
50717   if (!arg2) {
50718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CameraView const & type is null", 0);
50719     return 0;
50720   }
50721   {
50722     try {
50723       result = (Dali::Toolkit::CameraView *) &(arg1)->operator =((Dali::Toolkit::CameraView const &)*arg2);
50724     } CALL_CATCH_EXCEPTION(0);
50725   }
50726
50727   jresult = (void *)result;
50728   return jresult;
50729 }
50730
50731
50732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraView_DownCast(void * jarg1) {
50733   void * jresult ;
50734   Dali::BaseHandle arg1 ;
50735   Dali::BaseHandle *argp1 ;
50736   Dali::Toolkit::CameraView result;
50737
50738   argp1 = (Dali::BaseHandle *)jarg1;
50739   if (!argp1) {
50740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50741     return 0;
50742   }
50743   arg1 = *argp1;
50744   {
50745     try {
50746       result = Dali::Toolkit::CameraView::DownCast(arg1);
50747     } CALL_CATCH_EXCEPTION(0);
50748   }
50749
50750   jresult = new Dali::Toolkit::CameraView((const Dali::Toolkit::CameraView &)result);
50751   return jresult;
50752 }
50753
50754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraView_Update(void * jarg1) {
50755   Dali::Toolkit::CameraView *arg1 = (Dali::Toolkit::CameraView *) 0 ;
50756
50757   arg1 = (Dali::Toolkit::CameraView *)jarg1;
50758   {
50759     try {
50760       (arg1)->Update();
50761     } CALL_CATCH_EXCEPTION();
50762   }
50763 }
50764
50765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_PlayAnimation(void * jarg1, void * jarg2)
50766 {
50767   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView*)jarg1;
50768   if(arg1 == nullptr)
50769   {
50770     DALI_LOG_ERROR("VideoView is nullptr!");
50771     return;
50772   }
50773   Dali::Animation *arg2 = (Dali::Animation*)jarg2;
50774   if(arg2 == nullptr)
50775   {
50776     DALI_LOG_ERROR("Animation is nullptr!");
50777     return;
50778   }
50779
50780   {
50781     try{
50782
50783       Toolkit::DevelVideoView::PlayAnimation(*arg1, *arg2);
50784     } CALL_CATCH_EXCEPTION();
50785   }
50786
50787 }
50788
50789
50790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
50791   int jresult ;
50792   int result;
50793
50794   result = (int)Dali::Toolkit::Popup::Property::TITLE;
50795   jresult = (int)result;
50796   return jresult;
50797 }
50798
50799
50800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
50801   int jresult ;
50802   int result;
50803
50804   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
50805   jresult = (int)result;
50806   return jresult;
50807 }
50808
50809
50810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
50811   int jresult ;
50812   int result;
50813
50814   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
50815   jresult = (int)result;
50816   return jresult;
50817 }
50818
50819
50820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
50821   int jresult ;
50822   int result;
50823
50824   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
50825   jresult = (int)result;
50826   return jresult;
50827 }
50828
50829
50830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
50831   int jresult ;
50832   int result;
50833
50834   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
50835   jresult = (int)result;
50836   return jresult;
50837 }
50838
50839
50840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
50841   int jresult ;
50842   int result;
50843
50844   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
50845   jresult = (int)result;
50846   return jresult;
50847 }
50848
50849
50850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
50851   int jresult ;
50852   int result;
50853
50854   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
50855   jresult = (int)result;
50856   return jresult;
50857 }
50858
50859
50860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
50861   int jresult ;
50862   int result;
50863
50864   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
50865   jresult = (int)result;
50866   return jresult;
50867 }
50868
50869
50870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
50871   int jresult ;
50872   int result;
50873
50874   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
50875   jresult = (int)result;
50876   return jresult;
50877 }
50878
50879
50880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
50881   int jresult ;
50882   int result;
50883
50884   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
50885   jresult = (int)result;
50886   return jresult;
50887 }
50888
50889
50890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
50891   int jresult ;
50892   int result;
50893
50894   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
50895   jresult = (int)result;
50896   return jresult;
50897 }
50898
50899
50900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
50901   int jresult ;
50902   int result;
50903
50904   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
50905   jresult = (int)result;
50906   return jresult;
50907 }
50908
50909
50910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
50911   int jresult ;
50912   int result;
50913
50914   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
50915   jresult = (int)result;
50916   return jresult;
50917 }
50918
50919
50920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
50921   int jresult ;
50922   int result;
50923
50924   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
50925   jresult = (int)result;
50926   return jresult;
50927 }
50928
50929
50930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
50931   int jresult ;
50932   int result;
50933
50934   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
50935   jresult = (int)result;
50936   return jresult;
50937 }
50938
50939
50940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
50941   int jresult ;
50942   int result;
50943
50944   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
50945   jresult = (int)result;
50946   return jresult;
50947 }
50948
50949
50950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
50951   int jresult ;
50952   int result;
50953
50954   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
50955   jresult = (int)result;
50956   return jresult;
50957 }
50958
50959
50960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
50961   int jresult ;
50962   int result;
50963
50964   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
50965   jresult = (int)result;
50966   return jresult;
50967 }
50968
50969
50970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
50971   int jresult ;
50972   int result;
50973
50974   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
50975   jresult = (int)result;
50976   return jresult;
50977 }
50978
50979
50980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
50981   int jresult ;
50982   int result;
50983
50984   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
50985   jresult = (int)result;
50986   return jresult;
50987 }
50988
50989
50990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
50991   int jresult ;
50992   int result;
50993
50994   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
50995   jresult = (int)result;
50996   return jresult;
50997 }
50998
50999
51000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
51001   void * jresult ;
51002   Dali::Toolkit::Popup::Property *result = 0 ;
51003
51004   {
51005     try {
51006       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
51007     } CALL_CATCH_EXCEPTION(0);
51008   }
51009
51010   jresult = (void *)result;
51011   return jresult;
51012 }
51013
51014
51015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
51016   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
51017
51018   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
51019   {
51020     try {
51021       delete arg1;
51022     } CALL_CATCH_EXCEPTION();
51023   }
51024
51025 }
51026
51027
51028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
51029   void * jresult ;
51030   Dali::Toolkit::Popup *result = 0 ;
51031
51032   {
51033     try {
51034       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
51035     } CALL_CATCH_EXCEPTION(0);
51036   }
51037
51038   jresult = (void *)result;
51039   return jresult;
51040 }
51041
51042
51043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
51044   void * jresult ;
51045   Dali::Toolkit::Popup result;
51046
51047   {
51048     try {
51049       result = Dali::Toolkit::Popup::New();
51050     } CALL_CATCH_EXCEPTION(0);
51051   }
51052
51053   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
51054   return jresult;
51055 }
51056
51057
51058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
51059   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51060
51061   arg1 = (Dali::Toolkit::Popup *)jarg1;
51062   {
51063     try {
51064       delete arg1;
51065     } CALL_CATCH_EXCEPTION();
51066   }
51067
51068 }
51069
51070
51071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
51072   void * jresult ;
51073   Dali::Toolkit::Popup *arg1 = 0 ;
51074   Dali::Toolkit::Popup *result = 0 ;
51075
51076   arg1 = (Dali::Toolkit::Popup *)jarg1;
51077   if (!arg1) {
51078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
51079     return 0;
51080   }
51081   {
51082     try {
51083       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
51084     } CALL_CATCH_EXCEPTION(0);
51085   }
51086
51087   jresult = (void *)result;
51088   return jresult;
51089 }
51090
51091
51092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
51093   void * jresult ;
51094   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51095   Dali::Toolkit::Popup *arg2 = 0 ;
51096   Dali::Toolkit::Popup *result = 0 ;
51097
51098   arg1 = (Dali::Toolkit::Popup *)jarg1;
51099   arg2 = (Dali::Toolkit::Popup *)jarg2;
51100   if (!arg2) {
51101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
51102     return 0;
51103   }
51104   {
51105     try {
51106       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
51107     } CALL_CATCH_EXCEPTION(0);
51108   }
51109
51110   jresult = (void *)result;
51111   return jresult;
51112 }
51113
51114
51115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
51116   void * jresult ;
51117   Dali::BaseHandle arg1 ;
51118   Dali::BaseHandle *argp1 ;
51119   Dali::Toolkit::Popup result;
51120
51121   argp1 = (Dali::BaseHandle *)jarg1;
51122   if (!argp1) {
51123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51124     return 0;
51125   }
51126   arg1 = *argp1;
51127   {
51128     try {
51129       result = Dali::Toolkit::Popup::DownCast(arg1);
51130     } CALL_CATCH_EXCEPTION(0);
51131   }
51132
51133   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
51134   return jresult;
51135 }
51136
51137
51138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
51139   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51140   Dali::Actor arg2 ;
51141   Dali::Actor *argp2 ;
51142
51143   arg1 = (Dali::Toolkit::Popup *)jarg1;
51144   argp2 = (Dali::Actor *)jarg2;
51145   if (!argp2) {
51146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51147     return ;
51148   }
51149   arg2 = *argp2;
51150   {
51151     try {
51152       (arg1)->SetTitle(arg2);
51153     } CALL_CATCH_EXCEPTION();
51154   }
51155
51156 }
51157
51158
51159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
51160   void * jresult ;
51161   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51162   Dali::Actor result;
51163
51164   arg1 = (Dali::Toolkit::Popup *)jarg1;
51165   {
51166     try {
51167       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
51168     } CALL_CATCH_EXCEPTION(0);
51169   }
51170
51171   jresult = new Dali::Actor((const Dali::Actor &)result);
51172   return jresult;
51173 }
51174
51175
51176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
51177   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51178   Dali::Actor arg2 ;
51179   Dali::Actor *argp2 ;
51180
51181   arg1 = (Dali::Toolkit::Popup *)jarg1;
51182   argp2 = (Dali::Actor *)jarg2;
51183   if (!argp2) {
51184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51185     return ;
51186   }
51187   arg2 = *argp2;
51188   {
51189     try {
51190       (arg1)->SetContent(arg2);
51191     } CALL_CATCH_EXCEPTION();
51192   }
51193
51194 }
51195
51196
51197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
51198   void * jresult ;
51199   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51200   Dali::Actor result;
51201
51202   arg1 = (Dali::Toolkit::Popup *)jarg1;
51203   {
51204     try {
51205       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
51206     } CALL_CATCH_EXCEPTION(0);
51207   }
51208
51209   jresult = new Dali::Actor((const Dali::Actor &)result);
51210   return jresult;
51211 }
51212
51213
51214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
51215   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51216   Dali::Actor arg2 ;
51217   Dali::Actor *argp2 ;
51218
51219   arg1 = (Dali::Toolkit::Popup *)jarg1;
51220   argp2 = (Dali::Actor *)jarg2;
51221   if (!argp2) {
51222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51223     return ;
51224   }
51225   arg2 = *argp2;
51226   {
51227     try {
51228       (arg1)->SetFooter(arg2);
51229     } CALL_CATCH_EXCEPTION();
51230   }
51231
51232 }
51233
51234
51235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
51236   void * jresult ;
51237   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51238   Dali::Actor result;
51239
51240   arg1 = (Dali::Toolkit::Popup *)jarg1;
51241   {
51242     try {
51243       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
51244     } CALL_CATCH_EXCEPTION(0);
51245   }
51246
51247   jresult = new Dali::Actor((const Dali::Actor &)result);
51248   return jresult;
51249 }
51250
51251
51252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
51253   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51254   Dali::Toolkit::Popup::DisplayState arg2 ;
51255
51256   arg1 = (Dali::Toolkit::Popup *)jarg1;
51257   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
51258   {
51259     try {
51260       (arg1)->SetDisplayState(arg2);
51261     } CALL_CATCH_EXCEPTION();
51262   }
51263
51264 }
51265
51266
51267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
51268   int jresult ;
51269   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51270   Dali::Toolkit::Popup::DisplayState result;
51271
51272   arg1 = (Dali::Toolkit::Popup *)jarg1;
51273   {
51274     try {
51275       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
51276     } CALL_CATCH_EXCEPTION(0);
51277   }
51278
51279   jresult = (int)result;
51280   return jresult;
51281 }
51282
51283
51284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
51285   void * jresult ;
51286   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51287   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
51288
51289   arg1 = (Dali::Toolkit::Popup *)jarg1;
51290   {
51291     try {
51292       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
51293     } CALL_CATCH_EXCEPTION(0);
51294   }
51295
51296   jresult = (void *)result;
51297   return jresult;
51298 }
51299
51300
51301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
51302   void * jresult ;
51303   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51304   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
51305
51306   arg1 = (Dali::Toolkit::Popup *)jarg1;
51307   {
51308     try {
51309       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
51310     } CALL_CATCH_EXCEPTION(0);
51311   }
51312
51313   jresult = (void *)result;
51314   return jresult;
51315 }
51316
51317
51318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
51319   void * jresult ;
51320   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51321   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
51322
51323   arg1 = (Dali::Toolkit::Popup *)jarg1;
51324   {
51325     try {
51326       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
51327     } CALL_CATCH_EXCEPTION(0);
51328   }
51329
51330   jresult = (void *)result;
51331   return jresult;
51332 }
51333
51334
51335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
51336   void * jresult ;
51337   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51338   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
51339
51340   arg1 = (Dali::Toolkit::Popup *)jarg1;
51341   {
51342     try {
51343       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
51344     } CALL_CATCH_EXCEPTION(0);
51345   }
51346
51347   jresult = (void *)result;
51348   return jresult;
51349 }
51350
51351
51352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
51353   void * jresult ;
51354   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51355   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
51356
51357   arg1 = (Dali::Toolkit::Popup *)jarg1;
51358   {
51359     try {
51360       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
51361     } CALL_CATCH_EXCEPTION(0);
51362   }
51363
51364   jresult = (void *)result;
51365   return jresult;
51366 }
51367
51368
51369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
51370   int jresult ;
51371   int result;
51372
51373   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
51374   jresult = (int)result;
51375   return jresult;
51376 }
51377
51378
51379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
51380   int jresult ;
51381   int result;
51382
51383   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
51384   jresult = (int)result;
51385   return jresult;
51386 }
51387
51388
51389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
51390   int jresult ;
51391   int result;
51392
51393   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
51394   jresult = (int)result;
51395   return jresult;
51396 }
51397
51398
51399 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
51400   int jresult ;
51401   int result;
51402
51403   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
51404   jresult = (int)result;
51405   return jresult;
51406 }
51407
51408
51409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
51410   int jresult ;
51411   int result;
51412
51413   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
51414   jresult = (int)result;
51415   return jresult;
51416 }
51417
51418
51419 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
51420   int jresult ;
51421   int result;
51422
51423   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
51424   jresult = (int)result;
51425   return jresult;
51426 }
51427
51428
51429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
51430   int jresult ;
51431   int result;
51432
51433   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
51434   jresult = (int)result;
51435   return jresult;
51436 }
51437
51438
51439 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
51440   int jresult ;
51441   int result;
51442
51443   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
51444   jresult = (int)result;
51445   return jresult;
51446 }
51447
51448
51449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
51450   int jresult ;
51451   int result;
51452
51453   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
51454   jresult = (int)result;
51455   return jresult;
51456 }
51457
51458
51459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
51460   void * jresult ;
51461   Dali::Toolkit::ProgressBar::Property *result = 0 ;
51462
51463   {
51464     try {
51465       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
51466     } CALL_CATCH_EXCEPTION(0);
51467   }
51468
51469   jresult = (void *)result;
51470   return jresult;
51471 }
51472
51473
51474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
51475   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
51476
51477   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
51478   {
51479     try {
51480       delete arg1;
51481     } CALL_CATCH_EXCEPTION();
51482   }
51483
51484 }
51485
51486
51487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
51488   void * jresult ;
51489   Dali::Toolkit::ProgressBar result;
51490
51491   {
51492     try {
51493       result = Dali::Toolkit::ProgressBar::New();
51494     } CALL_CATCH_EXCEPTION(0);
51495   }
51496
51497   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
51498   return jresult;
51499 }
51500
51501
51502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
51503   void * jresult ;
51504   Dali::Toolkit::ProgressBar *result = 0 ;
51505
51506   {
51507     try {
51508       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
51509     } CALL_CATCH_EXCEPTION(0);
51510   }
51511
51512   jresult = (void *)result;
51513   return jresult;
51514 }
51515
51516
51517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
51518   void * jresult ;
51519   Dali::Toolkit::ProgressBar *arg1 = 0 ;
51520   Dali::Toolkit::ProgressBar *result = 0 ;
51521
51522   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
51523   if (!arg1) {
51524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
51525     return 0;
51526   }
51527   {
51528     try {
51529       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
51530     } CALL_CATCH_EXCEPTION(0);
51531   }
51532
51533   jresult = (void *)result;
51534   return jresult;
51535 }
51536
51537
51538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
51539   void * jresult ;
51540   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
51541   Dali::Toolkit::ProgressBar *arg2 = 0 ;
51542   Dali::Toolkit::ProgressBar *result = 0 ;
51543
51544   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
51545   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
51546   if (!arg2) {
51547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
51548     return 0;
51549   }
51550   {
51551     try {
51552       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
51553     } CALL_CATCH_EXCEPTION(0);
51554   }
51555
51556   jresult = (void *)result;
51557   return jresult;
51558 }
51559
51560
51561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
51562   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
51563
51564   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
51565   {
51566     try {
51567       delete arg1;
51568     } CALL_CATCH_EXCEPTION();
51569   }
51570
51571 }
51572
51573
51574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
51575   void * jresult ;
51576   Dali::BaseHandle arg1 ;
51577   Dali::BaseHandle *argp1 ;
51578   Dali::Toolkit::ProgressBar result;
51579
51580   argp1 = (Dali::BaseHandle *)jarg1;
51581   if (!argp1) {
51582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51583     return 0;
51584   }
51585   arg1 = *argp1;
51586   {
51587     try {
51588       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
51589     } CALL_CATCH_EXCEPTION(0);
51590   }
51591
51592   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
51593   return jresult;
51594 }
51595
51596
51597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
51598   void * jresult ;
51599   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
51600   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
51601
51602   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
51603   {
51604     try {
51605       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
51606     } CALL_CATCH_EXCEPTION(0);
51607   }
51608
51609   jresult = (void *)result;
51610   return jresult;
51611 }
51612
51613
51614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
51615   void * jresult ;
51616   Dali::Toolkit::GaussianBlurView *result = 0 ;
51617
51618   {
51619     try {
51620       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
51621     } CALL_CATCH_EXCEPTION(0);
51622   }
51623
51624   jresult = (void *)result;
51625   return jresult;
51626 }
51627
51628
51629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
51630   void * jresult ;
51631   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
51632   Dali::Toolkit::GaussianBlurView *result = 0 ;
51633
51634   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
51635   if (!arg1) {
51636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
51637     return 0;
51638   }
51639   {
51640     try {
51641       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
51642     } CALL_CATCH_EXCEPTION(0);
51643   }
51644
51645   jresult = (void *)result;
51646   return jresult;
51647 }
51648
51649
51650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
51651   void * jresult ;
51652   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
51653   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
51654   Dali::Toolkit::GaussianBlurView *result = 0 ;
51655
51656   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
51657   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
51658   if (!arg2) {
51659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
51660     return 0;
51661   }
51662   {
51663     try {
51664       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
51665     } CALL_CATCH_EXCEPTION(0);
51666   }
51667
51668   jresult = (void *)result;
51669   return jresult;
51670 }
51671
51672
51673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
51674   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
51675
51676   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
51677   {
51678     try {
51679       delete arg1;
51680     } CALL_CATCH_EXCEPTION();
51681   }
51682
51683 }
51684
51685
51686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
51687   void * jresult ;
51688   Dali::BaseHandle arg1 ;
51689   Dali::BaseHandle *argp1 ;
51690   Dali::Toolkit::GaussianBlurView result;
51691
51692   argp1 = (Dali::BaseHandle *)jarg1;
51693   if (!argp1) {
51694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51695     return 0;
51696   }
51697   arg1 = *argp1;
51698   {
51699     try {
51700       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
51701     } CALL_CATCH_EXCEPTION(0);
51702   }
51703
51704   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
51705   return jresult;
51706 }
51707
51708
51709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
51710   void * jresult ;
51711   Dali::Toolkit::GaussianBlurView result;
51712
51713   {
51714     try {
51715       result = Dali::Toolkit::GaussianBlurView::New();
51716     } CALL_CATCH_EXCEPTION(0);
51717   }
51718
51719   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
51720   return jresult;
51721 }
51722
51723
51724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, bool jarg6) {
51725   void * jresult ;
51726   unsigned int arg1 ;
51727   float arg2 ;
51728   Dali::Pixel::Format arg3 ;
51729   float arg4 ;
51730   float arg5 ;
51731   bool arg6 ;
51732   Dali::Toolkit::GaussianBlurView result;
51733
51734   arg1 = (unsigned int)jarg1;
51735   arg2 = (float)jarg2;
51736   arg3 = (Dali::Pixel::Format)jarg3;
51737   arg4 = (float)jarg4;
51738   arg5 = (float)jarg5;
51739   arg6 = jarg6 ? true : false;
51740   {
51741     try {
51742       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
51743     } CALL_CATCH_EXCEPTION(0);
51744   }
51745
51746   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
51747   return jresult;
51748 }
51749
51750
51751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
51752   void * jresult ;
51753   unsigned int arg1 ;
51754   float arg2 ;
51755   Dali::Pixel::Format arg3 ;
51756   float arg4 ;
51757   float arg5 ;
51758   Dali::Toolkit::GaussianBlurView result;
51759
51760   arg1 = (unsigned int)jarg1;
51761   arg2 = (float)jarg2;
51762   arg3 = (Dali::Pixel::Format)jarg3;
51763   arg4 = (float)jarg4;
51764   arg5 = (float)jarg5;
51765   {
51766     try {
51767       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
51768     } CALL_CATCH_EXCEPTION(0);
51769   }
51770
51771   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
51772   return jresult;
51773 }
51774
51775
51776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
51777   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
51778   Dali::Actor arg2 ;
51779   Dali::Actor *argp2 ;
51780
51781   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
51782   argp2 = (Dali::Actor *)jarg2;
51783   if (!argp2) {
51784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51785     return ;
51786   }
51787   arg2 = *argp2;
51788   {
51789     try {
51790       (arg1)->Add(arg2);
51791     } CALL_CATCH_EXCEPTION();
51792   }
51793
51794 }
51795
51796
51797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
51798   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
51799   Dali::Actor arg2 ;
51800   Dali::Actor *argp2 ;
51801
51802   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
51803   argp2 = (Dali::Actor *)jarg2;
51804   if (!argp2) {
51805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51806     return ;
51807   }
51808   arg2 = *argp2;
51809   {
51810     try {
51811       (arg1)->Remove(arg2);
51812     } CALL_CATCH_EXCEPTION();
51813   }
51814
51815 }
51816
51817
51818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
51819   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
51820
51821   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
51822   {
51823     try {
51824       (arg1)->Activate();
51825     } CALL_CATCH_EXCEPTION();
51826   }
51827
51828 }
51829
51830
51831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
51832   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
51833
51834   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
51835   {
51836     try {
51837       (arg1)->ActivateOnce();
51838     } CALL_CATCH_EXCEPTION();
51839   }
51840
51841 }
51842
51843
51844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
51845   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
51846
51847   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
51848   {
51849     try {
51850       (arg1)->Deactivate();
51851     } CALL_CATCH_EXCEPTION();
51852   }
51853
51854 }
51855
51856
51857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
51858   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
51859   Dali::Texture arg2 ;
51860   Dali::FrameBuffer arg3 ;
51861   Dali::Texture *argp2 ;
51862   Dali::FrameBuffer *argp3 ;
51863
51864   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
51865   argp2 = (Dali::Texture *)jarg2;
51866   if (!argp2) {
51867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
51868     return ;
51869   }
51870   arg2 = *argp2;
51871   argp3 = (Dali::FrameBuffer *)jarg3;
51872   if (!argp3) {
51873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
51874     return ;
51875   }
51876   arg3 = *argp3;
51877   {
51878     try {
51879       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
51880     } CALL_CATCH_EXCEPTION();
51881   }
51882
51883 }
51884
51885
51886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
51887   int jresult ;
51888   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
51889   Dali::Property::Index result;
51890
51891   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
51892   {
51893     try {
51894       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
51895     } CALL_CATCH_EXCEPTION(0);
51896   }
51897
51898   jresult = result;
51899   return jresult;
51900 }
51901
51902
51903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
51904   void * jresult ;
51905   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
51906   Dali::FrameBuffer result;
51907
51908   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
51909   {
51910     try {
51911       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
51912     } CALL_CATCH_EXCEPTION(0);
51913   }
51914
51915   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
51916   return jresult;
51917 }
51918
51919
51920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
51921   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
51922   Dali::Vector4 *arg2 = 0 ;
51923
51924   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
51925   arg2 = (Dali::Vector4 *)jarg2;
51926   if (!arg2) {
51927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
51928     return ;
51929   }
51930   {
51931     try {
51932       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
51933     } CALL_CATCH_EXCEPTION();
51934   }
51935
51936 }
51937
51938
51939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
51940   void * jresult ;
51941   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
51942   Dali::Vector4 result;
51943
51944   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
51945   {
51946     try {
51947       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
51948     } CALL_CATCH_EXCEPTION(0);
51949   }
51950
51951   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
51952   return jresult;
51953 }
51954
51955
51956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
51957   void * jresult ;
51958   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
51959   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
51960
51961   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
51962   {
51963     try {
51964       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
51965     } CALL_CATCH_EXCEPTION(0);
51966   }
51967
51968   jresult = (void *)result;
51969   return jresult;
51970 }
51971
51972
51973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
51974   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
51975
51976   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
51977   {
51978     try {
51979       delete arg1;
51980     } CALL_CATCH_EXCEPTION();
51981   }
51982
51983 }
51984
51985
51986 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
51987   unsigned int jresult ;
51988   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
51989   unsigned int result;
51990
51991   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
51992   {
51993     try {
51994       result = (unsigned int)(arg1)->GetNumberOfPages();
51995     } CALL_CATCH_EXCEPTION(0);
51996   }
51997
51998   jresult = result;
51999   return jresult;
52000 }
52001
52002
52003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
52004   void * jresult ;
52005   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
52006   unsigned int arg2 ;
52007   Dali::Texture result;
52008
52009   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
52010   arg2 = (unsigned int)jarg2;
52011   {
52012     try {
52013       result = (arg1)->NewPage(arg2);
52014     } CALL_CATCH_EXCEPTION(0);
52015   }
52016
52017   jresult = new Dali::Texture((const Dali::Texture &)result);
52018   return jresult;
52019 }
52020
52021
52022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
52023   int jresult ;
52024   int result;
52025
52026   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
52027   jresult = (int)result;
52028   return jresult;
52029 }
52030
52031
52032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
52033   int jresult ;
52034   int result;
52035
52036   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
52037   jresult = (int)result;
52038   return jresult;
52039 }
52040
52041
52042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
52043   int jresult ;
52044   int result;
52045
52046   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
52047   jresult = (int)result;
52048   return jresult;
52049 }
52050
52051
52052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
52053   void * jresult ;
52054   Dali::Toolkit::PageTurnView::Property *result = 0 ;
52055
52056   {
52057     try {
52058       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
52059     } CALL_CATCH_EXCEPTION(0);
52060   }
52061
52062   jresult = (void *)result;
52063   return jresult;
52064 }
52065
52066
52067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
52068   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
52069
52070   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
52071   {
52072     try {
52073       delete arg1;
52074     } CALL_CATCH_EXCEPTION();
52075   }
52076
52077 }
52078
52079
52080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
52081   void * jresult ;
52082   Dali::Toolkit::PageTurnView *result = 0 ;
52083
52084   {
52085     try {
52086       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
52087     } CALL_CATCH_EXCEPTION(0);
52088   }
52089
52090   jresult = (void *)result;
52091   return jresult;
52092 }
52093
52094
52095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
52096   void * jresult ;
52097   Dali::Toolkit::PageTurnView *arg1 = 0 ;
52098   Dali::Toolkit::PageTurnView *result = 0 ;
52099
52100   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
52101   if (!arg1) {
52102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
52103     return 0;
52104   }
52105   {
52106     try {
52107       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
52108     } CALL_CATCH_EXCEPTION(0);
52109   }
52110
52111   jresult = (void *)result;
52112   return jresult;
52113 }
52114
52115
52116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
52117   void * jresult ;
52118   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
52119   Dali::Toolkit::PageTurnView *arg2 = 0 ;
52120   Dali::Toolkit::PageTurnView *result = 0 ;
52121
52122   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
52123   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
52124   if (!arg2) {
52125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
52126     return 0;
52127   }
52128   {
52129     try {
52130       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
52131     } CALL_CATCH_EXCEPTION(0);
52132   }
52133
52134   jresult = (void *)result;
52135   return jresult;
52136 }
52137
52138
52139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
52140   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
52141
52142   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
52143   {
52144     try {
52145       delete arg1;
52146     } CALL_CATCH_EXCEPTION();
52147   }
52148
52149 }
52150
52151
52152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
52153   void * jresult ;
52154   Dali::BaseHandle arg1 ;
52155   Dali::BaseHandle *argp1 ;
52156   Dali::Toolkit::PageTurnView result;
52157
52158   argp1 = (Dali::BaseHandle *)jarg1;
52159   if (!argp1) {
52160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52161     return 0;
52162   }
52163   arg1 = *argp1;
52164   {
52165     try {
52166       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
52167     } CALL_CATCH_EXCEPTION(0);
52168   }
52169
52170   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
52171   return jresult;
52172 }
52173
52174
52175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
52176   void * jresult ;
52177   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
52178   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
52179
52180   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
52181   {
52182     try {
52183       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
52184     } CALL_CATCH_EXCEPTION(0);
52185   }
52186
52187   jresult = (void *)result;
52188   return jresult;
52189 }
52190
52191
52192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
52193   void * jresult ;
52194   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
52195   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
52196
52197   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
52198   {
52199     try {
52200       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
52201     } CALL_CATCH_EXCEPTION(0);
52202   }
52203
52204   jresult = (void *)result;
52205   return jresult;
52206 }
52207
52208
52209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
52210   void * jresult ;
52211   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
52212   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
52213
52214   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
52215   {
52216     try {
52217       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
52218     } CALL_CATCH_EXCEPTION(0);
52219   }
52220
52221   jresult = (void *)result;
52222   return jresult;
52223 }
52224
52225
52226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
52227   void * jresult ;
52228   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
52229   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
52230
52231   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
52232   {
52233     try {
52234       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
52235     } CALL_CATCH_EXCEPTION(0);
52236   }
52237
52238   jresult = (void *)result;
52239   return jresult;
52240 }
52241
52242
52243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
52244   void * jresult ;
52245   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
52246
52247   {
52248     try {
52249       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
52250     } CALL_CATCH_EXCEPTION(0);
52251   }
52252
52253   jresult = (void *)result;
52254   return jresult;
52255 }
52256
52257
52258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
52259   void * jresult ;
52260   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
52261   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
52262
52263   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
52264   if (!arg1) {
52265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
52266     return 0;
52267   }
52268   {
52269     try {
52270       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
52271     } CALL_CATCH_EXCEPTION(0);
52272   }
52273
52274   jresult = (void *)result;
52275   return jresult;
52276 }
52277
52278
52279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
52280   void * jresult ;
52281   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
52282   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
52283   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
52284
52285   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
52286   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
52287   if (!arg2) {
52288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
52289     return 0;
52290   }
52291   {
52292     try {
52293       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
52294     } CALL_CATCH_EXCEPTION(0);
52295   }
52296
52297   jresult = (void *)result;
52298   return jresult;
52299 }
52300
52301
52302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
52303   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
52304
52305   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
52306   {
52307     try {
52308       delete arg1;
52309     } CALL_CATCH_EXCEPTION();
52310   }
52311
52312 }
52313
52314
52315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
52316   void * jresult ;
52317   Dali::Toolkit::PageFactory *arg1 = 0 ;
52318   Dali::Vector2 *arg2 = 0 ;
52319   Dali::Toolkit::PageTurnLandscapeView result;
52320
52321   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
52322   if (!arg1) {
52323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
52324     return 0;
52325   }
52326   arg2 = (Dali::Vector2 *)jarg2;
52327   if (!arg2) {
52328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
52329     return 0;
52330   }
52331   {
52332     try {
52333       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
52334     } CALL_CATCH_EXCEPTION(0);
52335   }
52336
52337   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
52338   return jresult;
52339 }
52340
52341
52342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
52343   void * jresult ;
52344   Dali::BaseHandle arg1 ;
52345   Dali::BaseHandle *argp1 ;
52346   Dali::Toolkit::PageTurnLandscapeView result;
52347
52348   argp1 = (Dali::BaseHandle *)jarg1;
52349   if (!argp1) {
52350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52351     return 0;
52352   }
52353   arg1 = *argp1;
52354   {
52355     try {
52356       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
52357     } CALL_CATCH_EXCEPTION(0);
52358   }
52359
52360   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
52361   return jresult;
52362 }
52363
52364
52365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
52366   void * jresult ;
52367   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
52368
52369   {
52370     try {
52371       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
52372     } CALL_CATCH_EXCEPTION(0);
52373   }
52374
52375   jresult = (void *)result;
52376   return jresult;
52377 }
52378
52379
52380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
52381   void * jresult ;
52382   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
52383   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
52384
52385   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
52386   if (!arg1) {
52387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
52388     return 0;
52389   }
52390   {
52391     try {
52392       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
52393     } CALL_CATCH_EXCEPTION(0);
52394   }
52395
52396   jresult = (void *)result;
52397   return jresult;
52398 }
52399
52400
52401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
52402   void * jresult ;
52403   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
52404   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
52405   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
52406
52407   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
52408   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
52409   if (!arg2) {
52410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
52411     return 0;
52412   }
52413   {
52414     try {
52415       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
52416     } CALL_CATCH_EXCEPTION(0);
52417   }
52418
52419   jresult = (void *)result;
52420   return jresult;
52421 }
52422
52423
52424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
52425   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
52426
52427   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
52428   {
52429     try {
52430       delete arg1;
52431     } CALL_CATCH_EXCEPTION();
52432   }
52433
52434 }
52435
52436
52437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
52438   void * jresult ;
52439   Dali::Toolkit::PageFactory *arg1 = 0 ;
52440   Dali::Vector2 *arg2 = 0 ;
52441   Dali::Toolkit::PageTurnPortraitView result;
52442
52443   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
52444   if (!arg1) {
52445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
52446     return 0;
52447   }
52448   arg2 = (Dali::Vector2 *)jarg2;
52449   if (!arg2) {
52450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
52451     return 0;
52452   }
52453   {
52454     try {
52455       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
52456     } CALL_CATCH_EXCEPTION(0);
52457   }
52458
52459   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
52460   return jresult;
52461 }
52462
52463
52464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
52465   void * jresult ;
52466   Dali::BaseHandle arg1 ;
52467   Dali::BaseHandle *argp1 ;
52468   Dali::Toolkit::PageTurnPortraitView result;
52469
52470   argp1 = (Dali::BaseHandle *)jarg1;
52471   if (!argp1) {
52472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52473     return 0;
52474   }
52475   arg1 = *argp1;
52476   {
52477     try {
52478       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
52479     } CALL_CATCH_EXCEPTION(0);
52480   }
52481
52482   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
52483   return jresult;
52484 }
52485
52486
52487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
52488   int jresult ;
52489   int result;
52490
52491   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
52492   jresult = (int)result;
52493   return jresult;
52494 }
52495
52496
52497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
52498   int jresult ;
52499   int result;
52500
52501   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
52502   jresult = (int)result;
52503   return jresult;
52504 }
52505
52506
52507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
52508   int jresult ;
52509   int result;
52510
52511   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
52512   jresult = (int)result;
52513   return jresult;
52514 }
52515
52516
52517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
52518   void * jresult ;
52519   Dali::Toolkit::ToggleButton::Property *result = 0 ;
52520
52521   {
52522     try {
52523       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
52524     } CALL_CATCH_EXCEPTION(0);
52525   }
52526
52527   jresult = (void *)result;
52528   return jresult;
52529 }
52530
52531
52532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
52533   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
52534
52535   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
52536   {
52537     try {
52538       delete arg1;
52539     } CALL_CATCH_EXCEPTION();
52540   }
52541
52542 }
52543
52544
52545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
52546   void * jresult ;
52547   Dali::Toolkit::ToggleButton *result = 0 ;
52548
52549   {
52550     try {
52551       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
52552     } CALL_CATCH_EXCEPTION(0);
52553   }
52554
52555   jresult = (void *)result;
52556   return jresult;
52557 }
52558
52559
52560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
52561   void * jresult ;
52562   Dali::Toolkit::ToggleButton *arg1 = 0 ;
52563   Dali::Toolkit::ToggleButton *result = 0 ;
52564
52565   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
52566   if (!arg1) {
52567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
52568     return 0;
52569   }
52570   {
52571     try {
52572       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
52573     } CALL_CATCH_EXCEPTION(0);
52574   }
52575
52576   jresult = (void *)result;
52577   return jresult;
52578 }
52579
52580
52581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
52582   void * jresult ;
52583   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
52584   Dali::Toolkit::ToggleButton *arg2 = 0 ;
52585   Dali::Toolkit::ToggleButton *result = 0 ;
52586
52587   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
52588   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
52589   if (!arg2) {
52590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
52591     return 0;
52592   }
52593   {
52594     try {
52595       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
52596     } CALL_CATCH_EXCEPTION(0);
52597   }
52598
52599   jresult = (void *)result;
52600   return jresult;
52601 }
52602
52603
52604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
52605   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
52606
52607   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
52608   {
52609     try {
52610       delete arg1;
52611     } CALL_CATCH_EXCEPTION();
52612   }
52613
52614 }
52615
52616
52617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
52618   void * jresult ;
52619   Dali::Toolkit::ToggleButton result;
52620
52621   {
52622     try {
52623       result = Dali::Toolkit::ToggleButton::New();
52624     } CALL_CATCH_EXCEPTION(0);
52625   }
52626
52627   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
52628   return jresult;
52629 }
52630
52631
52632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
52633   void * jresult ;
52634   Dali::BaseHandle arg1 ;
52635   Dali::BaseHandle *argp1 ;
52636   Dali::Toolkit::ToggleButton result;
52637
52638   argp1 = (Dali::BaseHandle *)jarg1;
52639   if (!argp1) {
52640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52641     return 0;
52642   }
52643   arg1 = *argp1;
52644   {
52645     try {
52646       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
52647     } CALL_CATCH_EXCEPTION(0);
52648   }
52649
52650   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
52651   return jresult;
52652 }
52653
52654
52655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
52656   void * jresult ;
52657   Dali::Toolkit::Visual::Base *result = 0 ;
52658
52659   {
52660     try {
52661       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
52662     } CALL_CATCH_EXCEPTION(0);
52663   }
52664
52665   jresult = (void *)result;
52666   return jresult;
52667 }
52668
52669
52670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
52671   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
52672
52673   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
52674   {
52675     try {
52676       delete arg1;
52677     } CALL_CATCH_EXCEPTION();
52678   }
52679
52680 }
52681
52682
52683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
52684   void * jresult ;
52685   Dali::Toolkit::Visual::Base *arg1 = 0 ;
52686   Dali::Toolkit::Visual::Base *result = 0 ;
52687
52688   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
52689   if (!arg1) {
52690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
52691     return 0;
52692   }
52693   {
52694     try {
52695       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
52696     } CALL_CATCH_EXCEPTION(0);
52697   }
52698
52699   jresult = (void *)result;
52700   return jresult;
52701 }
52702
52703
52704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
52705   void * jresult ;
52706   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
52707   Dali::Toolkit::Visual::Base *arg2 = 0 ;
52708   Dali::Toolkit::Visual::Base *result = 0 ;
52709
52710   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
52711   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
52712   if (!arg2) {
52713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
52714     return 0;
52715   }
52716   {
52717     try {
52718       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
52719     } CALL_CATCH_EXCEPTION(0);
52720   }
52721
52722   jresult = (void *)result;
52723   return jresult;
52724 }
52725
52726
52727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
52728   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
52729   std::string *arg2 = 0 ;
52730
52731   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
52732   if (!jarg2) {
52733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52734     return ;
52735   }
52736   std::string arg2_str(jarg2);
52737   arg2 = &arg2_str;
52738   {
52739     try {
52740       (arg1)->SetName((std::string const &)*arg2);
52741     } CALL_CATCH_EXCEPTION();
52742   }
52743
52744
52745   //argout typemap for const std::string&
52746
52747 }
52748
52749
52750 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
52751   char * jresult ;
52752   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
52753   std::string *result = 0 ;
52754
52755   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
52756   {
52757     try {
52758       result = (std::string *) &(arg1)->GetName();
52759     } CALL_CATCH_EXCEPTION(0);
52760   }
52761
52762   jresult = SWIG_csharp_string_callback(result->c_str());
52763   return jresult;
52764 }
52765
52766
52767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
52768   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
52769   Dali::Property::Map *arg2 = 0 ;
52770   Dali::Size arg3 ;
52771   Dali::Size *argp3 ;
52772
52773   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
52774   arg2 = (Dali::Property::Map *)jarg2;
52775   if (!arg2) {
52776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
52777     return ;
52778   }
52779   argp3 = (Dali::Size *)jarg3;
52780   if (!argp3) {
52781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
52782     return ;
52783   }
52784   arg3 = *argp3;
52785   {
52786     try {
52787       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
52788     } CALL_CATCH_EXCEPTION();
52789   }
52790
52791 }
52792
52793
52794 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
52795   float jresult ;
52796   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
52797   float arg2 ;
52798   float result;
52799
52800   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
52801   arg2 = (float)jarg2;
52802   {
52803     try {
52804       result = (float)(arg1)->GetHeightForWidth(arg2);
52805     } CALL_CATCH_EXCEPTION(0);
52806   }
52807
52808   jresult = result;
52809   return jresult;
52810 }
52811
52812
52813 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
52814   float jresult ;
52815   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
52816   float arg2 ;
52817   float result;
52818
52819   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
52820   arg2 = (float)jarg2;
52821   {
52822     try {
52823       result = (float)(arg1)->GetWidthForHeight(arg2);
52824     } CALL_CATCH_EXCEPTION(0);
52825   }
52826
52827   jresult = result;
52828   return jresult;
52829 }
52830
52831
52832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
52833   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
52834   Dali::Vector2 *arg2 = 0 ;
52835
52836   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
52837   arg2 = (Dali::Vector2 *)jarg2;
52838   if (!arg2) {
52839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
52840     return ;
52841   }
52842   {
52843     try {
52844       (arg1)->GetNaturalSize(*arg2);
52845     } CALL_CATCH_EXCEPTION();
52846   }
52847
52848 }
52849
52850
52851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
52852   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
52853   float arg2 ;
52854
52855   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
52856   arg2 = (int)jarg2;
52857   {
52858     try {
52859       (arg1)->SetDepthIndex(arg2);
52860     } CALL_CATCH_EXCEPTION();
52861   }
52862
52863 }
52864
52865
52866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
52867   int jresult ;
52868   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
52869   int result;
52870
52871   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
52872   {
52873     try {
52874       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
52875     } CALL_CATCH_EXCEPTION(0);
52876   }
52877
52878   jresult = result;
52879   return jresult;
52880 }
52881
52882
52883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
52884   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
52885   Dali::Property::Map *arg2 = 0 ;
52886
52887   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
52888   arg2 = (Dali::Property::Map *)jarg2;
52889   if (!arg2) {
52890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
52891     return ;
52892   }
52893   {
52894     try {
52895       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
52896     } CALL_CATCH_EXCEPTION();
52897   }
52898
52899 }
52900
52901
52902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
52903   void * jresult ;
52904   Dali::Toolkit::VisualFactory result;
52905
52906   {
52907     try {
52908       result = Dali::Toolkit::VisualFactory::Get();
52909     } CALL_CATCH_EXCEPTION(0);
52910   }
52911
52912   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
52913   return jresult;
52914 }
52915
52916
52917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
52918   void * jresult ;
52919   Dali::Toolkit::VisualFactory *result = 0 ;
52920
52921   {
52922     try {
52923       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
52924     } CALL_CATCH_EXCEPTION(0);
52925   }
52926
52927   jresult = (void *)result;
52928   return jresult;
52929 }
52930
52931
52932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
52933   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
52934
52935   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
52936   {
52937     try {
52938       delete arg1;
52939     } CALL_CATCH_EXCEPTION();
52940   }
52941
52942 }
52943
52944
52945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
52946   void * jresult ;
52947   Dali::Toolkit::VisualFactory *arg1 = 0 ;
52948   Dali::Toolkit::VisualFactory *result = 0 ;
52949
52950   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
52951   if (!arg1) {
52952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
52953     return 0;
52954   }
52955   {
52956     try {
52957       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
52958     } CALL_CATCH_EXCEPTION(0);
52959   }
52960
52961   jresult = (void *)result;
52962   return jresult;
52963 }
52964
52965
52966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
52967   void * jresult ;
52968   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
52969   Dali::Toolkit::VisualFactory *arg2 = 0 ;
52970   Dali::Toolkit::VisualFactory *result = 0 ;
52971
52972   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
52973   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
52974   if (!arg2) {
52975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
52976     return 0;
52977   }
52978   {
52979     try {
52980       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
52981     } CALL_CATCH_EXCEPTION(0);
52982   }
52983
52984   jresult = (void *)result;
52985   return jresult;
52986 }
52987
52988
52989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
52990   void * jresult ;
52991   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
52992   Dali::Property::Map *arg2 = 0 ;
52993   Dali::Toolkit::Visual::Base result;
52994
52995   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
52996   arg2 = (Dali::Property::Map *)jarg2;
52997   if (!arg2) {
52998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
52999     return 0;
53000   }
53001   {
53002     try {
53003       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
53004     } CALL_CATCH_EXCEPTION(0);
53005   }
53006
53007   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
53008   return jresult;
53009 }
53010
53011
53012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
53013   void * jresult ;
53014   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
53015   std::string *arg2 = 0 ;
53016   Dali::ImageDimensions arg3 ;
53017   Dali::ImageDimensions *argp3 ;
53018   Dali::Toolkit::Visual::Base result;
53019
53020   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
53021   if (!jarg2) {
53022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53023     return 0;
53024   }
53025   std::string arg2_str(jarg2);
53026   arg2 = &arg2_str;
53027   argp3 = (Dali::ImageDimensions *)jarg3;
53028   if (!argp3) {
53029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
53030     return 0;
53031   }
53032   arg3 = *argp3;
53033   {
53034     try {
53035       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
53036     } CALL_CATCH_EXCEPTION(0);
53037   }
53038
53039   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
53040
53041   //argout typemap for const std::string&
53042
53043   return jresult;
53044 }
53045
53046
53047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
53048   void * jresult ;
53049   Dali::Toolkit::AsyncImageLoader *result = 0 ;
53050
53051   {
53052     try {
53053       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
53054     } CALL_CATCH_EXCEPTION(0);
53055   }
53056
53057   jresult = (void *)result;
53058   return jresult;
53059 }
53060
53061
53062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
53063   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
53064
53065   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
53066   {
53067     try {
53068       delete arg1;
53069     } CALL_CATCH_EXCEPTION();
53070   }
53071
53072 }
53073
53074
53075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
53076   void * jresult ;
53077   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
53078   Dali::Toolkit::AsyncImageLoader *result = 0 ;
53079
53080   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
53081   if (!arg1) {
53082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
53083     return 0;
53084   }
53085   {
53086     try {
53087       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
53088     } CALL_CATCH_EXCEPTION(0);
53089   }
53090
53091   jresult = (void *)result;
53092   return jresult;
53093 }
53094
53095
53096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
53097   void * jresult ;
53098   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
53099   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
53100   Dali::Toolkit::AsyncImageLoader *result = 0 ;
53101
53102   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
53103   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
53104   if (!arg2) {
53105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
53106     return 0;
53107   }
53108   {
53109     try {
53110       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
53111     } CALL_CATCH_EXCEPTION(0);
53112   }
53113
53114   jresult = (void *)result;
53115   return jresult;
53116 }
53117
53118
53119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
53120   void * jresult ;
53121   Dali::Toolkit::AsyncImageLoader result;
53122
53123   {
53124     try {
53125       result = Dali::Toolkit::AsyncImageLoader::New();
53126     } CALL_CATCH_EXCEPTION(0);
53127   }
53128
53129   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
53130   return jresult;
53131 }
53132
53133
53134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
53135   void * jresult ;
53136   Dali::BaseHandle arg1 ;
53137   Dali::BaseHandle *argp1 ;
53138   Dali::Toolkit::AsyncImageLoader result;
53139
53140   argp1 = (Dali::BaseHandle *)jarg1;
53141   if (!argp1) {
53142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
53143     return 0;
53144   }
53145   arg1 = *argp1;
53146   {
53147     try {
53148       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
53149     } CALL_CATCH_EXCEPTION(0);
53150   }
53151
53152   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
53153   return jresult;
53154 }
53155
53156
53157 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
53158   unsigned int jresult ;
53159   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
53160   std::string *arg2 = 0 ;
53161   uint32_t result;
53162
53163   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
53164   if (!jarg2) {
53165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53166     return 0;
53167   }
53168   std::string arg2_str(jarg2);
53169   arg2 = &arg2_str;
53170   {
53171     try {
53172       result = (arg1)->Load((std::string const &)*arg2);
53173     } CALL_CATCH_EXCEPTION(0);
53174   }
53175
53176   jresult = result;
53177
53178   //argout typemap for const std::string&
53179
53180   return jresult;
53181 }
53182
53183
53184 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
53185   unsigned int jresult ;
53186   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
53187   std::string *arg2 = 0 ;
53188   Dali::ImageDimensions arg3 ;
53189   Dali::ImageDimensions *argp3 ;
53190   uint32_t result;
53191
53192   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
53193   if (!jarg2) {
53194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53195     return 0;
53196   }
53197   std::string arg2_str(jarg2);
53198   arg2 = &arg2_str;
53199   argp3 = (Dali::ImageDimensions *)jarg3;
53200   if (!argp3) {
53201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
53202     return 0;
53203   }
53204   arg3 = *argp3;
53205   {
53206     try {
53207       result = (arg1)->Load((std::string const &)*arg2,arg3);
53208     } CALL_CATCH_EXCEPTION(0);
53209   }
53210
53211   jresult = result;
53212
53213   //argout typemap for const std::string&
53214
53215   return jresult;
53216 }
53217
53218
53219 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, bool jarg6) {
53220   unsigned int jresult ;
53221   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
53222   std::string *arg2 = 0 ;
53223   Dali::ImageDimensions arg3 ;
53224   Dali::FittingMode::Type arg4 ;
53225   Dali::SamplingMode::Type arg5 ;
53226   bool arg6 ;
53227   Dali::ImageDimensions *argp3 ;
53228   uint32_t result;
53229
53230   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
53231   if (!jarg2) {
53232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53233     return 0;
53234   }
53235   std::string arg2_str(jarg2);
53236   arg2 = &arg2_str;
53237   argp3 = (Dali::ImageDimensions *)jarg3;
53238   if (!argp3) {
53239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
53240     return 0;
53241   }
53242   arg3 = *argp3;
53243   arg4 = (Dali::FittingMode::Type)jarg4;
53244   arg5 = (Dali::SamplingMode::Type)jarg5;
53245   arg6 = jarg6 ? true : false;
53246   {
53247     try {
53248       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
53249     } CALL_CATCH_EXCEPTION(0);
53250   }
53251
53252   jresult = result;
53253
53254   //argout typemap for const std::string&
53255
53256   return jresult;
53257 }
53258
53259
53260 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
53261   bool jresult ;
53262   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
53263   uint32_t arg2 ;
53264   bool result;
53265
53266   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
53267   arg2 = (uint32_t)jarg2;
53268   {
53269     try {
53270       result = (bool)(arg1)->Cancel(arg2);
53271     } CALL_CATCH_EXCEPTION(0);
53272   }
53273
53274   jresult = result;
53275   return jresult;
53276 }
53277
53278
53279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
53280   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
53281
53282   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
53283   {
53284     try {
53285       (arg1)->CancelAll();
53286     } CALL_CATCH_EXCEPTION();
53287   }
53288
53289 }
53290
53291
53292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
53293   void * jresult ;
53294   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
53295   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
53296
53297   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
53298   {
53299     try {
53300       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
53301     } CALL_CATCH_EXCEPTION(0);
53302   }
53303
53304   jresult = (void *)result;
53305   return jresult;
53306 }
53307
53308
53309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
53310   void * jresult ;
53311   std::string *arg1 = 0 ;
53312   Dali::PixelData result;
53313
53314   if (!jarg1) {
53315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53316     return 0;
53317   }
53318   std::string arg1_str(jarg1);
53319   arg1 = &arg1_str;
53320   {
53321     try {
53322       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
53323     } CALL_CATCH_EXCEPTION(0);
53324   }
53325
53326   jresult = new Dali::PixelData((const Dali::PixelData &)result);
53327
53328   //argout typemap for const std::string&
53329
53330   return jresult;
53331 }
53332
53333
53334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
53335   void * jresult ;
53336   std::string *arg1 = 0 ;
53337   Dali::ImageDimensions arg2 ;
53338   Dali::ImageDimensions *argp2 ;
53339   Dali::PixelData result;
53340
53341   if (!jarg1) {
53342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53343     return 0;
53344   }
53345   std::string arg1_str(jarg1);
53346   arg1 = &arg1_str;
53347   argp2 = (Dali::ImageDimensions *)jarg2;
53348   if (!argp2) {
53349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
53350     return 0;
53351   }
53352   arg2 = *argp2;
53353   {
53354     try {
53355       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
53356     } CALL_CATCH_EXCEPTION(0);
53357   }
53358
53359   jresult = new Dali::PixelData((const Dali::PixelData &)result);
53360
53361   //argout typemap for const std::string&
53362
53363   return jresult;
53364 }
53365
53366
53367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
53368   void * jresult ;
53369   std::string *arg1 = 0 ;
53370   Dali::ImageDimensions arg2 ;
53371   Dali::FittingMode::Type arg3 ;
53372   Dali::SamplingMode::Type arg4 ;
53373   bool arg5 ;
53374   Dali::ImageDimensions *argp2 ;
53375   Dali::PixelData result;
53376
53377   if (!jarg1) {
53378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53379     return 0;
53380   }
53381   std::string arg1_str(jarg1);
53382   arg1 = &arg1_str;
53383   argp2 = (Dali::ImageDimensions *)jarg2;
53384   if (!argp2) {
53385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
53386     return 0;
53387   }
53388   arg2 = *argp2;
53389   arg3 = (Dali::FittingMode::Type)jarg3;
53390   arg4 = (Dali::SamplingMode::Type)jarg4;
53391   arg5 = jarg5 ? true : false;
53392   {
53393     try {
53394       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
53395     } CALL_CATCH_EXCEPTION(0);
53396   }
53397
53398   jresult = new Dali::PixelData((const Dali::PixelData &)result);
53399
53400   //argout typemap for const std::string&
53401
53402   return jresult;
53403 }
53404
53405
53406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
53407   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
53408
53409   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
53410   {
53411     try {
53412       delete arg1;
53413     } CALL_CATCH_EXCEPTION();
53414   }
53415
53416 }
53417
53418
53419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * customAlgorithmInterface, void * currentFocusedActor, void * proposedActorToFocus, int direction, char * deviceName) {
53420   void * jresult ;
53421   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
53422   Dali::Actor arg2 ;
53423   Dali::Actor arg3 ;
53424   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
53425   std::string *arg5 = 0 ;
53426   Dali::Actor *argp2 ;
53427   Dali::Actor *argp3 ;
53428   Dali::Actor result;
53429
53430   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)customAlgorithmInterface;
53431   argp2 = (Dali::Actor *)currentFocusedActor;
53432   if (!argp2) {
53433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53434     return 0;
53435   }
53436   arg2 = *argp2;
53437   argp3 = (Dali::Actor *)proposedActorToFocus;
53438   if (!argp3) {
53439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53440     return 0;
53441   }
53442   arg3 = *argp3;
53443   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)direction;
53444
53445   std::string arg5_str(deviceName);
53446   arg5 = &arg5_str;
53447
53448   {
53449     try {
53450       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4,(std::string const &)*arg5);
53451     } CALL_CATCH_EXCEPTION(0);
53452   }
53453
53454   jresult = new Dali::Actor((const Dali::Actor &)result);
53455   return jresult;
53456 }
53457
53458
53459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
53460   void * jresult ;
53461   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
53462
53463   {
53464     try {
53465       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
53466     } CALL_CATCH_EXCEPTION(0);
53467   }
53468
53469   jresult = (void *)result;
53470   return jresult;
53471 }
53472
53473
53474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback0_t callback0) {
53475   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg;
53476   SwigDirector_FrameCallbackInterface *director = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
53477   if (director) {
53478     director->swig_connect_director(callback0);
53479   }
53480 }
53481
53482
53483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameCallbackInterface() {
53484   void * jresult ;
53485   Dali::FrameCallbackInterface *result = 0 ;
53486
53487   {
53488     try {
53489       result =(Dali::FrameCallbackInterface *) new SwigDirector_FrameCallbackInterface();
53490     } CALL_CATCH_EXCEPTION(0);
53491   }
53492
53493   jresult = (void *)result;
53494   return jresult;
53495 }
53496
53497 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPosition(void * updateProxy, unsigned int id,  void* position) {
53498   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
53499   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
53500   return proxy->GetPosition(id, *vector3);
53501 }
53502
53503 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetPosition(void * updateProxy, unsigned int id, void* position) {
53504   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
53505   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
53506   return proxy->SetPosition(id, *vector3);
53507 }
53508
53509 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakePosition(void * updateProxy, unsigned int id, void* position) {
53510   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
53511   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
53512   return proxy->BakePosition(id, *vector3);
53513 }
53514
53515 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetSize(void * updateProxy, unsigned int id, void* size) {
53516   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
53517   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
53518   return proxy->GetSize(id, *vector3);
53519 }
53520
53521 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetSize(void * updateProxy, unsigned int id, void* size) {
53522   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
53523   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
53524   return proxy->SetSize(id, *vector3);
53525 }
53526 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeSize(void * updateProxy, unsigned int id, void* size) {
53527   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
53528   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
53529   return proxy->BakeSize(id, *vector3);
53530 }
53531
53532 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPositionAndSize(void * updateProxy, unsigned int id, void* position, void* size) {
53533   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
53534   Dali::Vector3* vector3_pos = (Dali::Vector3 *)position;
53535   Dali::Vector3* vector3_size = (Dali::Vector3 *)size;
53536   return proxy->GetPositionAndSize(id, *vector3_pos, *vector3_size);
53537 }
53538
53539 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetScale(void * updateProxy, unsigned int id, void* scale) {
53540   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
53541   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
53542   return proxy->GetScale(id,* vector3);
53543 }
53544
53545 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetScale(void * updateProxy, unsigned int id, void* scale) {
53546   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
53547   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
53548   return proxy->SetScale(id, *vector3);
53549 }
53550
53551 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeScale(void * updateProxy, unsigned int id, void* scale) {
53552   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
53553   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
53554   return proxy->BakeScale(id, *vector3);
53555 }
53556
53557 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetColor(void * updateProxy, unsigned int id, void* color) {
53558   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
53559   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
53560   return proxy->GetColor(id, *vector4);
53561 }
53562
53563 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetColor(void * updateProxy, unsigned int id, void* color) {
53564   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
53565   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
53566   return proxy->SetColor(id, *vector4);
53567 }
53568
53569 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeColor(void * updateProxy, unsigned int id, void* color) {
53570   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
53571   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
53572   return proxy->BakeColor(id, *vector4);
53573 }
53574
53575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_AddFrameCallback(void * jarg1, void* jarg2, void* jarg3) {
53576   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
53577   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
53578
53579   Dali::Stage *arg1 = (Dali::Stage *) 0;
53580   Dali::Actor *arg3 = 0;
53581
53582   arg1 = (Dali::Stage *)jarg1;
53583   arg3 = (Dali::Actor *)jarg3;
53584
53585   DevelStage::AddFrameCallback( *arg1, *arg2, *arg3 );
53586   return;
53587 }
53588
53589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_RemoveFrameCallback(void * jarg1, void* jarg2) {
53590
53591   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
53592   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
53593
53594   Dali::Stage *arg1 = (Dali::Stage *) 0;
53595
53596   arg1 = (Dali::Stage *)jarg1;
53597
53598   DevelStage::RemoveFrameCallback( *arg1, *arg2 );
53599   return;
53600 }
53601
53602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
53603   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
53604   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
53605   if (director) {
53606     director->swig_connect_director(callback0);
53607   }
53608 }
53609
53610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
53611   KeyboardFocusManager arg1 ;
53612   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
53613   KeyboardFocusManager *argp1 ;
53614
53615   argp1 = (KeyboardFocusManager *)jarg1;
53616   if (!argp1) {
53617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
53618     return ;
53619   }
53620   arg1 = *argp1;
53621   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
53622   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
53623   {
53624     try {
53625       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
53626     } CALL_CATCH_EXCEPTION();
53627   }
53628
53629 }
53630
53631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_EnableDefaultAlgorithm(void * jarg1, bool jarg2) {
53632   KeyboardFocusManager arg1 ;
53633   bool arg2 ;
53634   KeyboardFocusManager *argp1 ;
53635
53636   argp1 = (KeyboardFocusManager *)jarg1;
53637   if (!argp1) {
53638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
53639     return ;
53640   }
53641   arg1 = *argp1;
53642   arg2 = jarg2;
53643   {
53644     try {
53645       Dali::Toolkit::DevelKeyboardFocusManager::EnableDefaultAlgorithm(arg1, arg2);
53646     } CALL_CATCH_EXCEPTION();
53647   }
53648 }
53649
53650 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_IsDefaultAlgorithmEnabled(void * jarg1) {
53651   bool jresult ;
53652   KeyboardFocusManager arg1 ;
53653   KeyboardFocusManager *argp1 ;
53654   bool result;
53655
53656   argp1 = (KeyboardFocusManager *)jarg1;
53657   if (!argp1) {
53658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
53659     return false;
53660   }
53661   arg1 = *argp1;
53662   {
53663     try {
53664       result = Dali::Toolkit::DevelKeyboardFocusManager::IsDefaultAlgorithmEnabled(arg1);
53665     } CALL_CATCH_EXCEPTION(0);
53666   }
53667   jresult = result;
53668   return jresult;
53669 }
53670
53671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_SetFocusFinderRootActor(void * manager, void * actor) {
53672   if (!manager) {
53673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
53674     return ;
53675   }
53676   if (!actor) {
53677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
53678     return ;
53679   }
53680   {
53681     try {
53682       Dali::Toolkit::DevelKeyboardFocusManager::SetFocusFinderRootActor(*(KeyboardFocusManager *)manager, *(Dali::Actor *)actor);
53683     } CALL_CATCH_EXCEPTION();
53684   }
53685 }
53686
53687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_ResetFocusFinderRootActor(void * manager) {
53688   if (!manager) {
53689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
53690     return ;
53691   }
53692   {
53693     try {
53694       Dali::Toolkit::DevelKeyboardFocusManager::ResetFocusFinderRootActor(*(KeyboardFocusManager *)manager);
53695     } CALL_CATCH_EXCEPTION();
53696   }
53697 }
53698
53699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
53700   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53701
53702   arg1 = (std::vector< unsigned int > *)jarg1;
53703   {
53704     try {
53705       (arg1)->clear();
53706     } CALL_CATCH_EXCEPTION();
53707   }
53708
53709 }
53710
53711
53712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
53713   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53714   unsigned int *arg2 = 0 ;
53715   unsigned int temp2 ;
53716
53717   arg1 = (std::vector< unsigned int > *)jarg1;
53718   temp2 = (unsigned int)jarg2;
53719   arg2 = &temp2;
53720   {
53721     try {
53722       (arg1)->push_back((unsigned int const &)*arg2);
53723     } CALL_CATCH_EXCEPTION();
53724   }
53725
53726 }
53727
53728
53729 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
53730   unsigned long jresult ;
53731   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53732   std::vector< unsigned int >::size_type result;
53733
53734   arg1 = (std::vector< unsigned int > *)jarg1;
53735   {
53736     try {
53737       result = ((std::vector< unsigned int > const *)arg1)->size();
53738     } CALL_CATCH_EXCEPTION(0);
53739   }
53740
53741   jresult = (unsigned long)result;
53742   return jresult;
53743 }
53744
53745
53746 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
53747   unsigned long jresult ;
53748   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53749   std::vector< unsigned int >::size_type result;
53750
53751   arg1 = (std::vector< unsigned int > *)jarg1;
53752   {
53753     try {
53754       result = ((std::vector< unsigned int > const *)arg1)->capacity();
53755     } CALL_CATCH_EXCEPTION(0);
53756   }
53757
53758   jresult = (unsigned long)result;
53759   return jresult;
53760 }
53761
53762
53763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
53764   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53765   std::vector< unsigned int >::size_type arg2 ;
53766
53767   arg1 = (std::vector< unsigned int > *)jarg1;
53768   arg2 = (std::vector< unsigned int >::size_type)jarg2;
53769   {
53770     try {
53771       (arg1)->reserve(arg2);
53772     } CALL_CATCH_EXCEPTION();
53773   }
53774
53775 }
53776
53777
53778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
53779   void * jresult ;
53780   std::vector< unsigned int > *result = 0 ;
53781
53782   {
53783     try {
53784       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
53785     } CALL_CATCH_EXCEPTION(0);
53786   }
53787
53788   jresult = (void *)result;
53789   return jresult;
53790 }
53791
53792
53793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
53794   void * jresult ;
53795   std::vector< unsigned int > *arg1 = 0 ;
53796   std::vector< unsigned int > *result = 0 ;
53797
53798   arg1 = (std::vector< unsigned int > *)jarg1;
53799   if (!arg1) {
53800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
53801     return 0;
53802   }
53803   {
53804     try {
53805       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
53806     } CALL_CATCH_EXCEPTION(0);
53807   }
53808
53809   jresult = (void *)result;
53810   return jresult;
53811 }
53812
53813
53814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
53815   void * jresult ;
53816   int arg1 ;
53817   std::vector< unsigned int > *result = 0 ;
53818
53819   arg1 = (int)jarg1;
53820   {
53821     try {
53822       try {
53823         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
53824       }
53825       catch(std::out_of_range &_e) {
53826         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53827         return 0;
53828       }
53829
53830     } CALL_CATCH_EXCEPTION(0);
53831   }
53832
53833   jresult = (void *)result;
53834   return jresult;
53835 }
53836
53837
53838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
53839   unsigned int jresult ;
53840   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53841   int arg2 ;
53842   unsigned int result;
53843
53844   arg1 = (std::vector< unsigned int > *)jarg1;
53845   arg2 = (int)jarg2;
53846   {
53847     try {
53848       try {
53849         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
53850       }
53851       catch(std::out_of_range &_e) {
53852         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53853         return 0;
53854       }
53855
53856     } CALL_CATCH_EXCEPTION(0);
53857   }
53858
53859   jresult = result;
53860   return jresult;
53861 }
53862
53863
53864 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
53865   unsigned int jresult ;
53866   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53867   int arg2 ;
53868   unsigned int *result = 0 ;
53869
53870   arg1 = (std::vector< unsigned int > *)jarg1;
53871   arg2 = (int)jarg2;
53872   {
53873     try {
53874       try {
53875         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
53876       }
53877       catch(std::out_of_range &_e) {
53878         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53879         return 0;
53880       }
53881
53882     } CALL_CATCH_EXCEPTION(0);
53883   }
53884
53885   jresult = *result;
53886   return jresult;
53887 }
53888
53889
53890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
53891   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53892   int arg2 ;
53893   unsigned int *arg3 = 0 ;
53894   unsigned int temp3 ;
53895
53896   arg1 = (std::vector< unsigned int > *)jarg1;
53897   arg2 = (int)jarg2;
53898   temp3 = (unsigned int)jarg3;
53899   arg3 = &temp3;
53900   {
53901     try {
53902       try {
53903         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
53904       }
53905       catch(std::out_of_range &_e) {
53906         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53907         return ;
53908       }
53909
53910     } CALL_CATCH_EXCEPTION();
53911   }
53912
53913 }
53914
53915
53916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
53917   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53918   std::vector< unsigned int > *arg2 = 0 ;
53919
53920   arg1 = (std::vector< unsigned int > *)jarg1;
53921   arg2 = (std::vector< unsigned int > *)jarg2;
53922   if (!arg2) {
53923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
53924     return ;
53925   }
53926   {
53927     try {
53928       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
53929     } CALL_CATCH_EXCEPTION();
53930   }
53931
53932 }
53933
53934
53935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
53936   void * jresult ;
53937   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53938   int arg2 ;
53939   int arg3 ;
53940   std::vector< unsigned int > *result = 0 ;
53941
53942   arg1 = (std::vector< unsigned int > *)jarg1;
53943   arg2 = (int)jarg2;
53944   arg3 = (int)jarg3;
53945   {
53946     try {
53947       try {
53948         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
53949       }
53950       catch(std::out_of_range &_e) {
53951         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53952         return 0;
53953       }
53954       catch(std::invalid_argument &_e) {
53955         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53956         return 0;
53957       }
53958
53959     } CALL_CATCH_EXCEPTION(0);
53960   }
53961
53962   jresult = (void *)result;
53963   return jresult;
53964 }
53965
53966
53967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
53968   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53969   int arg2 ;
53970   unsigned int *arg3 = 0 ;
53971   unsigned int temp3 ;
53972
53973   arg1 = (std::vector< unsigned int > *)jarg1;
53974   arg2 = (int)jarg2;
53975   temp3 = (unsigned int)jarg3;
53976   arg3 = &temp3;
53977   {
53978     try {
53979       try {
53980         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
53981       }
53982       catch(std::out_of_range &_e) {
53983         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53984         return ;
53985       }
53986
53987     } CALL_CATCH_EXCEPTION();
53988   }
53989
53990 }
53991
53992
53993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
53994   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53995   int arg2 ;
53996   std::vector< unsigned int > *arg3 = 0 ;
53997
53998   arg1 = (std::vector< unsigned int > *)jarg1;
53999   arg2 = (int)jarg2;
54000   arg3 = (std::vector< unsigned int > *)jarg3;
54001   if (!arg3) {
54002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
54003     return ;
54004   }
54005   {
54006     try {
54007       try {
54008         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
54009       }
54010       catch(std::out_of_range &_e) {
54011         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54012         return ;
54013       }
54014
54015     } CALL_CATCH_EXCEPTION();
54016   }
54017
54018 }
54019
54020
54021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
54022   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54023   int arg2 ;
54024
54025   arg1 = (std::vector< unsigned int > *)jarg1;
54026   arg2 = (int)jarg2;
54027   {
54028     try {
54029       try {
54030         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
54031       }
54032       catch(std::out_of_range &_e) {
54033         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54034         return ;
54035       }
54036
54037     } CALL_CATCH_EXCEPTION();
54038   }
54039
54040 }
54041
54042
54043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
54044   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54045   int arg2 ;
54046   int arg3 ;
54047
54048   arg1 = (std::vector< unsigned int > *)jarg1;
54049   arg2 = (int)jarg2;
54050   arg3 = (int)jarg3;
54051   {
54052     try {
54053       try {
54054         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
54055       }
54056       catch(std::out_of_range &_e) {
54057         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54058         return ;
54059       }
54060       catch(std::invalid_argument &_e) {
54061         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
54062         return ;
54063       }
54064
54065     } CALL_CATCH_EXCEPTION();
54066   }
54067
54068 }
54069
54070
54071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
54072   void * jresult ;
54073   unsigned int *arg1 = 0 ;
54074   int arg2 ;
54075   unsigned int temp1 ;
54076   std::vector< unsigned int > *result = 0 ;
54077
54078   temp1 = (unsigned int)jarg1;
54079   arg1 = &temp1;
54080   arg2 = (int)jarg2;
54081   {
54082     try {
54083       try {
54084         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
54085       }
54086       catch(std::out_of_range &_e) {
54087         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54088         return 0;
54089       }
54090
54091     } CALL_CATCH_EXCEPTION(0);
54092   }
54093
54094   jresult = (void *)result;
54095   return jresult;
54096 }
54097
54098
54099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
54100   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54101
54102   arg1 = (std::vector< unsigned int > *)jarg1;
54103   {
54104     try {
54105       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
54106     } CALL_CATCH_EXCEPTION();
54107   }
54108
54109 }
54110
54111
54112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
54113   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54114   int arg2 ;
54115   int arg3 ;
54116
54117   arg1 = (std::vector< unsigned int > *)jarg1;
54118   arg2 = (int)jarg2;
54119   arg3 = (int)jarg3;
54120   {
54121     try {
54122       try {
54123         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
54124       }
54125       catch(std::out_of_range &_e) {
54126         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54127         return ;
54128       }
54129       catch(std::invalid_argument &_e) {
54130         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
54131         return ;
54132       }
54133
54134     } CALL_CATCH_EXCEPTION();
54135   }
54136
54137 }
54138
54139
54140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
54141   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54142   int arg2 ;
54143   std::vector< unsigned int > *arg3 = 0 ;
54144
54145   arg1 = (std::vector< unsigned int > *)jarg1;
54146   arg2 = (int)jarg2;
54147   arg3 = (std::vector< unsigned int > *)jarg3;
54148   if (!arg3) {
54149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
54150     return ;
54151   }
54152   {
54153     try {
54154       try {
54155         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
54156       }
54157       catch(std::out_of_range &_e) {
54158         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54159         return ;
54160       }
54161
54162     } CALL_CATCH_EXCEPTION();
54163   }
54164
54165 }
54166
54167
54168 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
54169   bool jresult ;
54170   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54171   unsigned int *arg2 = 0 ;
54172   unsigned int temp2 ;
54173   bool result;
54174
54175   arg1 = (std::vector< unsigned int > *)jarg1;
54176   temp2 = (unsigned int)jarg2;
54177   arg2 = &temp2;
54178   {
54179     try {
54180       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
54181     } CALL_CATCH_EXCEPTION(0);
54182   }
54183
54184   jresult = result;
54185   return jresult;
54186 }
54187
54188
54189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
54190   int jresult ;
54191   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54192   unsigned int *arg2 = 0 ;
54193   unsigned int temp2 ;
54194   int result;
54195
54196   arg1 = (std::vector< unsigned int > *)jarg1;
54197   temp2 = (unsigned int)jarg2;
54198   arg2 = &temp2;
54199   {
54200     try {
54201       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
54202     } CALL_CATCH_EXCEPTION(0);
54203   }
54204
54205   jresult = result;
54206   return jresult;
54207 }
54208
54209
54210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
54211   int jresult ;
54212   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54213   unsigned int *arg2 = 0 ;
54214   unsigned int temp2 ;
54215   int result;
54216
54217   arg1 = (std::vector< unsigned int > *)jarg1;
54218   temp2 = (unsigned int)jarg2;
54219   arg2 = &temp2;
54220   {
54221     try {
54222       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
54223     } CALL_CATCH_EXCEPTION(0);
54224   }
54225
54226   jresult = result;
54227   return jresult;
54228 }
54229
54230
54231 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
54232   bool jresult ;
54233   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54234   unsigned int *arg2 = 0 ;
54235   unsigned int temp2 ;
54236   bool result;
54237
54238   arg1 = (std::vector< unsigned int > *)jarg1;
54239   temp2 = (unsigned int)jarg2;
54240   arg2 = &temp2;
54241   {
54242     try {
54243       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
54244     } CALL_CATCH_EXCEPTION(0);
54245   }
54246
54247   jresult = result;
54248   return jresult;
54249 }
54250
54251
54252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
54253   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54254
54255   arg1 = (std::vector< unsigned int > *)jarg1;
54256   {
54257     try {
54258       delete arg1;
54259     } CALL_CATCH_EXCEPTION();
54260   }
54261
54262 }
54263
54264
54265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
54266   void * jresult ;
54267   std::pair< unsigned int,Dali::Actor > *result = 0 ;
54268
54269   {
54270     try {
54271       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
54272     } CALL_CATCH_EXCEPTION(0);
54273   }
54274
54275   jresult = (void *)result;
54276   return jresult;
54277 }
54278
54279
54280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
54281   void * jresult ;
54282   unsigned int arg1 ;
54283   Dali::Actor arg2 ;
54284   Dali::Actor *argp2 ;
54285   std::pair< unsigned int,Dali::Actor > *result = 0 ;
54286
54287   arg1 = (unsigned int)jarg1;
54288   argp2 = (Dali::Actor *)jarg2;
54289   if (!argp2) {
54290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54291     return 0;
54292   }
54293   arg2 = *argp2;
54294   {
54295     try {
54296       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
54297     } CALL_CATCH_EXCEPTION(0);
54298   }
54299
54300   jresult = (void *)result;
54301   return jresult;
54302 }
54303
54304
54305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
54306   void * jresult ;
54307   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
54308   std::pair< unsigned int,Dali::Actor > *result = 0 ;
54309
54310   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
54311   if (!arg1) {
54312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
54313     return 0;
54314   }
54315   {
54316     try {
54317       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
54318     } CALL_CATCH_EXCEPTION(0);
54319   }
54320
54321   jresult = (void *)result;
54322   return jresult;
54323 }
54324
54325
54326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
54327   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
54328   unsigned int arg2 ;
54329
54330   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
54331   arg2 = (unsigned int)jarg2;
54332   if (arg1) (arg1)->first = arg2;
54333 }
54334
54335
54336 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
54337   unsigned int jresult ;
54338   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
54339   unsigned int result;
54340
54341   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
54342   result = (unsigned int) ((arg1)->first);
54343   jresult = result;
54344   return jresult;
54345 }
54346
54347
54348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
54349   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
54350   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
54351
54352   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
54353   arg2 = (Dali::Actor *)jarg2;
54354   if (arg1) (arg1)->second = *arg2;
54355 }
54356
54357
54358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
54359   void * jresult ;
54360   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
54361   Dali::Actor *result = 0 ;
54362
54363   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
54364   result = (Dali::Actor *)& ((arg1)->second);
54365   jresult = (void *)result;
54366   return jresult;
54367 }
54368
54369
54370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
54371   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
54372
54373   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
54374   {
54375     try {
54376       delete arg1;
54377     } CALL_CATCH_EXCEPTION();
54378   }
54379
54380 }
54381
54382
54383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
54384   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54385
54386   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54387   {
54388     try {
54389       (arg1)->clear();
54390     } CALL_CATCH_EXCEPTION();
54391   }
54392
54393 }
54394
54395
54396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
54397   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54398   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
54399
54400   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54401   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
54402   if (!arg2) {
54403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
54404     return ;
54405   }
54406   {
54407     try {
54408       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
54409     } CALL_CATCH_EXCEPTION();
54410   }
54411
54412 }
54413
54414
54415 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
54416   unsigned long jresult ;
54417   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54418   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
54419
54420   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54421   {
54422     try {
54423       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
54424     } CALL_CATCH_EXCEPTION(0);
54425   }
54426
54427   jresult = (unsigned long)result;
54428   return jresult;
54429 }
54430
54431
54432 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
54433   unsigned long jresult ;
54434   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54435   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
54436
54437   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54438   {
54439     try {
54440       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
54441     } CALL_CATCH_EXCEPTION(0);
54442   }
54443
54444   jresult = (unsigned long)result;
54445   return jresult;
54446 }
54447
54448
54449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
54450   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54451   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
54452
54453   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54454   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
54455   {
54456     try {
54457       (arg1)->reserve(arg2);
54458     } CALL_CATCH_EXCEPTION();
54459   }
54460
54461 }
54462
54463
54464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
54465   void * jresult ;
54466   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
54467
54468   {
54469     try {
54470       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
54471     } CALL_CATCH_EXCEPTION(0);
54472   }
54473
54474   jresult = (void *)result;
54475   return jresult;
54476 }
54477
54478
54479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
54480   void * jresult ;
54481   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
54482   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
54483
54484   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54485   if (!arg1) {
54486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
54487     return 0;
54488   }
54489   {
54490     try {
54491       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);
54492     } CALL_CATCH_EXCEPTION(0);
54493   }
54494
54495   jresult = (void *)result;
54496   return jresult;
54497 }
54498
54499
54500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
54501   void * jresult ;
54502   int arg1 ;
54503   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
54504
54505   arg1 = (int)jarg1;
54506   {
54507     try {
54508       try {
54509         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);
54510       }
54511       catch(std::out_of_range &_e) {
54512         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54513         return 0;
54514       }
54515
54516     } CALL_CATCH_EXCEPTION(0);
54517   }
54518
54519   jresult = (void *)result;
54520   return jresult;
54521 }
54522
54523
54524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
54525   void * jresult ;
54526   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54527   int arg2 ;
54528   std::pair< unsigned int,Dali::Actor > result;
54529
54530   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54531   arg2 = (int)jarg2;
54532   {
54533     try {
54534       try {
54535         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
54536       }
54537       catch(std::out_of_range &_e) {
54538         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54539         return 0;
54540       }
54541
54542     } CALL_CATCH_EXCEPTION(0);
54543   }
54544
54545   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
54546   return jresult;
54547 }
54548
54549
54550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
54551   void * jresult ;
54552   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54553   int arg2 ;
54554   std::pair< unsigned int,Dali::Actor > *result = 0 ;
54555
54556   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54557   arg2 = (int)jarg2;
54558   {
54559     try {
54560       try {
54561         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
54562       }
54563       catch(std::out_of_range &_e) {
54564         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54565         return 0;
54566       }
54567
54568     } CALL_CATCH_EXCEPTION(0);
54569   }
54570
54571   jresult = (void *)result;
54572   return jresult;
54573 }
54574
54575
54576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
54577   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54578   int arg2 ;
54579   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
54580
54581   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54582   arg2 = (int)jarg2;
54583   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
54584   if (!arg3) {
54585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
54586     return ;
54587   }
54588   {
54589     try {
54590       try {
54591         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);
54592       }
54593       catch(std::out_of_range &_e) {
54594         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54595         return ;
54596       }
54597
54598     } CALL_CATCH_EXCEPTION();
54599   }
54600
54601 }
54602
54603
54604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
54605   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54606   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
54607
54608   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54609   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
54610   if (!arg2) {
54611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
54612     return ;
54613   }
54614   {
54615     try {
54616       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);
54617     } CALL_CATCH_EXCEPTION();
54618   }
54619
54620 }
54621
54622
54623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
54624   void * jresult ;
54625   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54626   int arg2 ;
54627   int arg3 ;
54628   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
54629
54630   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54631   arg2 = (int)jarg2;
54632   arg3 = (int)jarg3;
54633   {
54634     try {
54635       try {
54636         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);
54637       }
54638       catch(std::out_of_range &_e) {
54639         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54640         return 0;
54641       }
54642       catch(std::invalid_argument &_e) {
54643         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
54644         return 0;
54645       }
54646
54647     } CALL_CATCH_EXCEPTION(0);
54648   }
54649
54650   jresult = (void *)result;
54651   return jresult;
54652 }
54653
54654
54655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
54656   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54657   int arg2 ;
54658   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
54659
54660   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54661   arg2 = (int)jarg2;
54662   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
54663   if (!arg3) {
54664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
54665     return ;
54666   }
54667   {
54668     try {
54669       try {
54670         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);
54671       }
54672       catch(std::out_of_range &_e) {
54673         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54674         return ;
54675       }
54676
54677     } CALL_CATCH_EXCEPTION();
54678   }
54679
54680 }
54681
54682
54683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
54684   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54685   int arg2 ;
54686   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
54687
54688   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54689   arg2 = (int)jarg2;
54690   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
54691   if (!arg3) {
54692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
54693     return ;
54694   }
54695   {
54696     try {
54697       try {
54698         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);
54699       }
54700       catch(std::out_of_range &_e) {
54701         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54702         return ;
54703       }
54704
54705     } CALL_CATCH_EXCEPTION();
54706   }
54707
54708 }
54709
54710
54711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
54712   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54713   int arg2 ;
54714
54715   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54716   arg2 = (int)jarg2;
54717   {
54718     try {
54719       try {
54720         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
54721       }
54722       catch(std::out_of_range &_e) {
54723         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54724         return ;
54725       }
54726
54727     } CALL_CATCH_EXCEPTION();
54728   }
54729
54730 }
54731
54732
54733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
54734   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54735   int arg2 ;
54736   int arg3 ;
54737
54738   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54739   arg2 = (int)jarg2;
54740   arg3 = (int)jarg3;
54741   {
54742     try {
54743       try {
54744         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
54745       }
54746       catch(std::out_of_range &_e) {
54747         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54748         return ;
54749       }
54750       catch(std::invalid_argument &_e) {
54751         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
54752         return ;
54753       }
54754
54755     } CALL_CATCH_EXCEPTION();
54756   }
54757
54758 }
54759
54760
54761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
54762   void * jresult ;
54763   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
54764   int arg2 ;
54765   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
54766
54767   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
54768   if (!arg1) {
54769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
54770     return 0;
54771   }
54772   arg2 = (int)jarg2;
54773   {
54774     try {
54775       try {
54776         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);
54777       }
54778       catch(std::out_of_range &_e) {
54779         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54780         return 0;
54781       }
54782
54783     } CALL_CATCH_EXCEPTION(0);
54784   }
54785
54786   jresult = (void *)result;
54787   return jresult;
54788 }
54789
54790
54791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
54792   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54793
54794   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54795   {
54796     try {
54797       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
54798     } CALL_CATCH_EXCEPTION();
54799   }
54800
54801 }
54802
54803
54804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
54805   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54806   int arg2 ;
54807   int arg3 ;
54808
54809   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54810   arg2 = (int)jarg2;
54811   arg3 = (int)jarg3;
54812   {
54813     try {
54814       try {
54815         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
54816       }
54817       catch(std::out_of_range &_e) {
54818         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54819         return ;
54820       }
54821       catch(std::invalid_argument &_e) {
54822         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
54823         return ;
54824       }
54825
54826     } CALL_CATCH_EXCEPTION();
54827   }
54828
54829 }
54830
54831
54832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
54833   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54834   int arg2 ;
54835   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
54836
54837   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54838   arg2 = (int)jarg2;
54839   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
54840   if (!arg3) {
54841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
54842     return ;
54843   }
54844   {
54845     try {
54846       try {
54847         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);
54848       }
54849       catch(std::out_of_range &_e) {
54850         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54851         return ;
54852       }
54853
54854     } CALL_CATCH_EXCEPTION();
54855   }
54856
54857 }
54858
54859
54860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
54861   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54862
54863   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54864   {
54865     try {
54866       delete arg1;
54867     } CALL_CATCH_EXCEPTION();
54868   }
54869
54870 }
54871
54872
54873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
54874   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54875
54876   arg1 = (std::vector< Dali::Actor > *)jarg1;
54877   {
54878     try {
54879       (arg1)->clear();
54880     } CALL_CATCH_EXCEPTION();
54881   }
54882
54883 }
54884
54885
54886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
54887   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54888   Dali::Actor *arg2 = 0 ;
54889
54890   arg1 = (std::vector< Dali::Actor > *)jarg1;
54891   arg2 = (Dali::Actor *)jarg2;
54892   if (!arg2) {
54893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
54894     return ;
54895   }
54896   {
54897     try {
54898       (arg1)->push_back((Dali::Actor const &)*arg2);
54899     } CALL_CATCH_EXCEPTION();
54900   }
54901
54902 }
54903
54904
54905 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
54906   unsigned long jresult ;
54907   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54908   std::vector< Dali::Actor >::size_type result;
54909
54910   arg1 = (std::vector< Dali::Actor > *)jarg1;
54911   {
54912     try {
54913       result = ((std::vector< Dali::Actor > const *)arg1)->size();
54914     } CALL_CATCH_EXCEPTION(0);
54915   }
54916
54917   jresult = (unsigned long)result;
54918   return jresult;
54919 }
54920
54921
54922 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
54923   unsigned long jresult ;
54924   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54925   std::vector< Dali::Actor >::size_type result;
54926
54927   arg1 = (std::vector< Dali::Actor > *)jarg1;
54928   {
54929     try {
54930       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
54931     } CALL_CATCH_EXCEPTION(0);
54932   }
54933
54934   jresult = (unsigned long)result;
54935   return jresult;
54936 }
54937
54938
54939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
54940   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54941   std::vector< Dali::Actor >::size_type arg2 ;
54942
54943   arg1 = (std::vector< Dali::Actor > *)jarg1;
54944   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
54945   {
54946     try {
54947       (arg1)->reserve(arg2);
54948     } CALL_CATCH_EXCEPTION();
54949   }
54950
54951 }
54952
54953
54954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
54955   void * jresult ;
54956   std::vector< Dali::Actor > *result = 0 ;
54957
54958   {
54959     try {
54960       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
54961     } CALL_CATCH_EXCEPTION(0);
54962   }
54963
54964   jresult = (void *)result;
54965   return jresult;
54966 }
54967
54968
54969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
54970   void * jresult ;
54971   std::vector< Dali::Actor > *arg1 = 0 ;
54972   std::vector< Dali::Actor > *result = 0 ;
54973
54974   arg1 = (std::vector< Dali::Actor > *)jarg1;
54975   if (!arg1) {
54976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
54977     return 0;
54978   }
54979   {
54980     try {
54981       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
54982     } CALL_CATCH_EXCEPTION(0);
54983   }
54984
54985   jresult = (void *)result;
54986   return jresult;
54987 }
54988
54989
54990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
54991   void * jresult ;
54992   int arg1 ;
54993   std::vector< Dali::Actor > *result = 0 ;
54994
54995   arg1 = (int)jarg1;
54996   {
54997     try {
54998       try {
54999         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
55000       }
55001       catch(std::out_of_range &_e) {
55002         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55003         return 0;
55004       }
55005
55006     } CALL_CATCH_EXCEPTION(0);
55007   }
55008
55009   jresult = (void *)result;
55010   return jresult;
55011 }
55012
55013
55014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
55015   void * jresult ;
55016   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55017   int arg2 ;
55018   Dali::Actor result;
55019
55020   arg1 = (std::vector< Dali::Actor > *)jarg1;
55021   arg2 = (int)jarg2;
55022   {
55023     try {
55024       try {
55025         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
55026       }
55027       catch(std::out_of_range &_e) {
55028         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55029         return 0;
55030       }
55031
55032     } CALL_CATCH_EXCEPTION(0);
55033   }
55034
55035   jresult = new Dali::Actor((const Dali::Actor &)result);
55036   return jresult;
55037 }
55038
55039
55040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
55041   void * jresult ;
55042   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55043   int arg2 ;
55044   Dali::Actor *result = 0 ;
55045
55046   arg1 = (std::vector< Dali::Actor > *)jarg1;
55047   arg2 = (int)jarg2;
55048   {
55049     try {
55050       try {
55051         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
55052       }
55053       catch(std::out_of_range &_e) {
55054         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55055         return 0;
55056       }
55057
55058     } CALL_CATCH_EXCEPTION(0);
55059   }
55060
55061   jresult = (void *)result;
55062   return jresult;
55063 }
55064
55065
55066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
55067   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55068   int arg2 ;
55069   Dali::Actor *arg3 = 0 ;
55070
55071   arg1 = (std::vector< Dali::Actor > *)jarg1;
55072   arg2 = (int)jarg2;
55073   arg3 = (Dali::Actor *)jarg3;
55074   if (!arg3) {
55075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
55076     return ;
55077   }
55078   {
55079     try {
55080       try {
55081         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
55082       }
55083       catch(std::out_of_range &_e) {
55084         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55085         return ;
55086       }
55087
55088     } CALL_CATCH_EXCEPTION();
55089   }
55090
55091 }
55092
55093
55094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
55095   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55096   std::vector< Dali::Actor > *arg2 = 0 ;
55097
55098   arg1 = (std::vector< Dali::Actor > *)jarg1;
55099   arg2 = (std::vector< Dali::Actor > *)jarg2;
55100   if (!arg2) {
55101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
55102     return ;
55103   }
55104   {
55105     try {
55106       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
55107     } CALL_CATCH_EXCEPTION();
55108   }
55109
55110 }
55111
55112
55113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
55114   void * jresult ;
55115   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55116   int arg2 ;
55117   int arg3 ;
55118   std::vector< Dali::Actor > *result = 0 ;
55119
55120   arg1 = (std::vector< Dali::Actor > *)jarg1;
55121   arg2 = (int)jarg2;
55122   arg3 = (int)jarg3;
55123   {
55124     try {
55125       try {
55126         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
55127       }
55128       catch(std::out_of_range &_e) {
55129         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55130         return 0;
55131       }
55132       catch(std::invalid_argument &_e) {
55133         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
55134         return 0;
55135       }
55136
55137     } CALL_CATCH_EXCEPTION(0);
55138   }
55139
55140   jresult = (void *)result;
55141   return jresult;
55142 }
55143
55144
55145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
55146   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55147   int arg2 ;
55148   Dali::Actor *arg3 = 0 ;
55149
55150   arg1 = (std::vector< Dali::Actor > *)jarg1;
55151   arg2 = (int)jarg2;
55152   arg3 = (Dali::Actor *)jarg3;
55153   if (!arg3) {
55154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
55155     return ;
55156   }
55157   {
55158     try {
55159       try {
55160         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
55161       }
55162       catch(std::out_of_range &_e) {
55163         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55164         return ;
55165       }
55166
55167     } CALL_CATCH_EXCEPTION();
55168   }
55169
55170 }
55171
55172
55173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
55174   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55175   int arg2 ;
55176   std::vector< Dali::Actor > *arg3 = 0 ;
55177
55178   arg1 = (std::vector< Dali::Actor > *)jarg1;
55179   arg2 = (int)jarg2;
55180   arg3 = (std::vector< Dali::Actor > *)jarg3;
55181   if (!arg3) {
55182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
55183     return ;
55184   }
55185   {
55186     try {
55187       try {
55188         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
55189       }
55190       catch(std::out_of_range &_e) {
55191         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55192         return ;
55193       }
55194
55195     } CALL_CATCH_EXCEPTION();
55196   }
55197
55198 }
55199
55200
55201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
55202   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55203   int arg2 ;
55204
55205   arg1 = (std::vector< Dali::Actor > *)jarg1;
55206   arg2 = (int)jarg2;
55207   {
55208     try {
55209       try {
55210         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
55211       }
55212       catch(std::out_of_range &_e) {
55213         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55214         return ;
55215       }
55216
55217     } CALL_CATCH_EXCEPTION();
55218   }
55219
55220 }
55221
55222
55223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
55224   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55225   int arg2 ;
55226   int arg3 ;
55227
55228   arg1 = (std::vector< Dali::Actor > *)jarg1;
55229   arg2 = (int)jarg2;
55230   arg3 = (int)jarg3;
55231   {
55232     try {
55233       try {
55234         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
55235       }
55236       catch(std::out_of_range &_e) {
55237         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55238         return ;
55239       }
55240       catch(std::invalid_argument &_e) {
55241         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
55242         return ;
55243       }
55244
55245     } CALL_CATCH_EXCEPTION();
55246   }
55247
55248 }
55249
55250
55251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
55252   void * jresult ;
55253   Dali::Actor *arg1 = 0 ;
55254   int arg2 ;
55255   std::vector< Dali::Actor > *result = 0 ;
55256
55257   arg1 = (Dali::Actor *)jarg1;
55258   if (!arg1) {
55259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
55260     return 0;
55261   }
55262   arg2 = (int)jarg2;
55263   {
55264     try {
55265       try {
55266         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
55267       }
55268       catch(std::out_of_range &_e) {
55269         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55270         return 0;
55271       }
55272
55273     } CALL_CATCH_EXCEPTION(0);
55274   }
55275
55276   jresult = (void *)result;
55277   return jresult;
55278 }
55279
55280
55281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
55282   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55283
55284   arg1 = (std::vector< Dali::Actor > *)jarg1;
55285   {
55286     try {
55287       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
55288     } CALL_CATCH_EXCEPTION();
55289   }
55290
55291 }
55292
55293
55294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
55295   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55296   int arg2 ;
55297   int arg3 ;
55298
55299   arg1 = (std::vector< Dali::Actor > *)jarg1;
55300   arg2 = (int)jarg2;
55301   arg3 = (int)jarg3;
55302   {
55303     try {
55304       try {
55305         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
55306       }
55307       catch(std::out_of_range &_e) {
55308         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55309         return ;
55310       }
55311       catch(std::invalid_argument &_e) {
55312         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
55313         return ;
55314       }
55315
55316     } CALL_CATCH_EXCEPTION();
55317   }
55318
55319 }
55320
55321
55322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
55323   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55324   int arg2 ;
55325   std::vector< Dali::Actor > *arg3 = 0 ;
55326
55327   arg1 = (std::vector< Dali::Actor > *)jarg1;
55328   arg2 = (int)jarg2;
55329   arg3 = (std::vector< Dali::Actor > *)jarg3;
55330   if (!arg3) {
55331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
55332     return ;
55333   }
55334   {
55335     try {
55336       try {
55337         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
55338       }
55339       catch(std::out_of_range &_e) {
55340         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55341         return ;
55342       }
55343
55344     } CALL_CATCH_EXCEPTION();
55345   }
55346
55347 }
55348
55349
55350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
55351   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55352
55353   arg1 = (std::vector< Dali::Actor > *)jarg1;
55354   {
55355     try {
55356       delete arg1;
55357     } CALL_CATCH_EXCEPTION();
55358   }
55359
55360 }
55361
55362
55363 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
55364   bool jresult ;
55365   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
55366   bool result;
55367
55368   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
55369   {
55370     try {
55371       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
55372     } CALL_CATCH_EXCEPTION(0);
55373   }
55374
55375   jresult = result;
55376   return jresult;
55377 }
55378
55379
55380 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
55381   unsigned long jresult ;
55382   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
55383   std::size_t result;
55384
55385   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
55386   {
55387     try {
55388       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
55389     } CALL_CATCH_EXCEPTION(0);
55390   }
55391
55392   jresult = (unsigned long)result;
55393   return jresult;
55394 }
55395
55396
55397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
55398   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
55399   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
55400
55401   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
55402   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
55403   {
55404     try {
55405       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
55406     } CALL_CATCH_EXCEPTION();
55407   }
55408
55409 }
55410
55411
55412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
55413   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
55414   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
55415
55416   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
55417   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
55418   {
55419     try {
55420       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
55421     } CALL_CATCH_EXCEPTION();
55422   }
55423
55424 }
55425
55426
55427 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
55428   bool jresult ;
55429   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
55430   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
55431   bool result;
55432
55433   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
55434   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
55435   if (!arg2) {
55436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
55437     return 0;
55438   }
55439   {
55440     try {
55441       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
55442     } CALL_CATCH_EXCEPTION(0);
55443   }
55444
55445   jresult = result;
55446   return jresult;
55447 }
55448
55449
55450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
55451   void * jresult ;
55452   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
55453
55454   {
55455     try {
55456       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
55457     } CALL_CATCH_EXCEPTION(0);
55458   }
55459
55460   jresult = (void *)result;
55461   return jresult;
55462 }
55463
55464
55465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
55466   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
55467
55468   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
55469   {
55470     try {
55471       delete arg1;
55472     } CALL_CATCH_EXCEPTION();
55473   }
55474
55475 }
55476
55477
55478 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
55479   bool jresult ;
55480   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
55481   bool result;
55482
55483   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
55484   {
55485     try {
55486       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);
55487     } CALL_CATCH_EXCEPTION(0);
55488   }
55489
55490   jresult = result;
55491   return jresult;
55492 }
55493
55494
55495 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
55496   unsigned long jresult ;
55497   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
55498   std::size_t result;
55499
55500   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
55501   {
55502     try {
55503       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);
55504     } CALL_CATCH_EXCEPTION(0);
55505   }
55506
55507   jresult = (unsigned long)result;
55508   return jresult;
55509 }
55510
55511
55512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
55513   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
55514   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
55515
55516   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
55517   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
55518   {
55519     try {
55520       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
55521     } CALL_CATCH_EXCEPTION();
55522   }
55523
55524 }
55525
55526
55527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
55528   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
55529   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
55530
55531   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
55532   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
55533   {
55534     try {
55535       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
55536     } CALL_CATCH_EXCEPTION();
55537   }
55538
55539 }
55540
55541
55542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
55543   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
55544   Dali::Actor arg2 ;
55545   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
55546   Dali::Actor *argp2 ;
55547
55548   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
55549   argp2 = (Dali::Actor *)jarg2;
55550   if (!argp2) {
55551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55552     return ;
55553   }
55554   arg2 = *argp2;
55555   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
55556   {
55557     try {
55558       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
55559     } CALL_CATCH_EXCEPTION();
55560   }
55561
55562 }
55563
55564
55565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
55566   void * jresult ;
55567   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
55568
55569   {
55570     try {
55571       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
55572     } CALL_CATCH_EXCEPTION(0);
55573   }
55574
55575   jresult = (void *)result;
55576   return jresult;
55577 }
55578
55579
55580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
55581   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
55582
55583   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
55584   {
55585     try {
55586       delete arg1;
55587     } CALL_CATCH_EXCEPTION();
55588   }
55589
55590 }
55591
55592
55593 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
55594   bool jresult ;
55595   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
55596   bool result;
55597
55598   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
55599   {
55600     try {
55601       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
55602     } CALL_CATCH_EXCEPTION(0);
55603   }
55604
55605   jresult = result;
55606   return jresult;
55607 }
55608
55609
55610 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
55611   unsigned long jresult ;
55612   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
55613   std::size_t result;
55614
55615   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
55616   {
55617     try {
55618       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
55619     } CALL_CATCH_EXCEPTION(0);
55620   }
55621
55622   jresult = (unsigned long)result;
55623   return jresult;
55624 }
55625
55626
55627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
55628   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
55629   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
55630
55631   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
55632   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
55633   {
55634     try {
55635       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
55636     } CALL_CATCH_EXCEPTION();
55637   }
55638
55639 }
55640
55641
55642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
55643   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
55644   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
55645
55646   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
55647   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
55648   {
55649     try {
55650       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
55651     } CALL_CATCH_EXCEPTION();
55652   }
55653
55654 }
55655
55656
55657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55658   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
55659   Dali::Actor arg2 ;
55660   Dali::Actor arg3 ;
55661   Dali::Actor *argp2 ;
55662   Dali::Actor *argp3 ;
55663
55664   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
55665   argp2 = (Dali::Actor *)jarg2;
55666   if (!argp2) {
55667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55668     return ;
55669   }
55670   arg2 = *argp2;
55671   argp3 = (Dali::Actor *)jarg3;
55672   if (!argp3) {
55673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55674     return ;
55675   }
55676   arg3 = *argp3;
55677   {
55678     try {
55679       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
55680     } CALL_CATCH_EXCEPTION();
55681   }
55682
55683 }
55684
55685
55686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
55687   void * jresult ;
55688   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
55689
55690   {
55691     try {
55692       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
55693     } CALL_CATCH_EXCEPTION(0);
55694   }
55695
55696   jresult = (void *)result;
55697   return jresult;
55698 }
55699
55700
55701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
55702   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
55703
55704   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
55705   {
55706     try {
55707       delete arg1;
55708     } CALL_CATCH_EXCEPTION();
55709   }
55710
55711 }
55712
55713
55714 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
55715   bool jresult ;
55716   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
55717   bool result;
55718
55719   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
55720   {
55721     try {
55722       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
55723     } CALL_CATCH_EXCEPTION(0);
55724   }
55725
55726   jresult = result;
55727   return jresult;
55728 }
55729
55730
55731 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
55732   unsigned long jresult ;
55733   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
55734   std::size_t result;
55735
55736   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
55737   {
55738     try {
55739       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
55740     } CALL_CATCH_EXCEPTION(0);
55741   }
55742
55743   jresult = (unsigned long)result;
55744   return jresult;
55745 }
55746
55747
55748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
55749   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
55750   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
55751
55752   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
55753   arg2 = (void (*)(Dali::Actor,bool))jarg2;
55754   {
55755     try {
55756       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
55757     } CALL_CATCH_EXCEPTION();
55758   }
55759
55760 }
55761
55762
55763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
55764   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
55765   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
55766
55767   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
55768   arg2 = (void (*)(Dali::Actor,bool))jarg2;
55769   {
55770     try {
55771       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
55772     } CALL_CATCH_EXCEPTION();
55773   }
55774
55775 }
55776
55777
55778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, bool jarg3) {
55779   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
55780   Dali::Actor arg2 ;
55781   bool arg3 ;
55782   Dali::Actor *argp2 ;
55783
55784   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
55785   argp2 = (Dali::Actor *)jarg2;
55786   if (!argp2) {
55787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55788     return ;
55789   }
55790   arg2 = *argp2;
55791   arg3 = jarg3 ? true : false;
55792   {
55793     try {
55794       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
55795     } CALL_CATCH_EXCEPTION();
55796   }
55797
55798 }
55799
55800
55801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
55802   void * jresult ;
55803   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
55804
55805   {
55806     try {
55807       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
55808     } CALL_CATCH_EXCEPTION(0);
55809   }
55810
55811   jresult = (void *)result;
55812   return jresult;
55813 }
55814
55815
55816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
55817   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
55818
55819   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
55820   {
55821     try {
55822       delete arg1;
55823     } CALL_CATCH_EXCEPTION();
55824   }
55825
55826 }
55827
55828
55829 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
55830   bool jresult ;
55831   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
55832   bool result;
55833
55834   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
55835   {
55836     try {
55837       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);
55838     } CALL_CATCH_EXCEPTION(0);
55839   }
55840
55841   jresult = result;
55842   return jresult;
55843 }
55844
55845
55846 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
55847   unsigned long jresult ;
55848   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
55849   std::size_t result;
55850
55851   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
55852   {
55853     try {
55854       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);
55855     } CALL_CATCH_EXCEPTION(0);
55856   }
55857
55858   jresult = (unsigned long)result;
55859   return jresult;
55860 }
55861
55862
55863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
55864   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
55865   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
55866
55867   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
55868   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
55869   {
55870     try {
55871       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
55872     } CALL_CATCH_EXCEPTION();
55873   }
55874
55875 }
55876
55877
55878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
55879   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
55880   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
55881
55882   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
55883   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
55884   {
55885     try {
55886       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
55887     } CALL_CATCH_EXCEPTION();
55888   }
55889
55890 }
55891
55892
55893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
55894   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
55895   Dali::Toolkit::StyleManager arg2 ;
55896   Dali::StyleChange::Type arg3 ;
55897   Dali::Toolkit::StyleManager *argp2 ;
55898
55899   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
55900   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
55901   if (!argp2) {
55902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
55903     return ;
55904   }
55905   arg2 = *argp2;
55906   arg3 = (Dali::StyleChange::Type)jarg3;
55907   {
55908     try {
55909       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
55910     } CALL_CATCH_EXCEPTION();
55911   }
55912
55913 }
55914
55915
55916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
55917   void * jresult ;
55918   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
55919
55920   {
55921     try {
55922       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
55923     } CALL_CATCH_EXCEPTION(0);
55924   }
55925
55926   jresult = (void *)result;
55927   return jresult;
55928 }
55929
55930
55931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
55932   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
55933
55934   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
55935   {
55936     try {
55937       delete arg1;
55938     } CALL_CATCH_EXCEPTION();
55939   }
55940
55941 }
55942
55943
55944 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
55945   bool jresult ;
55946   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
55947   bool result;
55948
55949   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
55950   {
55951     try {
55952       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
55953     } CALL_CATCH_EXCEPTION(0);
55954   }
55955
55956   jresult = result;
55957   return jresult;
55958 }
55959
55960
55961 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
55962   unsigned long jresult ;
55963   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
55964   std::size_t result;
55965
55966   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
55967   {
55968     try {
55969       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
55970     } CALL_CATCH_EXCEPTION(0);
55971   }
55972
55973   jresult = (unsigned long)result;
55974   return jresult;
55975 }
55976
55977
55978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
55979   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
55980   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
55981
55982   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
55983   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
55984   {
55985     try {
55986       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
55987     } CALL_CATCH_EXCEPTION();
55988   }
55989
55990 }
55991
55992
55993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
55994   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
55995   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
55996
55997   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
55998   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
55999   {
56000     try {
56001       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
56002     } CALL_CATCH_EXCEPTION();
56003   }
56004
56005 }
56006
56007
56008 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
56009   bool jresult ;
56010   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
56011   Dali::Toolkit::Button arg2 ;
56012   Dali::Toolkit::Button *argp2 ;
56013   bool result;
56014
56015   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
56016   argp2 = (Dali::Toolkit::Button *)jarg2;
56017   if (!argp2) {
56018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
56019     return 0;
56020   }
56021   arg2 = *argp2;
56022   {
56023     try {
56024       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
56025     } CALL_CATCH_EXCEPTION(0);
56026   }
56027
56028   jresult = result;
56029   return jresult;
56030 }
56031
56032
56033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
56034   void * jresult ;
56035   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
56036
56037   {
56038     try {
56039       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
56040     } CALL_CATCH_EXCEPTION(0);
56041   }
56042
56043   jresult = (void *)result;
56044   return jresult;
56045 }
56046
56047
56048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
56049   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
56050
56051   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
56052   {
56053     try {
56054       delete arg1;
56055     } CALL_CATCH_EXCEPTION();
56056   }
56057
56058 }
56059
56060
56061 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
56062   bool jresult ;
56063   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
56064   bool result;
56065
56066   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
56067   {
56068     try {
56069       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
56070     } CALL_CATCH_EXCEPTION(0);
56071   }
56072
56073   jresult = result;
56074   return jresult;
56075 }
56076
56077
56078 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
56079   unsigned long jresult ;
56080   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
56081   std::size_t result;
56082
56083   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
56084   {
56085     try {
56086       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
56087     } CALL_CATCH_EXCEPTION(0);
56088   }
56089
56090   jresult = (unsigned long)result;
56091   return jresult;
56092 }
56093
56094
56095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
56096   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
56097   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
56098
56099   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
56100   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
56101   {
56102     try {
56103       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
56104     } CALL_CATCH_EXCEPTION();
56105   }
56106
56107 }
56108
56109
56110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
56111   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
56112   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
56113
56114   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
56115   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
56116   {
56117     try {
56118       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
56119     } CALL_CATCH_EXCEPTION();
56120   }
56121
56122 }
56123
56124
56125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
56126   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
56127   Dali::Toolkit::GaussianBlurView arg2 ;
56128   Dali::Toolkit::GaussianBlurView *argp2 ;
56129
56130   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
56131   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
56132   if (!argp2) {
56133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
56134     return ;
56135   }
56136   arg2 = *argp2;
56137   {
56138     try {
56139       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
56140     } CALL_CATCH_EXCEPTION();
56141   }
56142
56143 }
56144
56145
56146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
56147   void * jresult ;
56148   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
56149
56150   {
56151     try {
56152       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
56153     } CALL_CATCH_EXCEPTION(0);
56154   }
56155
56156   jresult = (void *)result;
56157   return jresult;
56158 }
56159
56160
56161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
56162   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
56163
56164   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
56165   {
56166     try {
56167       delete arg1;
56168     } CALL_CATCH_EXCEPTION();
56169   }
56170
56171 }
56172
56173
56174 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
56175   bool jresult ;
56176   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
56177   bool result;
56178
56179   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
56180   {
56181     try {
56182       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);
56183     } CALL_CATCH_EXCEPTION(0);
56184   }
56185
56186   jresult = result;
56187   return jresult;
56188 }
56189
56190
56191 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
56192   unsigned long jresult ;
56193   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
56194   std::size_t result;
56195
56196   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
56197   {
56198     try {
56199       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);
56200     } CALL_CATCH_EXCEPTION(0);
56201   }
56202
56203   jresult = (unsigned long)result;
56204   return jresult;
56205 }
56206
56207
56208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
56209   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
56210   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
56211
56212   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
56213   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
56214   {
56215     try {
56216       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
56217     } CALL_CATCH_EXCEPTION();
56218   }
56219
56220 }
56221
56222
56223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
56224   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
56225   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
56226
56227   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
56228   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
56229   {
56230     try {
56231       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
56232     } CALL_CATCH_EXCEPTION();
56233   }
56234
56235 }
56236
56237
56238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, bool jarg4) {
56239   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
56240   Dali::Toolkit::PageTurnView arg2 ;
56241   unsigned int arg3 ;
56242   bool arg4 ;
56243   Dali::Toolkit::PageTurnView *argp2 ;
56244
56245   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
56246   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
56247   if (!argp2) {
56248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
56249     return ;
56250   }
56251   arg2 = *argp2;
56252   arg3 = (unsigned int)jarg3;
56253   arg4 = jarg4 ? true : false;
56254   {
56255     try {
56256       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
56257     } CALL_CATCH_EXCEPTION();
56258   }
56259
56260 }
56261
56262
56263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
56264   void * jresult ;
56265   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
56266
56267   {
56268     try {
56269       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
56270     } CALL_CATCH_EXCEPTION(0);
56271   }
56272
56273   jresult = (void *)result;
56274   return jresult;
56275 }
56276
56277
56278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
56279   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
56280
56281   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
56282   {
56283     try {
56284       delete arg1;
56285     } CALL_CATCH_EXCEPTION();
56286   }
56287
56288 }
56289
56290
56291 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
56292   bool jresult ;
56293   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
56294   bool result;
56295
56296   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
56297   {
56298     try {
56299       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
56300     } CALL_CATCH_EXCEPTION(0);
56301   }
56302
56303   jresult = result;
56304   return jresult;
56305 }
56306
56307
56308 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
56309   unsigned long jresult ;
56310   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
56311   std::size_t result;
56312
56313   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
56314   {
56315     try {
56316       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
56317     } CALL_CATCH_EXCEPTION(0);
56318   }
56319
56320   jresult = (unsigned long)result;
56321   return jresult;
56322 }
56323
56324
56325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
56326   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
56327   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
56328
56329   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
56330   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
56331   {
56332     try {
56333       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
56334     } CALL_CATCH_EXCEPTION();
56335   }
56336 }
56337
56338
56339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
56340   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
56341   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
56342
56343   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
56344   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
56345   {
56346     try {
56347       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
56348     } CALL_CATCH_EXCEPTION();
56349   }
56350 }
56351
56352
56353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
56354   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
56355   Dali::Toolkit::PageTurnView arg2 ;
56356   Dali::Toolkit::PageTurnView *argp2 ;
56357
56358   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
56359   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
56360   if (!argp2) {
56361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
56362     return ;
56363   }
56364   arg2 = *argp2;
56365   {
56366     try {
56367       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
56368     } CALL_CATCH_EXCEPTION();
56369   }
56370 }
56371
56372
56373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
56374   void * jresult ;
56375   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
56376
56377   {
56378     try {
56379       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
56380     } CALL_CATCH_EXCEPTION(0);
56381   }
56382
56383   jresult = (void *)result;
56384   return jresult;
56385 }
56386
56387
56388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
56389   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
56390
56391   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
56392   {
56393     try {
56394       delete arg1;
56395     } CALL_CATCH_EXCEPTION();
56396   }
56397
56398 }
56399
56400
56401 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
56402   bool jresult ;
56403   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
56404   bool result;
56405
56406   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
56407   {
56408     try {
56409       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);
56410     } CALL_CATCH_EXCEPTION(0);
56411   }
56412
56413   jresult = result;
56414   return jresult;
56415 }
56416
56417
56418 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
56419   unsigned long jresult ;
56420   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
56421   std::size_t result;
56422
56423   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
56424   {
56425     try {
56426       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);
56427     } CALL_CATCH_EXCEPTION(0);
56428   }
56429
56430   jresult = (unsigned long)result;
56431   return jresult;
56432 }
56433
56434
56435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
56436   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
56437   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
56438
56439   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
56440   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
56441   {
56442     try {
56443       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
56444     } CALL_CATCH_EXCEPTION();
56445   }
56446
56447 }
56448
56449
56450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
56451   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
56452   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
56453
56454   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
56455   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
56456   {
56457     try {
56458       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
56459     } CALL_CATCH_EXCEPTION();
56460   }
56461
56462 }
56463
56464
56465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
56466   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
56467   Dali::Toolkit::ProgressBar arg2 ;
56468   float arg3 ;
56469   float arg4 ;
56470   Dali::Toolkit::ProgressBar *argp2 ;
56471
56472   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
56473   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
56474   if (!argp2) {
56475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
56476     return ;
56477   }
56478   arg2 = *argp2;
56479   arg3 = (float)jarg3;
56480   arg4 = (float)jarg4;
56481   {
56482     try {
56483       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
56484     } CALL_CATCH_EXCEPTION();
56485   }
56486
56487 }
56488
56489
56490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
56491   void * jresult ;
56492   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
56493
56494   {
56495     try {
56496       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
56497     } CALL_CATCH_EXCEPTION(0);
56498   }
56499
56500   jresult = (void *)result;
56501   return jresult;
56502 }
56503
56504
56505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
56506   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
56507
56508   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
56509   {
56510     try {
56511       delete arg1;
56512     } CALL_CATCH_EXCEPTION();
56513   }
56514
56515 }
56516
56517
56518 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
56519   bool jresult ;
56520   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
56521   bool result;
56522
56523   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
56524   {
56525     try {
56526       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);
56527     } CALL_CATCH_EXCEPTION(0);
56528   }
56529
56530   jresult = result;
56531   return jresult;
56532 }
56533
56534
56535 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
56536   unsigned long jresult ;
56537   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
56538   std::size_t result;
56539
56540   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
56541   {
56542     try {
56543       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);
56544     } CALL_CATCH_EXCEPTION(0);
56545   }
56546
56547   jresult = (unsigned long)result;
56548   return jresult;
56549 }
56550
56551
56552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
56553   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
56554   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
56555
56556   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
56557   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
56558   {
56559     try {
56560       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56561     } CALL_CATCH_EXCEPTION();
56562   }
56563
56564 }
56565
56566
56567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
56568   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
56569   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
56570
56571   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
56572   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
56573   {
56574     try {
56575       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56576     } CALL_CATCH_EXCEPTION();
56577   }
56578
56579 }
56580
56581
56582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
56583   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
56584   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
56585
56586   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
56587   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
56588   if (!arg2) {
56589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
56590     return ;
56591   }
56592   {
56593     try {
56594       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
56595     } CALL_CATCH_EXCEPTION();
56596   }
56597
56598 }
56599
56600
56601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
56602   void * jresult ;
56603   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
56604
56605   {
56606     try {
56607       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
56608     } CALL_CATCH_EXCEPTION(0);
56609   }
56610
56611   jresult = (void *)result;
56612   return jresult;
56613 }
56614
56615
56616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
56617   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
56618
56619   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
56620   {
56621     try {
56622       delete arg1;
56623     } CALL_CATCH_EXCEPTION();
56624   }
56625
56626 }
56627
56628
56629 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
56630   bool jresult ;
56631   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
56632   bool result;
56633
56634   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
56635   {
56636     try {
56637       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
56638     } CALL_CATCH_EXCEPTION(0);
56639   }
56640
56641   jresult = result;
56642   return jresult;
56643 }
56644
56645
56646 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
56647   unsigned long jresult ;
56648   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
56649   std::size_t result;
56650
56651   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
56652   {
56653     try {
56654       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
56655     } CALL_CATCH_EXCEPTION(0);
56656   }
56657
56658   jresult = (unsigned long)result;
56659   return jresult;
56660 }
56661
56662
56663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
56664   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
56665   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
56666
56667   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
56668   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
56669   {
56670     try {
56671       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56672     } CALL_CATCH_EXCEPTION();
56673   }
56674
56675 }
56676
56677
56678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
56679   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
56680   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
56681
56682   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
56683   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
56684   {
56685     try {
56686       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56687     } CALL_CATCH_EXCEPTION();
56688   }
56689
56690 }
56691
56692
56693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
56694   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
56695   Dali::Vector2 *arg2 = 0 ;
56696
56697   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
56698   arg2 = (Dali::Vector2 *)jarg2;
56699   if (!arg2) {
56700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
56701     return ;
56702   }
56703   {
56704     try {
56705       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
56706     } CALL_CATCH_EXCEPTION();
56707   }
56708
56709 }
56710
56711
56712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
56713   void * jresult ;
56714   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
56715
56716   {
56717     try {
56718       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
56719     } CALL_CATCH_EXCEPTION(0);
56720   }
56721
56722   jresult = (void *)result;
56723   return jresult;
56724 }
56725
56726
56727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
56728   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
56729
56730   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
56731   {
56732     try {
56733       delete arg1;
56734     } CALL_CATCH_EXCEPTION();
56735   }
56736
56737 }
56738
56739
56740
56741 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
56742   bool jresult ;
56743   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
56744   bool result;
56745
56746   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
56747   {
56748     try {
56749       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);
56750     } CALL_CATCH_EXCEPTION(0);
56751   }
56752
56753   jresult = result;
56754   return jresult;
56755 }
56756
56757
56758 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
56759   unsigned long jresult ;
56760   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
56761   std::size_t result;
56762
56763   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
56764   {
56765     try {
56766       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);
56767     } CALL_CATCH_EXCEPTION(0);
56768   }
56769
56770   jresult = (unsigned long)result;
56771   return jresult;
56772 }
56773
56774
56775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
56776   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
56777   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
56778
56779   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
56780   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
56781   {
56782     try {
56783       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56784     } CALL_CATCH_EXCEPTION();
56785   }
56786
56787 }
56788
56789
56790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
56791   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
56792   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
56793
56794   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
56795   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
56796   {
56797     try {
56798       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56799     } CALL_CATCH_EXCEPTION();
56800   }
56801
56802 }
56803
56804
56805 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
56806   bool jresult ;
56807   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
56808   Dali::Toolkit::Control arg2 ;
56809   Dali::KeyEvent *arg3 = 0 ;
56810   Dali::Toolkit::Control *argp2 ;
56811   bool result;
56812
56813   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
56814   argp2 = (Dali::Toolkit::Control *)jarg2;
56815   if (!argp2) {
56816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
56817     return 0;
56818   }
56819   arg2 = *argp2;
56820   arg3 = (Dali::KeyEvent *)jarg3;
56821   if (!arg3) {
56822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56823     return 0;
56824   }
56825   {
56826     try {
56827       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);
56828     } CALL_CATCH_EXCEPTION(0);
56829   }
56830
56831   jresult = result;
56832   return jresult;
56833 }
56834
56835
56836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
56837   void * jresult ;
56838   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
56839
56840   {
56841     try {
56842       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
56843     } CALL_CATCH_EXCEPTION(0);
56844   }
56845
56846   jresult = (void *)result;
56847   return jresult;
56848 }
56849
56850
56851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
56852   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
56853
56854   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
56855   {
56856     try {
56857       delete arg1;
56858     } CALL_CATCH_EXCEPTION();
56859   }
56860
56861 }
56862
56863
56864 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
56865   bool jresult ;
56866   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56867   bool result;
56868
56869   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56870   {
56871     try {
56872       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
56873     } CALL_CATCH_EXCEPTION(0);
56874   }
56875
56876   jresult = result;
56877   return jresult;
56878 }
56879
56880
56881 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
56882   unsigned long jresult ;
56883   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56884   std::size_t result;
56885
56886   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56887   {
56888     try {
56889       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
56890     } CALL_CATCH_EXCEPTION(0);
56891   }
56892
56893   jresult = (unsigned long)result;
56894   return jresult;
56895 }
56896
56897
56898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
56899   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56900   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
56901
56902   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56903   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
56904   {
56905     try {
56906       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
56907     } CALL_CATCH_EXCEPTION();
56908   }
56909
56910 }
56911
56912
56913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
56914   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56915   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
56916
56917   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56918   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
56919   {
56920     try {
56921       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
56922     } CALL_CATCH_EXCEPTION();
56923   }
56924
56925 }
56926
56927
56928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
56929   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56930   Dali::Toolkit::Control arg2 ;
56931   Dali::Toolkit::Control *argp2 ;
56932
56933   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56934   argp2 = (Dali::Toolkit::Control *)jarg2;
56935   if (!argp2) {
56936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
56937     return ;
56938   }
56939   arg2 = *argp2;
56940   {
56941     try {
56942       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
56943     } CALL_CATCH_EXCEPTION();
56944   }
56945
56946 }
56947
56948
56949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
56950   void * jresult ;
56951   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
56952
56953   {
56954     try {
56955       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
56956     } CALL_CATCH_EXCEPTION(0);
56957   }
56958
56959   jresult = (void *)result;
56960   return jresult;
56961 }
56962
56963
56964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
56965   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56966
56967   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56968   {
56969     try {
56970       delete arg1;
56971     } CALL_CATCH_EXCEPTION();
56972   }
56973
56974 }
56975
56976
56977 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
56978   bool jresult ;
56979   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
56980   bool result;
56981
56982   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
56983   {
56984     try {
56985       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
56986     } CALL_CATCH_EXCEPTION(0);
56987   }
56988
56989   jresult = result;
56990   return jresult;
56991 }
56992
56993
56994 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
56995   unsigned long jresult ;
56996   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
56997   std::size_t result;
56998
56999   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
57000   {
57001     try {
57002       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
57003     } CALL_CATCH_EXCEPTION(0);
57004   }
57005
57006   jresult = (unsigned long)result;
57007   return jresult;
57008 }
57009
57010
57011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
57012   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
57013   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
57014
57015   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
57016   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
57017   {
57018     try {
57019       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
57020     } CALL_CATCH_EXCEPTION();
57021   }
57022
57023 }
57024
57025
57026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
57027   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
57028   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
57029
57030   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
57031   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
57032   {
57033     try {
57034       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
57035     } CALL_CATCH_EXCEPTION();
57036   }
57037
57038 }
57039
57040
57041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
57042   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
57043   Dali::Toolkit::VideoView *arg2 = 0 ;
57044
57045   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
57046   arg2 = (Dali::Toolkit::VideoView *)jarg2;
57047   if (!arg2) {
57048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
57049     return ;
57050   }
57051   {
57052     try {
57053       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
57054     } CALL_CATCH_EXCEPTION();
57055   }
57056
57057 }
57058
57059
57060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
57061   void * jresult ;
57062   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
57063
57064   {
57065     try {
57066       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
57067     } CALL_CATCH_EXCEPTION(0);
57068   }
57069
57070   jresult = (void *)result;
57071   return jresult;
57072 }
57073
57074
57075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
57076   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
57077
57078   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
57079   {
57080     try {
57081       delete arg1;
57082     } CALL_CATCH_EXCEPTION();
57083   }
57084
57085 }
57086
57087
57088 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
57089   bool jresult ;
57090   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
57091   bool result;
57092
57093   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
57094   {
57095     try {
57096       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
57097     } CALL_CATCH_EXCEPTION(0);
57098   }
57099
57100   jresult = result;
57101   return jresult;
57102 }
57103
57104
57105 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
57106   unsigned long jresult ;
57107   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
57108   std::size_t result;
57109
57110   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
57111   {
57112     try {
57113       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
57114     } CALL_CATCH_EXCEPTION(0);
57115   }
57116
57117   jresult = (unsigned long)result;
57118   return jresult;
57119 }
57120
57121
57122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
57123   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
57124   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
57125
57126   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
57127   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
57128   {
57129     try {
57130       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
57131     } CALL_CATCH_EXCEPTION();
57132   }
57133
57134 }
57135
57136
57137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
57138   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
57139   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
57140
57141   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
57142   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
57143   {
57144     try {
57145       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
57146     } CALL_CATCH_EXCEPTION();
57147   }
57148
57149 }
57150
57151
57152 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
57153   bool jresult ;
57154   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
57155   Dali::Toolkit::Slider arg2 ;
57156   float arg3 ;
57157   Dali::Toolkit::Slider *argp2 ;
57158   bool result;
57159
57160   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
57161   argp2 = (Dali::Toolkit::Slider *)jarg2;
57162   if (!argp2) {
57163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
57164     return 0;
57165   }
57166   arg2 = *argp2;
57167   arg3 = (float)jarg3;
57168   {
57169     try {
57170       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
57171     } CALL_CATCH_EXCEPTION(0);
57172   }
57173
57174   jresult = result;
57175   return jresult;
57176 }
57177
57178
57179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
57180   void * jresult ;
57181   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
57182
57183   {
57184     try {
57185       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
57186     } CALL_CATCH_EXCEPTION(0);
57187   }
57188
57189   jresult = (void *)result;
57190   return jresult;
57191 }
57192
57193
57194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
57195   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
57196
57197   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
57198   {
57199     try {
57200       delete arg1;
57201     } CALL_CATCH_EXCEPTION();
57202   }
57203
57204 }
57205
57206
57207 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
57208   bool jresult ;
57209   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
57210   bool result;
57211
57212   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
57213   {
57214     try {
57215       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
57216     } CALL_CATCH_EXCEPTION(0);
57217   }
57218
57219   jresult = result;
57220   return jresult;
57221 }
57222
57223
57224 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
57225   unsigned long jresult ;
57226   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
57227   std::size_t result;
57228
57229   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
57230   {
57231     try {
57232       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
57233     } CALL_CATCH_EXCEPTION(0);
57234   }
57235
57236   jresult = (unsigned long)result;
57237   return jresult;
57238 }
57239
57240
57241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
57242   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
57243   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
57244
57245   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
57246   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
57247   {
57248     try {
57249       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
57250     } CALL_CATCH_EXCEPTION();
57251   }
57252
57253 }
57254
57255
57256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
57257   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
57258   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
57259
57260   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
57261   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
57262   {
57263     try {
57264       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
57265     } CALL_CATCH_EXCEPTION();
57266   }
57267
57268 }
57269
57270
57271 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
57272   bool jresult ;
57273   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
57274   Dali::Toolkit::Slider arg2 ;
57275   int arg3 ;
57276   Dali::Toolkit::Slider *argp2 ;
57277   bool result;
57278
57279   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
57280   argp2 = (Dali::Toolkit::Slider *)jarg2;
57281   if (!argp2) {
57282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
57283     return 0;
57284   }
57285   arg2 = *argp2;
57286   arg3 = (int)jarg3;
57287   {
57288     try {
57289       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
57290     } CALL_CATCH_EXCEPTION(0);
57291   }
57292
57293   jresult = result;
57294   return jresult;
57295 }
57296
57297
57298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
57299   void * jresult ;
57300   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
57301
57302   {
57303     try {
57304       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
57305     } CALL_CATCH_EXCEPTION(0);
57306   }
57307
57308   jresult = (void *)result;
57309   return jresult;
57310 }
57311
57312
57313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
57314   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
57315
57316   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
57317   {
57318     try {
57319       delete arg1;
57320     } CALL_CATCH_EXCEPTION();
57321   }
57322
57323 }
57324
57325
57326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
57327   void * jresult ;
57328   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
57329
57330   {
57331     try {
57332       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
57333     } CALL_CATCH_EXCEPTION(0);
57334   }
57335
57336   jresult = (void *)result;
57337   return jresult;
57338 }
57339
57340
57341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
57342   void * jresult ;
57343   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
57344   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
57345
57346   arg1 = (Dali::Toolkit::Ruler *)jarg1;
57347   {
57348     try {
57349       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
57350     } CALL_CATCH_EXCEPTION(0);
57351   }
57352
57353   jresult = (void *)result;
57354   return jresult;
57355 }
57356
57357
57358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
57359   void * jresult ;
57360   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
57361   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
57362
57363   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57364   if (!arg1) {
57365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
57366     return 0;
57367   }
57368   {
57369     try {
57370       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
57371     } CALL_CATCH_EXCEPTION(0);
57372   }
57373
57374   jresult = (void *)result;
57375   return jresult;
57376 }
57377
57378
57379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
57380   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57381
57382   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57383   {
57384     try {
57385       delete arg1;
57386     } CALL_CATCH_EXCEPTION();
57387   }
57388
57389 }
57390
57391
57392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
57393   void * jresult ;
57394   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57395   Dali::Toolkit::Ruler *result = 0 ;
57396
57397   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57398   {
57399     try {
57400       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
57401     } CALL_CATCH_EXCEPTION(0);
57402   }
57403
57404   jresult = (void *)result;
57405   return jresult;
57406 }
57407
57408
57409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
57410   void * jresult ;
57411   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57412   Dali::Toolkit::Ruler *result = 0 ;
57413
57414   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57415   {
57416     try {
57417       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
57418     } CALL_CATCH_EXCEPTION(0);
57419   }
57420
57421   jresult = (void *)result;
57422   return jresult;
57423 }
57424
57425
57426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
57427   void * jresult ;
57428   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57429   Dali::Toolkit::Ruler *result = 0 ;
57430
57431   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57432   {
57433     try {
57434       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
57435     } CALL_CATCH_EXCEPTION(0);
57436   }
57437
57438   jresult = (void *)result;
57439   return jresult;
57440 }
57441
57442
57443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
57444   void * jresult ;
57445   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57446   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
57447   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
57448
57449   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57450   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
57451   if (!arg2) {
57452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
57453     return 0;
57454   }
57455   {
57456     try {
57457       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
57458     } CALL_CATCH_EXCEPTION(0);
57459   }
57460
57461   jresult = (void *)result;
57462   return jresult;
57463 }
57464
57465
57466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
57467   void * jresult ;
57468   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57469   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
57470   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
57471
57472   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57473   arg2 = (Dali::Toolkit::Ruler *)jarg2;
57474   {
57475     try {
57476       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
57477     } CALL_CATCH_EXCEPTION(0);
57478   }
57479
57480   jresult = (void *)result;
57481   return jresult;
57482 }
57483
57484
57485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
57486   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57487
57488   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57489   {
57490     try {
57491       (arg1)->Reset();
57492     } CALL_CATCH_EXCEPTION();
57493   }
57494
57495 }
57496
57497
57498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
57499   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57500   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
57501
57502   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57503   arg2 = (Dali::Toolkit::Ruler *)jarg2;
57504   {
57505     try {
57506       (arg1)->Reset(arg2);
57507     } CALL_CATCH_EXCEPTION();
57508   }
57509
57510 }
57511
57512
57513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
57514   void * jresult ;
57515   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57516   Dali::Toolkit::Ruler *result = 0 ;
57517
57518   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57519   {
57520     try {
57521       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
57522     } CALL_CATCH_EXCEPTION(0);
57523   }
57524
57525   jresult = (void *)result;
57526   return jresult;
57527 }
57528
57529
57530 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
57531   float jresult ;
57532   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57533   float arg2 ;
57534   float arg3 ;
57535   float result;
57536
57537   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57538   arg2 = (float)jarg2;
57539   arg3 = (float)jarg3;
57540   {
57541     try {
57542       result = (float)(*arg1)->Snap(arg2,arg3);
57543     } CALL_CATCH_EXCEPTION(0);
57544   }
57545
57546   jresult = result;
57547   return jresult;
57548 }
57549
57550
57551 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
57552   float jresult ;
57553   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57554   float arg2 ;
57555   float result;
57556
57557   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57558   arg2 = (float)jarg2;
57559   {
57560     try {
57561       result = (float)(*arg1)->Snap(arg2);
57562     } CALL_CATCH_EXCEPTION(0);
57563   }
57564
57565   jresult = result;
57566   return jresult;
57567 }
57568
57569
57570 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) {
57571   float jresult ;
57572   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57573   unsigned int arg2 ;
57574   unsigned int *arg3 = 0 ;
57575   bool arg4 ;
57576   float result;
57577
57578   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57579   arg2 = (unsigned int)jarg2;
57580   arg3 = (unsigned int *)jarg3;
57581   arg4 = jarg4 ? true : false;
57582   {
57583     try {
57584       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
57585     } CALL_CATCH_EXCEPTION(0);
57586   }
57587
57588   jresult = result;
57589   return jresult;
57590 }
57591
57592
57593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) {
57594   unsigned int jresult ;
57595   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57596   float arg2 ;
57597   bool arg3 ;
57598   unsigned int result;
57599
57600   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57601   arg2 = (float)jarg2;
57602   arg3 = jarg3 ? true : false;
57603   {
57604     try {
57605       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
57606     } CALL_CATCH_EXCEPTION(0);
57607   }
57608
57609   jresult = result;
57610   return jresult;
57611 }
57612
57613
57614 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
57615   unsigned int jresult ;
57616   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57617   unsigned int result;
57618
57619   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57620   {
57621     try {
57622       result = (unsigned int)(*arg1)->GetTotalPages();
57623     } CALL_CATCH_EXCEPTION(0);
57624   }
57625
57626   jresult = result;
57627   return jresult;
57628 }
57629
57630
57631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
57632   int jresult ;
57633   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57634   Dali::Toolkit::Ruler::RulerType result;
57635
57636   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57637   {
57638     try {
57639       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
57640     } CALL_CATCH_EXCEPTION(0);
57641   }
57642
57643   jresult = (int)result;
57644   return jresult;
57645 }
57646
57647
57648 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
57649   bool jresult ;
57650   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57651   bool result;
57652
57653   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57654   {
57655     try {
57656       result = (bool)(*arg1)->IsEnabled();
57657     } CALL_CATCH_EXCEPTION(0);
57658   }
57659
57660   jresult = result;
57661   return jresult;
57662 }
57663
57664
57665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
57666   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57667
57668   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57669   {
57670     try {
57671       (*arg1)->Enable();
57672     } CALL_CATCH_EXCEPTION();
57673   }
57674
57675 }
57676
57677
57678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
57679   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57680
57681   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57682   {
57683     try {
57684       (*arg1)->Disable();
57685     } CALL_CATCH_EXCEPTION();
57686   }
57687
57688 }
57689
57690
57691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
57692   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57693   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
57694   Dali::Toolkit::RulerDomain *argp2 ;
57695
57696   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57697   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
57698   if (!argp2) {
57699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
57700     return ;
57701   }
57702   arg2 = *argp2;
57703   {
57704     try {
57705       (*arg1)->SetDomain(arg2);
57706     } CALL_CATCH_EXCEPTION();
57707   }
57708
57709 }
57710
57711
57712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
57713   void * jresult ;
57714   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57715   Dali::Toolkit::RulerDomain *result = 0 ;
57716
57717   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57718   {
57719     try {
57720       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
57721     } CALL_CATCH_EXCEPTION(0);
57722   }
57723
57724   jresult = (void *)result;
57725   return jresult;
57726 }
57727
57728
57729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
57730   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57731
57732   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57733   {
57734     try {
57735       (*arg1)->DisableDomain();
57736     } CALL_CATCH_EXCEPTION();
57737   }
57738
57739 }
57740
57741
57742 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
57743   float jresult ;
57744   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57745   float arg2 ;
57746   float arg3 ;
57747   float arg4 ;
57748   float result;
57749
57750   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57751   arg2 = (float)jarg2;
57752   arg3 = (float)jarg3;
57753   arg4 = (float)jarg4;
57754   {
57755     try {
57756       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
57757     } CALL_CATCH_EXCEPTION(0);
57758   }
57759
57760   jresult = result;
57761   return jresult;
57762 }
57763
57764
57765 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
57766   float jresult ;
57767   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57768   float arg2 ;
57769   float arg3 ;
57770   float result;
57771
57772   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57773   arg2 = (float)jarg2;
57774   arg3 = (float)jarg3;
57775   {
57776     try {
57777       result = (float)(*arg1)->Clamp(arg2,arg3);
57778     } CALL_CATCH_EXCEPTION(0);
57779   }
57780
57781   jresult = result;
57782   return jresult;
57783 }
57784
57785
57786 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
57787   float jresult ;
57788   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57789   float arg2 ;
57790   float result;
57791
57792   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57793   arg2 = (float)jarg2;
57794   {
57795     try {
57796       result = (float)(*arg1)->Clamp(arg2);
57797     } CALL_CATCH_EXCEPTION(0);
57798   }
57799
57800   jresult = result;
57801   return jresult;
57802 }
57803
57804
57805 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
57806   float jresult ;
57807   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57808   float arg2 ;
57809   float arg3 ;
57810   float arg4 ;
57811   Dali::Toolkit::ClampState *arg5 = 0 ;
57812   float result;
57813
57814   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57815   arg2 = (float)jarg2;
57816   arg3 = (float)jarg3;
57817   arg4 = (float)jarg4;
57818   arg5 = (Dali::Toolkit::ClampState *)jarg5;
57819   if (!arg5) {
57820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
57821     return 0;
57822   }
57823   {
57824     try {
57825       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
57826     } CALL_CATCH_EXCEPTION(0);
57827   }
57828
57829   jresult = result;
57830   return jresult;
57831 }
57832
57833
57834 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
57835   float jresult ;
57836   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57837   float arg2 ;
57838   float arg3 ;
57839   float arg4 ;
57840   float arg5 ;
57841   float result;
57842
57843   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57844   arg2 = (float)jarg2;
57845   arg3 = (float)jarg3;
57846   arg4 = (float)jarg4;
57847   arg5 = (float)jarg5;
57848   {
57849     try {
57850       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
57851     } CALL_CATCH_EXCEPTION(0);
57852   }
57853
57854   jresult = result;
57855   return jresult;
57856 }
57857
57858
57859 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
57860   float jresult ;
57861   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57862   float arg2 ;
57863   float arg3 ;
57864   float arg4 ;
57865   float result;
57866
57867   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57868   arg2 = (float)jarg2;
57869   arg3 = (float)jarg3;
57870   arg4 = (float)jarg4;
57871   {
57872     try {
57873       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
57874     } CALL_CATCH_EXCEPTION(0);
57875   }
57876
57877   jresult = result;
57878   return jresult;
57879 }
57880
57881
57882 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
57883   float jresult ;
57884   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57885   float arg2 ;
57886   float arg3 ;
57887   float result;
57888
57889   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57890   arg2 = (float)jarg2;
57891   arg3 = (float)jarg3;
57892   {
57893     try {
57894       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
57895     } CALL_CATCH_EXCEPTION(0);
57896   }
57897
57898   jresult = result;
57899   return jresult;
57900 }
57901
57902
57903 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
57904   float jresult ;
57905   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57906   float arg2 ;
57907   float result;
57908
57909   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57910   arg2 = (float)jarg2;
57911   {
57912     try {
57913       result = (float)(*arg1)->SnapAndClamp(arg2);
57914     } CALL_CATCH_EXCEPTION(0);
57915   }
57916
57917   jresult = result;
57918   return jresult;
57919 }
57920
57921
57922 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
57923   float jresult ;
57924   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57925   float arg2 ;
57926   float arg3 ;
57927   float arg4 ;
57928   float arg5 ;
57929   Dali::Toolkit::ClampState *arg6 = 0 ;
57930   float result;
57931
57932   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57933   arg2 = (float)jarg2;
57934   arg3 = (float)jarg3;
57935   arg4 = (float)jarg4;
57936   arg5 = (float)jarg5;
57937   arg6 = (Dali::Toolkit::ClampState *)jarg6;
57938   if (!arg6) {
57939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
57940     return 0;
57941   }
57942   {
57943     try {
57944       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
57945     } CALL_CATCH_EXCEPTION(0);
57946   }
57947
57948   jresult = result;
57949   return jresult;
57950 }
57951
57952
57953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
57954   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57955
57956   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57957   {
57958     try {
57959       (*arg1)->Reference();
57960     } CALL_CATCH_EXCEPTION();
57961   }
57962
57963 }
57964
57965
57966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
57967   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57968
57969   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57970   {
57971     try {
57972       (*arg1)->Unreference();
57973     } CALL_CATCH_EXCEPTION();
57974   }
57975
57976 }
57977
57978
57979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
57980   int jresult ;
57981   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57982   int result;
57983
57984   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57985   {
57986     try {
57987       result = (int)(*arg1)->ReferenceCount();
57988     } CALL_CATCH_EXCEPTION(0);
57989   }
57990
57991   jresult = result;
57992   return jresult;
57993 }
57994
57995
57996 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
57997   bool jresult ;
57998   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
57999   bool result;
58000
58001   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
58002   {
58003     try {
58004       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
58005     } CALL_CATCH_EXCEPTION(0);
58006   }
58007
58008   jresult = result;
58009   return jresult;
58010 }
58011
58012
58013 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
58014   unsigned long jresult ;
58015   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
58016   std::size_t result;
58017
58018   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
58019   {
58020     try {
58021       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
58022     } CALL_CATCH_EXCEPTION(0);
58023   }
58024
58025   jresult = (unsigned long)result;
58026   return jresult;
58027 }
58028
58029
58030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
58031   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
58032   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
58033
58034   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
58035   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
58036   {
58037     try {
58038       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
58039     } CALL_CATCH_EXCEPTION();
58040   }
58041
58042 }
58043
58044
58045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
58046   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
58047   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
58048
58049   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
58050   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
58051   {
58052     try {
58053       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
58054     } CALL_CATCH_EXCEPTION();
58055   }
58056
58057 }
58058
58059
58060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
58061   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
58062   Dali::Toolkit::Control arg2 ;
58063   Dali::Toolkit::Control *argp2 ;
58064
58065   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
58066   argp2 = (Dali::Toolkit::Control *)jarg2;
58067   if (!argp2) {
58068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
58069     return ;
58070   }
58071   arg2 = *argp2;
58072   {
58073     try {
58074       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
58075     } CALL_CATCH_EXCEPTION();
58076   }
58077
58078 }
58079
58080
58081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
58082   void * jresult ;
58083   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
58084
58085   {
58086     try {
58087       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
58088     } CALL_CATCH_EXCEPTION(0);
58089   }
58090
58091   jresult = (void *)result;
58092   return jresult;
58093 }
58094
58095
58096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
58097   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
58098
58099   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
58100   {
58101     try {
58102       delete arg1;
58103     } CALL_CATCH_EXCEPTION();
58104   }
58105
58106 }
58107
58108 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
58109   Dali::RefObject *result = NULL;
58110
58111   if (arg1)
58112   {
58113     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
58114   }
58115   return result;
58116 }
58117
58118 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
58119     return (Dali::RefObject *)jarg1;
58120 }
58121
58122 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
58123     return (Dali::SignalObserver *)jarg1;
58124 }
58125
58126 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
58127     return (Dali::ConnectionTrackerInterface *)jarg1;
58128 }
58129
58130 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
58131     return (Dali::BaseHandle *)jarg1;
58132 }
58133
58134 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
58135     return (Dali::BaseHandle *)jarg1;
58136 }
58137
58138 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
58139     return (Dali::BaseHandle *)jarg1;
58140 }
58141
58142 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
58143     return (Dali::BaseHandle *)jarg1;
58144 }
58145
58146 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
58147     return (Dali::BaseHandle *)jarg1;
58148 }
58149
58150 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
58151     return (Dali::BaseHandle *)jarg1;
58152 }
58153
58154 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
58155     return (Dali::BaseHandle *)jarg1;
58156 }
58157
58158 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
58159     return (Dali::BaseHandle *)jarg1;
58160 }
58161
58162 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
58163     return (Dali::BaseHandle *)jarg1;
58164 }
58165
58166 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
58167     return (Dali::BaseHandle *)jarg1;
58168 }
58169
58170 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VertexBuffer_SWIGUpcast(Dali::VertexBuffer *jarg1) {
58171     return (Dali::BaseHandle *)jarg1;
58172 }
58173
58174 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
58175     return (Dali::BaseHandle *)jarg1;
58176 }
58177
58178 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
58179     return (Dali::Handle *)jarg1;
58180 }
58181
58182 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
58183     return (Dali::Handle *)jarg1;
58184 }
58185
58186 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
58187     return (Dali::BaseHandle *)jarg1;
58188 }
58189
58190 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
58191     return (Dali::BaseHandle *)jarg1;
58192 }
58193
58194 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
58195     return (Dali::Handle *)jarg1;
58196 }
58197
58198 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchEvent *jarg1) {
58199     return (Dali::BaseHandle *)jarg1;
58200 }
58201
58202 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Hover_SWIGUpcast(Dali::HoverEvent *jarg1) {
58203     return (Dali::BaseHandle *)jarg1;
58204 }
58205
58206 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Wheel_SWIGUpcast(Dali::WheelEvent *jarg1) {
58207     return (Dali::BaseHandle *)jarg1;
58208 }
58209
58210 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Key_SWIGUpcast(Dali::KeyEvent *jarg1) {
58211     return (Dali::BaseHandle *)jarg1;
58212 }
58213
58214 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Gesture_SWIGUpcast(Dali::Gesture *jarg1) {
58215     return (Dali::BaseHandle *)jarg1;
58216 }
58217
58218 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
58219     return (Dali::Handle *)jarg1;
58220 }
58221
58222 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
58223     return (Dali::GestureDetector *)jarg1;
58224 }
58225
58226 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
58227     return (Dali::Gesture *)jarg1;
58228 }
58229
58230 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
58231     return (Dali::Handle *)jarg1;
58232 }
58233
58234 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
58235     return (Dali::Actor *)jarg1;
58236 }
58237
58238 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
58239     return (Dali::RefObject *)jarg1;
58240 }
58241
58242 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
58243     return (Dali::Actor *)jarg1;
58244 }
58245
58246 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
58247     return (Dali::GestureDetector *)jarg1;
58248 }
58249
58250 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
58251     return (Dali::Gesture *)jarg1;
58252 }
58253
58254 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
58255     return (Dali::GestureDetector *)jarg1;
58256 }
58257
58258 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
58259     return (Dali::Gesture *)jarg1;
58260 }
58261
58262 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
58263     return (Dali::GestureDetector *)jarg1;
58264 }
58265
58266 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
58267     return (Dali::Gesture *)jarg1;
58268 }
58269
58270 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
58271     return (Dali::BaseHandle *)jarg1;
58272 }
58273
58274 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
58275     return (Dali::Handle *)jarg1;
58276 }
58277
58278 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
58279     return (Dali::Handle *)jarg1;
58280 }
58281
58282 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
58283     return (Dali::Handle *)jarg1;
58284 }
58285
58286 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
58287     return (Dali::RefObject *)jarg1;
58288 }
58289
58290 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
58291     return (Dali::Actor *)jarg1;
58292 }
58293
58294 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
58295     return (Dali::BaseHandle *)jarg1;
58296 }
58297
58298 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
58299     return (Dali::BaseHandle *)jarg1;
58300 }
58301
58302 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
58303     return (Dali::BaseHandle *)jarg1;
58304 }
58305
58306 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
58307     return (Dali::CustomActorImpl *)jarg1;
58308 }
58309
58310 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
58311     return (Dali::CustomActor *)jarg1;
58312 }
58313
58314 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
58315     return (Dali::BaseHandle *)jarg1;
58316 }
58317
58318 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
58319     return (Dali::Toolkit::Control *)jarg1;
58320 }
58321
58322 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
58323     return (Dali::Toolkit::Control *)jarg1;
58324 }
58325
58326 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
58327     return (Dali::Toolkit::Button *)jarg1;
58328 }
58329
58330 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
58331     return (Dali::Toolkit::Button *)jarg1;
58332 }
58333
58334 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
58335     return (Dali::Toolkit::Button *)jarg1;
58336 }
58337
58338 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
58339     return (Dali::Toolkit::Control *)jarg1;
58340 }
58341
58342 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
58343     return (Dali::Toolkit::Control *)jarg1;
58344 }
58345
58346 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
58347     return (Dali::Toolkit::Control *)jarg1;
58348 }
58349
58350 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
58351     return (Dali::Toolkit::Control *)jarg1;
58352 }
58353
58354 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
58355     return (Dali::Toolkit::Control *)jarg1;
58356 }
58357
58358 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
58359     return (Dali::RefObject *)jarg1;
58360 }
58361
58362 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
58363     return (Dali::Toolkit::Scrollable *)jarg1;
58364 }
58365
58366 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
58367     return (Dali::BaseHandle *)jarg1;
58368 }
58369
58370 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
58371     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
58372 }
58373
58374 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
58375     return (Dali::RefObject *)jarg1;
58376 }
58377
58378 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
58379     return (Dali::Toolkit::Ruler *)jarg1;
58380 }
58381
58382 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
58383     return (Dali::Toolkit::Ruler *)jarg1;
58384 }
58385
58386 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
58387     return (Dali::Toolkit::Scrollable *)jarg1;
58388 }
58389
58390 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
58391     return (Dali::Toolkit::Control *)jarg1;
58392 }
58393
58394
58395 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
58396     return (Dali::Toolkit::Control *)jarg1;
58397 }
58398
58399 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
58400     return (Dali::BaseHandle *)jarg1;
58401 }
58402
58403 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
58404     return (Dali::BaseHandle *)jarg1;
58405 }
58406
58407 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
58408     return (Dali::Toolkit::Control *)jarg1;
58409 }
58410
58411 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
58412     return (Dali::Toolkit::Control *)jarg1;
58413 }
58414
58415 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_CameraView_SWIGUpcast(Dali::Toolkit::CameraView *jarg1) {
58416     return (Dali::Toolkit::Control *)jarg1;
58417 }
58418
58419 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
58420     return (Dali::Toolkit::Control *)jarg1;
58421 }
58422
58423 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
58424     return (Dali::Toolkit::Control *)jarg1;
58425 }
58426
58427 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
58428     return (Dali::Toolkit::Control *)jarg1;
58429 }
58430
58431 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
58432     return (Dali::Toolkit::Control *)jarg1;
58433 }
58434
58435 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
58436     return (Dali::Toolkit::PageTurnView *)jarg1;
58437 }
58438
58439 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
58440     return (Dali::Toolkit::PageTurnView *)jarg1;
58441 }
58442
58443 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
58444     return (Dali::Toolkit::Button *)jarg1;
58445 }
58446
58447 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
58448     return (Dali::BaseHandle *)jarg1;
58449 }
58450
58451 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
58452     return (Dali::BaseHandle *)jarg1;
58453 }
58454
58455 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
58456     return (Dali::BaseHandle *)jarg1;
58457 }
58458
58459 /*
58460  * Widget binding
58461  */
58462 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
58463     return (Dali::BaseHandle *)jarg1;
58464 }
58465
58466 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
58467     return (Dali::BaseObject *)jarg1;
58468 }
58469
58470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
58471   void * jresult ;
58472   Dali::Widget result;
58473
58474   {
58475     try {
58476       result = Dali::Widget::New();
58477     } CALL_CATCH_EXCEPTION(0);
58478   }
58479
58480   jresult = new Dali::Widget((const Dali::Widget &)result);
58481   return jresult;
58482 }
58483
58484
58485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
58486   void * jresult ;
58487   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
58488   Dali::Widget result;
58489
58490   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58491
58492   if (!arg1) {
58493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
58494     return 0;
58495   }
58496   {
58497     try {
58498       jresult = new Dali::Widget(arg1);
58499     } CALL_CATCH_EXCEPTION(0);
58500   }
58501   return jresult;
58502 }
58503
58504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
58505   void * jresult ;
58506   Dali::Widget *result = 0 ;
58507
58508   {
58509     try {
58510       result = (Dali::Widget *)new Dali::Widget();
58511     } CALL_CATCH_EXCEPTION(0);
58512   }
58513   jresult = (void *)result;
58514   return jresult;
58515 }
58516
58517
58518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
58519   void * jresult ;
58520   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
58521   Dali::Widget *arg2 = 0 ;
58522   Dali::Widget *result = 0 ;
58523
58524   arg1 = (Dali::Widget *)jarg1;
58525   arg2 = (Dali::Widget *)jarg2;
58526   if (!arg2) {
58527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
58528     return 0;
58529   }
58530   {
58531     try {
58532       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
58533     } CALL_CATCH_EXCEPTION(0);
58534   }
58535   jresult = (void *)result;
58536   return jresult;
58537 }
58538
58539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
58540   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
58541
58542   arg1 = (Dali::Widget *)jarg1;
58543   {
58544     try {
58545       delete arg1;
58546     } CALL_CATCH_EXCEPTION();
58547   }
58548 }
58549
58550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
58551   void * jresult ;
58552   SwigDirector_WidgetImpl* result;
58553   {
58554     try {
58555       result = new SwigDirector_WidgetImpl();
58556     } CALL_CATCH_EXCEPTION(0);
58557   }
58558   jresult = result;
58559   return jresult;
58560 }
58561
58562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
58563   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58564   std::string *arg2 = 0 ;
58565   Dali::Window arg3 ;
58566   Dali::Window *argp3 ;
58567
58568   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58569   if (!jarg2) {
58570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58571     return ;
58572   }
58573   std::string arg2_str(jarg2);
58574   arg2 = &arg2_str;
58575   argp3 = (Dali::Window *)jarg3;
58576   if (!argp3) {
58577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
58578     return ;
58579   }
58580   arg3 = *argp3;
58581   {
58582     try {
58583       (arg1)->OnCreate((std::string const &)*arg2,arg3);
58584     } CALL_CATCH_EXCEPTION();
58585   }
58586 }
58587
58588
58589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
58590   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58591   std::string *arg2 = 0 ;
58592   Dali::Window arg3 ;
58593   Dali::Window *argp3 ;
58594
58595   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58596   if (!jarg2) {
58597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58598     return ;
58599   }
58600   std::string arg2_str(jarg2);
58601   arg2 = &arg2_str;
58602   argp3 = (Dali::Window *)jarg3;
58603   if (!argp3) {
58604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
58605     return ;
58606   }
58607   arg3 = *argp3;
58608   {
58609     try {
58610       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
58611     } CALL_CATCH_EXCEPTION();
58612   }
58613 }
58614
58615
58616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
58617   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58618   std::string *arg2 = 0 ;
58619   Dali::Widget::Termination arg3 ;
58620
58621   arg1 = (Dali::Internal::Adaptor::Widget *)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   arg3 = (Dali::Widget::Termination)jarg3;
58629   {
58630     try {
58631       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
58632     } CALL_CATCH_EXCEPTION();
58633   }
58634 }
58635
58636
58637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
58638   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58639   std::string *arg2 = 0 ;
58640   Dali::Widget::Termination arg3 ;
58641
58642   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58643   if (!jarg2) {
58644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58645     return ;
58646   }
58647   std::string arg2_str(jarg2);
58648   arg2 = &arg2_str;
58649   arg3 = (Dali::Widget::Termination)jarg3;
58650   {
58651     try {
58652       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
58653     } CALL_CATCH_EXCEPTION();
58654   }
58655 }
58656
58657
58658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
58659   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58660
58661   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58662   {
58663     try {
58664       (arg1)->OnPause();
58665     } CALL_CATCH_EXCEPTION();
58666   }
58667 }
58668
58669
58670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
58671   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58672
58673   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58674   {
58675     try {
58676       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
58677     } CALL_CATCH_EXCEPTION();
58678   }
58679 }
58680
58681
58682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
58683   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58684
58685   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58686   {
58687     try {
58688       (arg1)->OnResume();
58689     } CALL_CATCH_EXCEPTION();
58690   }
58691 }
58692
58693
58694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
58695   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58696
58697   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58698   {
58699     try {
58700       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
58701     } CALL_CATCH_EXCEPTION();
58702   }
58703 }
58704
58705
58706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
58707   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58708   Dali::Window arg2 ;
58709   Dali::Window *argp2 ;
58710
58711   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58712   argp2 = (Dali::Window *)jarg2;
58713   if (!argp2) {
58714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
58715     return ;
58716   }
58717   arg2 = *argp2;
58718   {
58719     try {
58720       (arg1)->OnResize(arg2);
58721     } CALL_CATCH_EXCEPTION();
58722   }
58723 }
58724
58725
58726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
58727   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58728   Dali::Window arg2 ;
58729   Dali::Window *argp2 ;
58730
58731   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58732   argp2 = (Dali::Window *)jarg2;
58733   if (!argp2) {
58734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
58735     return ;
58736   }
58737   arg2 = *argp2;
58738   {
58739     try {
58740       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
58741     } CALL_CATCH_EXCEPTION();
58742   }
58743 }
58744
58745
58746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
58747   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58748   std::string *arg2 = 0 ;
58749   int arg3 ;
58750
58751   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58752   if (!jarg2) {
58753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58754     return ;
58755   }
58756   std::string arg2_str(jarg2);
58757   arg2 = &arg2_str;
58758   arg3 = (int)jarg3;
58759   {
58760     try {
58761       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
58762     } CALL_CATCH_EXCEPTION();
58763   }
58764 }
58765
58766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
58767   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58768   std::string *arg2 = 0 ;
58769   int arg3 ;
58770
58771   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58772   if (!jarg2) {
58773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58774     return ;
58775   }
58776   std::string arg2_str(jarg2);
58777   arg2 = &arg2_str;
58778   arg3 = (int)jarg3;
58779   {
58780     try {
58781       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
58782     } CALL_CATCH_EXCEPTION();
58783   }
58784 }
58785
58786
58787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
58788   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58789   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58790   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58791
58792   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58793   arg2 = (Dali::SlotObserver *)jarg2;
58794   arg3 = (Dali::CallbackBase *)jarg3;
58795   {
58796     try {
58797       (arg1)->SignalConnected(arg2,arg3);
58798     } CALL_CATCH_EXCEPTION();
58799   }
58800 }
58801
58802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
58803   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58804   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58805   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58806
58807   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58808   arg2 = (Dali::SlotObserver *)jarg2;
58809   arg3 = (Dali::CallbackBase *)jarg3;
58810   {
58811     try {
58812       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
58813     } CALL_CATCH_EXCEPTION();
58814   }
58815 }
58816
58817
58818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
58819   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58820   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58821   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58822
58823   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58824   arg2 = (Dali::SlotObserver *)jarg2;
58825   arg3 = (Dali::CallbackBase *)jarg3;
58826   {
58827     try {
58828       (arg1)->SignalDisconnected(arg2,arg3);
58829     } CALL_CATCH_EXCEPTION();
58830   }
58831 }
58832
58833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
58834   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58835   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58836   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58837
58838   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58839   arg2 = (Dali::SlotObserver *)jarg2;
58840   arg3 = (Dali::CallbackBase *)jarg3;
58841   {
58842     try {
58843       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
58844     } CALL_CATCH_EXCEPTION();
58845   }
58846 }
58847
58848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
58849   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58850   std::string *arg2 = 0 ;
58851
58852   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58853   if (!jarg2) {
58854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58855     return ;
58856   }
58857   std::string arg2_str(jarg2);
58858   arg2 = &arg2_str;
58859   {
58860     try {
58861       (arg1)->SetContentInfo((std::string const &)*arg2);
58862     } CALL_CATCH_EXCEPTION();
58863   }
58864 }
58865
58866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetUsingKeyEvent(void * jwidget, bool jflag) {
58867   Dali::Internal::Adaptor::Widget *widget = (Dali::Internal::Adaptor::Widget *) 0 ;
58868   bool flag;
58869
58870   widget = (Dali::Internal::Adaptor::Widget *)jwidget;
58871   flag = jflag ? true : false;
58872   {
58873     try {
58874       (widget)->SetUsingKeyEvent(flag);
58875     } CALL_CATCH_EXCEPTION();
58876   }
58877 }
58878
58879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
58880   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
58881   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
58882
58883   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
58884   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
58885   {
58886     try {
58887       (arg1)->SetImpl(arg2);
58888     } CALL_CATCH_EXCEPTION();
58889   }
58890 }
58891
58892
58893 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) {
58894   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
58895   if (director) {
58896     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
58897   }
58898 }
58899
58900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
58901   void * jresult ;
58902   Dali::Widget *arg1 = 0 ;
58903   SwigDirector_WidgetImpl *result = 0 ;
58904
58905   arg1 = (Dali::Widget *)jarg1;
58906   if (!arg1) {
58907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
58908     return 0;
58909   }
58910   {
58911     try {
58912       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
58913     } CALL_CATCH_EXCEPTION(0);
58914   }
58915   jresult = (void*) result;
58916   return jresult;
58917 }
58918
58919
58920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
58921   void * jresult ;
58922   int *arg1 = (int *) 0 ;
58923   char ***arg2 ;
58924   std::string *arg3 = 0 ;
58925   Dali::WidgetApplication result;
58926   {
58927     int index = 0;
58928     int length = 0;
58929     char *retPtr;
58930     char *nextPtr;
58931     argWidgetC = jarg1;
58932     argWidgetV = new char*[jarg1 + 1];
58933
58934     retPtr = strtok_r( jarg2, " ", &nextPtr);
58935     if( retPtr )
58936     {
58937       length = strlen(retPtr);
58938     }
58939     argWidgetV[index] = new char[length + 1];
58940     if( retPtr )
58941     {
58942       strncpy(argWidgetV[index], retPtr, length);
58943     }
58944     argWidgetV[index][length] = '\0';
58945     index++;
58946
58947     while (index < jarg1)
58948     {
58949       length = 0;
58950       retPtr = strtok_r(NULL, " ", &nextPtr);
58951       if( retPtr )
58952       {
58953         length = strlen(retPtr);
58954       }
58955       argWidgetV[index] = new char[length + 1];
58956       if( retPtr )
58957       {
58958         strncpy(argWidgetV[index], retPtr, length);
58959       }
58960       argWidgetV[index][length] = '\0';
58961       index++;
58962     }
58963
58964     argWidgetV[jarg1] = NULL;
58965     argWidgetC = jarg1;
58966
58967     arg1 = &argWidgetC;
58968     arg2 = &argWidgetV;
58969   }
58970
58971   if (!jarg3) {
58972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58973     return 0;
58974   }
58975   std::string arg3_str(jarg3);
58976   arg3 = &arg3_str;
58977   {
58978     try {
58979       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
58980     } CALL_CATCH_EXCEPTION(0);
58981   }
58982   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
58983   return jresult;
58984 }
58985
58986
58987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
58988   void * jresult ;
58989   Dali::WidgetApplication *result = 0 ;
58990
58991   {
58992     try {
58993       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
58994     } CALL_CATCH_EXCEPTION(0);
58995   }
58996   jresult = (void *)result;
58997   return jresult;
58998 }
58999
59000
59001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
59002   void * jresult ;
59003   Dali::WidgetApplication *arg1 = 0 ;
59004   Dali::WidgetApplication *result = 0 ;
59005
59006   arg1 = (Dali::WidgetApplication *)jarg1;
59007   if (!arg1) {
59008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
59009     return 0;
59010   }
59011   {
59012     try {
59013       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
59014     } CALL_CATCH_EXCEPTION(0);
59015   }
59016   jresult = (void *)result;
59017   return jresult;
59018 }
59019
59020
59021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
59022   void * jresult ;
59023   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
59024   Dali::WidgetApplication *arg2 = 0 ;
59025   Dali::WidgetApplication *result = 0 ;
59026
59027   arg1 = (Dali::WidgetApplication *)jarg1;
59028   arg2 = (Dali::WidgetApplication *)jarg2;
59029   if (!arg2) {
59030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
59031     return 0;
59032   }
59033   {
59034     try {
59035       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
59036     } CALL_CATCH_EXCEPTION(0);
59037   }
59038   jresult = (void *)result;
59039   return jresult;
59040 }
59041
59042
59043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
59044   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
59045
59046   arg1 = (Dali::WidgetApplication *)jarg1;
59047   {
59048     try {
59049       delete arg1;
59050       if( argWidgetV )
59051       {
59052         // free string data
59053         for( int i=0; i < argWidgetC+1; i++)
59054         {
59055           delete [] argWidgetV[i];
59056         }
59057         delete [] argWidgetV;
59058       }
59059     } CALL_CATCH_EXCEPTION();
59060   }
59061 }
59062
59063
59064 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
59065 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
59066
59067 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
59068 {
59069   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
59070   return *widget;
59071 }
59072
59073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
59074   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
59075   std::string *arg2 = 0 ;
59076
59077   arg1 = (Dali::WidgetApplication *)jarg1;
59078   if (!jarg2) {
59079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59080     return ;
59081   }
59082   std::string arg2_str(*jarg2);
59083   arg2 = &arg2_str;
59084
59085   if(!_CSharpCreateWidgetFunction)
59086   {
59087     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
59088   }
59089
59090   {
59091     try {
59092       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
59093     } CALL_CATCH_EXCEPTION();
59094   }
59095   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
59096 }
59097
59098
59099 //for PixelBuffer and ImageLoading
59100
59101 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
59102     return (Dali::BaseHandle *)jarg1;
59103 }
59104
59105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
59106   void * jresult ;
59107   unsigned int arg1 ;
59108   unsigned int arg2 ;
59109   Dali::Pixel::Format arg3 ;
59110   Dali::Devel::PixelBuffer result;
59111
59112   arg1 = (unsigned int)jarg1;
59113   arg2 = (unsigned int)jarg2;
59114   arg3 = (Dali::Pixel::Format)jarg3;
59115   {
59116     try {
59117       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
59118     } CALL_CATCH_EXCEPTION(0);
59119   }
59120   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59121   return jresult;
59122 }
59123
59124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
59125   void * jresult ;
59126   Dali::Devel::PixelBuffer *result = 0 ;
59127
59128   {
59129     try {
59130       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
59131     } CALL_CATCH_EXCEPTION(0);
59132   }
59133   jresult = (void *)result;
59134   return jresult;
59135 }
59136
59137
59138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
59139   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59140
59141   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59142   {
59143     try {
59144       delete arg1;
59145     } CALL_CATCH_EXCEPTION();
59146   }
59147 }
59148
59149
59150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
59151   void * jresult ;
59152   Dali::Devel::PixelBuffer *arg1 = 0 ;
59153   Dali::Devel::PixelBuffer *result = 0 ;
59154
59155   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59156   if (!arg1) {
59157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
59158     return 0;
59159   }
59160   {
59161     try {
59162       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
59163     } CALL_CATCH_EXCEPTION(0);
59164   }
59165   jresult = (void *)result;
59166   return jresult;
59167 }
59168
59169
59170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
59171   void * jresult ;
59172   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59173   Dali::Devel::PixelBuffer *arg2 = 0 ;
59174   Dali::Devel::PixelBuffer *result = 0 ;
59175
59176   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59177   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
59178   if (!arg2) {
59179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
59180     return 0;
59181   }
59182   {
59183     try {
59184       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
59185     } CALL_CATCH_EXCEPTION(0);
59186   }
59187   jresult = (void *)result;
59188   return jresult;
59189 }
59190
59191
59192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
59193   void * jresult ;
59194   Dali::Devel::PixelBuffer *arg1 = 0 ;
59195   Dali::PixelData result;
59196
59197   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59198   if (!arg1) {
59199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
59200     return 0;
59201   }
59202   {
59203     try {
59204       result = Dali::Devel::PixelBuffer::Convert(*arg1);
59205     } CALL_CATCH_EXCEPTION(0);
59206   }
59207   jresult = new Dali::PixelData((const Dali::PixelData &)result);
59208   return jresult;
59209 }
59210
59211
59212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
59213   void * jresult ;
59214   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59215   Dali::PixelData result;
59216
59217   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59218   {
59219     try {
59220       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
59221     } CALL_CATCH_EXCEPTION(0);
59222   }
59223   jresult = new Dali::PixelData((const Dali::PixelData &)result);
59224   return jresult;
59225 }
59226
59227
59228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
59229   void * jresult ;
59230   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59231   unsigned char *result = 0 ;
59232
59233   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59234   {
59235     try {
59236       result = (unsigned char *)(arg1)->GetBuffer();
59237     } CALL_CATCH_EXCEPTION(0);
59238   }
59239    jresult = (void *)result;
59240    return jresult;
59241 }
59242
59243 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
59244   unsigned int jresult ;
59245   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59246   unsigned int result;
59247
59248   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59249   {
59250     try {
59251       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
59252     } CALL_CATCH_EXCEPTION(0);
59253   }
59254   jresult = result;
59255   return jresult;
59256 }
59257
59258
59259 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
59260   unsigned int jresult ;
59261   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59262   unsigned int result;
59263
59264   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59265   {
59266     try {
59267       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
59268     } CALL_CATCH_EXCEPTION(0);
59269   }
59270   jresult = result;
59271   return jresult;
59272 }
59273
59274
59275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
59276   int jresult ;
59277   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59278   Dali::Pixel::Format result;
59279
59280   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59281   {
59282     try {
59283       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
59284     } CALL_CATCH_EXCEPTION(0);
59285   }
59286   jresult = (int)result;
59287   return jresult;
59288 }
59289
59290
59291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, bool jarg4) {
59292   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59293   Dali::Devel::PixelBuffer arg2 ;
59294   float arg3 ;
59295   bool arg4 ;
59296   Dali::Devel::PixelBuffer *argp2 ;
59297
59298   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59299   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
59300   if (!argp2) {
59301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
59302     return ;
59303   }
59304   arg2 = *argp2;
59305   arg3 = (float)jarg3;
59306   arg4 = jarg4 ? true : false;
59307   {
59308     try {
59309       (arg1)->ApplyMask(arg2,arg3,arg4);
59310     } CALL_CATCH_EXCEPTION();
59311   }
59312 }
59313
59314
59315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
59316   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59317   Dali::Devel::PixelBuffer arg2 ;
59318   float arg3 ;
59319   Dali::Devel::PixelBuffer *argp2 ;
59320
59321   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59322   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
59323   if (!argp2) {
59324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
59325     return ;
59326   }
59327   arg2 = *argp2;
59328   arg3 = (float)jarg3;
59329   {
59330     try {
59331       (arg1)->ApplyMask(arg2,arg3);
59332     } CALL_CATCH_EXCEPTION();
59333   }
59334 }
59335
59336
59337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
59338   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59339   Dali::Devel::PixelBuffer arg2 ;
59340   Dali::Devel::PixelBuffer *argp2 ;
59341
59342   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59343   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
59344   if (!argp2) {
59345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
59346     return ;
59347   }
59348   arg2 = *argp2;
59349   {
59350     try {
59351       (arg1)->ApplyMask(arg2);
59352     } CALL_CATCH_EXCEPTION();
59353   }
59354 }
59355
59356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
59357   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59358   float arg2 ;
59359
59360   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59361   arg2 = (float)jarg2;
59362   {
59363     try {
59364       (arg1)->ApplyGaussianBlur(arg2);
59365     } CALL_CATCH_EXCEPTION();
59366   }
59367 }
59368
59369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
59370   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59371   uint16_t arg2 ;
59372   uint16_t arg3 ;
59373   uint16_t arg4 ;
59374   uint16_t arg5 ;
59375
59376   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59377   arg2 = (uint16_t)jarg2;
59378   arg3 = (uint16_t)jarg3;
59379   arg4 = (uint16_t)jarg4;
59380   arg5 = (uint16_t)jarg5;
59381   {
59382     try {
59383       (arg1)->Crop(arg2,arg3,arg4,arg5);
59384     } CALL_CATCH_EXCEPTION();
59385   }
59386 }
59387
59388
59389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
59390   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59391   uint16_t arg2 ;
59392   uint16_t arg3 ;
59393
59394   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59395   arg2 = (uint16_t)jarg2;
59396   arg3 = (uint16_t)jarg3;
59397   {
59398     try {
59399       (arg1)->Resize(arg2,arg3);
59400     } CALL_CATCH_EXCEPTION();
59401   }
59402 }
59403
59404 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void* jarg2) {
59405   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59406   Dali::Degree * arg2 ;
59407
59408   bool result = false;
59409
59410   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59411   arg2 = (Dali::Degree *)jarg2;
59412   {
59413     try {
59414       result = (arg1)->Rotate(*arg2);
59415     } CALL_CATCH_EXCEPTION(false);
59416   }
59417   return result;
59418 }
59419
59420 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBrightness(void * jarg1) {
59421   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59422   uint32_t result = 0;
59423
59424   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59425   {
59426     try {
59427       result = (arg1)->GetBrightness();
59428     } CALL_CATCH_EXCEPTION(0);
59429   }
59430   return result;
59431 }
59432
59433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
59434   void * jresult ;
59435   std::string *arg1 = 0 ;
59436   Dali::ImageDimensions arg2 ;
59437   Dali::FittingMode::Type arg3 ;
59438   Dali::SamplingMode::Type arg4 ;
59439   bool arg5 ;
59440   Dali::ImageDimensions *argp2 ;
59441   Dali::Devel::PixelBuffer result;
59442
59443   if (!jarg1) {
59444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59445     return 0;
59446   }
59447   std::string arg1_str(jarg1);
59448   arg1 = &arg1_str;
59449   argp2 = (Dali::ImageDimensions *)jarg2;
59450   if (!argp2) {
59451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59452     return 0;
59453   }
59454   arg2 = *argp2;
59455   arg3 = (Dali::FittingMode::Type)jarg3;
59456   arg4 = (Dali::SamplingMode::Type)jarg4;
59457   arg5 = jarg5 ? true : false;
59458   {
59459     try {
59460       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
59461     } CALL_CATCH_EXCEPTION(0);
59462   }
59463   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59464   return jresult;
59465 }
59466
59467
59468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
59469   void * jresult ;
59470   std::string *arg1 = 0 ;
59471   Dali::ImageDimensions arg2 ;
59472   Dali::FittingMode::Type arg3 ;
59473   Dali::SamplingMode::Type arg4 ;
59474   Dali::ImageDimensions *argp2 ;
59475   Dali::Devel::PixelBuffer result;
59476
59477   if (!jarg1) {
59478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59479     return 0;
59480   }
59481   std::string arg1_str(jarg1);
59482   arg1 = &arg1_str;
59483   argp2 = (Dali::ImageDimensions *)jarg2;
59484   if (!argp2) {
59485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59486     return 0;
59487   }
59488   arg2 = *argp2;
59489   arg3 = (Dali::FittingMode::Type)jarg3;
59490   arg4 = (Dali::SamplingMode::Type)jarg4;
59491   {
59492     try {
59493       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
59494     } CALL_CATCH_EXCEPTION(0);
59495   }
59496   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59497   return jresult;
59498 }
59499
59500
59501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
59502   void * jresult ;
59503   std::string *arg1 = 0 ;
59504   Dali::ImageDimensions arg2 ;
59505   Dali::FittingMode::Type arg3 ;
59506   Dali::ImageDimensions *argp2 ;
59507   Dali::Devel::PixelBuffer result;
59508
59509   if (!jarg1) {
59510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59511     return 0;
59512   }
59513   std::string arg1_str(jarg1);
59514   arg1 = &arg1_str;
59515   argp2 = (Dali::ImageDimensions *)jarg2;
59516   if (!argp2) {
59517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59518     return 0;
59519   }
59520   arg2 = *argp2;
59521   arg3 = (Dali::FittingMode::Type)jarg3;
59522   {
59523     try {
59524       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
59525     } CALL_CATCH_EXCEPTION(0);
59526   }
59527   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59528   return jresult;
59529 }
59530
59531
59532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
59533   void * jresult ;
59534   std::string *arg1 = 0 ;
59535   Dali::ImageDimensions arg2 ;
59536   Dali::ImageDimensions *argp2 ;
59537   Dali::Devel::PixelBuffer result;
59538
59539   if (!jarg1) {
59540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59541     return 0;
59542   }
59543   std::string arg1_str(jarg1);
59544   arg1 = &arg1_str;
59545   argp2 = (Dali::ImageDimensions *)jarg2;
59546   if (!argp2) {
59547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59548     return 0;
59549   }
59550   arg2 = *argp2;
59551   {
59552     try {
59553       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
59554     } CALL_CATCH_EXCEPTION(0);
59555   }
59556   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59557   return jresult;
59558 }
59559
59560
59561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
59562   void * jresult ;
59563   std::string *arg1 = 0 ;
59564   Dali::Devel::PixelBuffer result;
59565
59566   if (!jarg1) {
59567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59568     return 0;
59569   }
59570   std::string arg1_str(jarg1);
59571   arg1 = &arg1_str;
59572   {
59573     try {
59574       result = Dali::LoadImageFromFile((std::string const &)*arg1);
59575     } CALL_CATCH_EXCEPTION(0);
59576   }
59577   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59578   return jresult;
59579 }
59580
59581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_0(void * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
59582   void * jresult ;
59583   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
59584   Dali::ImageDimensions arg2 ;
59585   Dali::FittingMode::Type arg3 ;
59586   Dali::SamplingMode::Type arg4 ;
59587   bool arg5 ;
59588   Dali::ImageDimensions *argp2 ;
59589   Dali::Devel::PixelBuffer result;
59590
59591   if (!jarg1) {
59592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
59593     return 0;
59594   }
59595   arg1 = (Dali::Vector<uint8_t> *)jarg1;
59596   argp2 = (Dali::ImageDimensions *)jarg2;
59597   if (!argp2) {
59598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59599     return 0;
59600   }
59601   arg2 = *argp2;
59602   arg3 = (Dali::FittingMode::Type)jarg3;
59603   arg4 = (Dali::SamplingMode::Type)jarg4;
59604   arg5 = jarg5 ? true : false;
59605   {
59606     try {
59607       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1, arg2, arg3, arg4, arg5);
59608     } CALL_CATCH_EXCEPTION(0);
59609   }
59610   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59611   return jresult;
59612 }
59613
59614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_1(void * jarg1, void * jarg2, int jarg3, int jarg4) {
59615   void * jresult ;
59616   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
59617   Dali::ImageDimensions arg2 ;
59618   Dali::FittingMode::Type arg3 ;
59619   Dali::SamplingMode::Type arg4 ;
59620   Dali::ImageDimensions *argp2 ;
59621   Dali::Devel::PixelBuffer result;
59622
59623   if (!jarg1) {
59624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
59625     return 0;
59626   }
59627   arg1 = (Dali::Vector<uint8_t> *)jarg1;
59628   argp2 = (Dali::ImageDimensions *)jarg2;
59629   if (!argp2) {
59630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59631     return 0;
59632   }
59633   arg2 = *argp2;
59634   arg3 = (Dali::FittingMode::Type)jarg3;
59635   arg4 = (Dali::SamplingMode::Type)jarg4;
59636   {
59637     try {
59638       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1, arg2, arg3, arg4);
59639     } CALL_CATCH_EXCEPTION(0);
59640   }
59641   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59642   return jresult;
59643 }
59644
59645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_2(void * jarg1, void * jarg2, int jarg3) {
59646   void * jresult ;
59647   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
59648   Dali::ImageDimensions arg2 ;
59649   Dali::FittingMode::Type arg3 ;
59650   Dali::ImageDimensions *argp2 ;
59651   Dali::Devel::PixelBuffer result;
59652
59653   if (!jarg1) {
59654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
59655     return 0;
59656   }
59657   arg1 = (Dali::Vector<uint8_t> *)jarg1;
59658   argp2 = (Dali::ImageDimensions *)jarg2;
59659   if (!argp2) {
59660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59661     return 0;
59662   }
59663   arg2 = *argp2;
59664   arg3 = (Dali::FittingMode::Type)jarg3;
59665   {
59666     try {
59667       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1, arg2, arg3);
59668     } CALL_CATCH_EXCEPTION(0);
59669   }
59670   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59671   return jresult;
59672 }
59673
59674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_3(void * jarg1, void * jarg2) {
59675   void * jresult ;
59676   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
59677   Dali::ImageDimensions arg2 ;
59678   Dali::ImageDimensions *argp2 ;
59679   Dali::Devel::PixelBuffer result;
59680
59681   if (!jarg1) {
59682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
59683     return 0;
59684   }
59685   arg1 = (Dali::Vector<uint8_t> *)jarg1;
59686   argp2 = (Dali::ImageDimensions *)jarg2;
59687   if (!argp2) {
59688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59689     return 0;
59690   }
59691   arg2 = *argp2;
59692   {
59693     try {
59694       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1, arg2);
59695     } CALL_CATCH_EXCEPTION(0);
59696   }
59697   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59698   return jresult;
59699 }
59700
59701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_4(void * jarg1) {
59702   void * jresult ;
59703   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
59704   Dali::Devel::PixelBuffer result;
59705
59706   if (!jarg1) {
59707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
59708     return 0;
59709   }
59710   arg1 = (Dali::Vector<uint8_t> *)jarg1;
59711   {
59712     try {
59713       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1);
59714     } CALL_CATCH_EXCEPTION(0);
59715   }
59716   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59717   return jresult;
59718 }
59719
59720
59721
59722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
59723   void * jresult ;
59724   std::string *arg1 = 0 ;
59725   Dali::ImageDimensions arg2 ;
59726   Dali::FittingMode::Type arg3 ;
59727   Dali::SamplingMode::Type arg4 ;
59728   bool arg5 ;
59729   Dali::ImageDimensions *argp2 ;
59730   Dali::ImageDimensions result;
59731
59732   if (!jarg1) {
59733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59734     return 0;
59735   }
59736   std::string arg1_str(jarg1);
59737   arg1 = &arg1_str;
59738   argp2 = (Dali::ImageDimensions *)jarg2;
59739   if (!argp2) {
59740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59741     return 0;
59742   }
59743   arg2 = *argp2;
59744   arg3 = (Dali::FittingMode::Type)jarg3;
59745   arg4 = (Dali::SamplingMode::Type)jarg4;
59746   arg5 = jarg5 ? true : false;
59747   {
59748     try {
59749       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
59750     } CALL_CATCH_EXCEPTION(0);
59751   }
59752   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
59753   return jresult;
59754 }
59755
59756
59757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
59758   void * jresult ;
59759   std::string *arg1 = 0 ;
59760   Dali::ImageDimensions arg2 ;
59761   Dali::FittingMode::Type arg3 ;
59762   Dali::SamplingMode::Type arg4 ;
59763   Dali::ImageDimensions *argp2 ;
59764   Dali::ImageDimensions result;
59765
59766   if (!jarg1) {
59767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59768     return 0;
59769   }
59770   std::string arg1_str(jarg1);
59771   arg1 = &arg1_str;
59772   argp2 = (Dali::ImageDimensions *)jarg2;
59773   if (!argp2) {
59774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59775     return 0;
59776   }
59777   arg2 = *argp2;
59778   arg3 = (Dali::FittingMode::Type)jarg3;
59779   arg4 = (Dali::SamplingMode::Type)jarg4;
59780   {
59781     try {
59782       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
59783     } CALL_CATCH_EXCEPTION(0);
59784   }
59785   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
59786   return jresult;
59787 }
59788
59789
59790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
59791   void * jresult ;
59792   std::string *arg1 = 0 ;
59793   Dali::ImageDimensions arg2 ;
59794   Dali::FittingMode::Type arg3 ;
59795   Dali::ImageDimensions *argp2 ;
59796   Dali::ImageDimensions result;
59797
59798   if (!jarg1) {
59799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59800     return 0;
59801   }
59802   std::string arg1_str(jarg1);
59803   arg1 = &arg1_str;
59804   argp2 = (Dali::ImageDimensions *)jarg2;
59805   if (!argp2) {
59806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59807     return 0;
59808   }
59809   arg2 = *argp2;
59810   arg3 = (Dali::FittingMode::Type)jarg3;
59811   {
59812     try {
59813       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
59814     } CALL_CATCH_EXCEPTION(0);
59815   }
59816   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
59817   return jresult;
59818 }
59819
59820
59821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
59822   void * jresult ;
59823   std::string *arg1 = 0 ;
59824   Dali::ImageDimensions arg2 ;
59825   Dali::ImageDimensions *argp2 ;
59826   Dali::ImageDimensions result;
59827
59828   if (!jarg1) {
59829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59830     return 0;
59831   }
59832   std::string arg1_str(jarg1);
59833   arg1 = &arg1_str;
59834   argp2 = (Dali::ImageDimensions *)jarg2;
59835   if (!argp2) {
59836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59837     return 0;
59838   }
59839   arg2 = *argp2;
59840   {
59841     try {
59842       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
59843     } CALL_CATCH_EXCEPTION(0);
59844   }
59845   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
59846   return jresult;
59847 }
59848
59849
59850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
59851   void * jresult ;
59852   std::string *arg1 = 0 ;
59853   Dali::ImageDimensions result;
59854
59855   if (!jarg1) {
59856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59857     return 0;
59858   }
59859   std::string arg1_str(jarg1);
59860   arg1 = &arg1_str;
59861   {
59862     try {
59863       result = Dali::GetClosestImageSize((std::string const &)*arg1);
59864     } CALL_CATCH_EXCEPTION(0);
59865   }
59866   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
59867   return jresult;
59868 }
59869
59870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1, bool jarg2) {
59871   void * jresult ;
59872   std::string *arg1 = 0 ;
59873   bool arg2 ;
59874   Dali::ImageDimensions result;
59875
59876   if (!jarg1) {
59877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59878     return 0;
59879   }
59880   std::string arg1_str(jarg1);
59881   arg1 = &arg1_str;
59882   arg2 = jarg2 ? true : false;
59883   {
59884     try {
59885       result = Dali::GetOriginalImageSize((std::string const &)*arg1,arg2);
59886     } CALL_CATCH_EXCEPTION(0);
59887   }
59888   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
59889   return jresult;
59890 }
59891
59892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
59893   void * jresult ;
59894   std::string *arg1 = 0 ;
59895   Dali::ImageDimensions arg2 ;
59896   Dali::FittingMode::Type arg3 ;
59897   Dali::SamplingMode::Type arg4 ;
59898   bool arg5 ;
59899   Dali::ImageDimensions *argp2 ;
59900   Dali::Devel::PixelBuffer result;
59901
59902   if (!jarg1) {
59903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59904     return 0;
59905   }
59906   std::string arg1_str(jarg1);
59907   arg1 = &arg1_str;
59908   argp2 = (Dali::ImageDimensions *)jarg2;
59909   if (!argp2) {
59910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59911     return 0;
59912   }
59913   arg2 = *argp2;
59914   arg3 = (Dali::FittingMode::Type)jarg3;
59915   arg4 = (Dali::SamplingMode::Type)jarg4;
59916   arg5 = jarg5 ? true : false;
59917   {
59918     try {
59919       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
59920     } CALL_CATCH_EXCEPTION(0);
59921   }
59922   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59923   return jresult;
59924 }
59925
59926
59927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
59928   void * jresult ;
59929   std::string *arg1 = 0 ;
59930   Dali::ImageDimensions arg2 ;
59931   Dali::FittingMode::Type arg3 ;
59932   Dali::SamplingMode::Type arg4 ;
59933   Dali::ImageDimensions *argp2 ;
59934   Dali::Devel::PixelBuffer result;
59935
59936   if (!jarg1) {
59937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59938     return 0;
59939   }
59940   std::string arg1_str(jarg1);
59941   arg1 = &arg1_str;
59942   argp2 = (Dali::ImageDimensions *)jarg2;
59943   if (!argp2) {
59944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59945     return 0;
59946   }
59947   arg2 = *argp2;
59948   arg3 = (Dali::FittingMode::Type)jarg3;
59949   arg4 = (Dali::SamplingMode::Type)jarg4;
59950   {
59951     try {
59952       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
59953     } CALL_CATCH_EXCEPTION(0);
59954   }
59955   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59956   return jresult;
59957 }
59958
59959
59960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
59961   void * jresult ;
59962   std::string *arg1 = 0 ;
59963   Dali::ImageDimensions arg2 ;
59964   Dali::FittingMode::Type arg3 ;
59965   Dali::ImageDimensions *argp2 ;
59966   Dali::Devel::PixelBuffer result;
59967
59968   if (!jarg1) {
59969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59970     return 0;
59971   }
59972   std::string arg1_str(jarg1);
59973   arg1 = &arg1_str;
59974   argp2 = (Dali::ImageDimensions *)jarg2;
59975   if (!argp2) {
59976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59977     return 0;
59978   }
59979   arg2 = *argp2;
59980   arg3 = (Dali::FittingMode::Type)jarg3;
59981   {
59982     try {
59983       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
59984     } CALL_CATCH_EXCEPTION(0);
59985   }
59986   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59987   return jresult;
59988 }
59989
59990
59991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
59992   void * jresult ;
59993   std::string *arg1 = 0 ;
59994   Dali::ImageDimensions arg2 ;
59995   Dali::ImageDimensions *argp2 ;
59996   Dali::Devel::PixelBuffer result;
59997
59998   if (!jarg1) {
59999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60000     return 0;
60001   }
60002   std::string arg1_str(jarg1);
60003   arg1 = &arg1_str;
60004   argp2 = (Dali::ImageDimensions *)jarg2;
60005   if (!argp2) {
60006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60007     return 0;
60008   }
60009   arg2 = *argp2;
60010   {
60011     try {
60012       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
60013     } CALL_CATCH_EXCEPTION(0);
60014   }
60015   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60016   return jresult;
60017 }
60018
60019
60020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
60021   void * jresult ;
60022   std::string *arg1 = 0 ;
60023   Dali::Devel::PixelBuffer result;
60024
60025   if (!jarg1) {
60026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60027     return 0;
60028   }
60029   std::string arg1_str(jarg1);
60030   arg1 = &arg1_str;
60031   {
60032     try {
60033       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
60034     } CALL_CATCH_EXCEPTION(0);
60035   }
60036   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60037   return jresult;
60038 }
60039
60040 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
60041   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
60042   char * jresult = SWIG_csharp_string_callback((const char *)result);
60043   return jresult;
60044 }
60045
60046 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
60047   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
60048   return result;
60049 }
60050
60051 struct NativeImageSourcePtrHandle
60052 {
60053   NativeImageSourcePtr Ptr;
60054 };
60055
60056 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
60057 {
60058   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
60059   return (NativeImageInterface*)(arg1);
60060 }
60061
60062 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
60063 {
60064   void* jresult;
60065   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
60066   {
60067     try {
60068       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
60069     }
60070     catch (std::out_of_range & e) {
60071       {
60072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60073       };
60074     }
60075     catch (std::exception & e) {
60076       {
60077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60078       };
60079     }
60080     catch (Dali::DaliException e) {
60081       {
60082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60083       };
60084     }
60085     catch (...) {
60086       {
60087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60088       };
60089     }
60090   }
60091   jresult = (void *)handle;
60092   return jresult;
60093 }
60094
60095 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
60096 {
60097   void* jresult;
60098   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
60099   jresult = (void*)( handle->Ptr.Get() );
60100   return jresult;
60101 }
60102
60103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
60104   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
60105   {
60106     try {
60107       delete arg1;
60108     }
60109     catch (std::out_of_range & e) {
60110       {
60111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
60112       };
60113     }
60114     catch (std::exception & e) {
60115       {
60116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
60117       };
60118     }
60119     catch (Dali::DaliException e) {
60120       {
60121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
60122       };
60123     }
60124     catch (...) {
60125       {
60126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
60127       };
60128     }
60129   }
60130 }
60131
60132 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
60133 {
60134   void* jresult;
60135   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
60136   uint16_t* arg2 = (uint16_t*)(jarg2);
60137   uint16_t* arg3 = (uint16_t*)(jarg3);
60138   uint16_t* arg4 = (uint16_t*)(jarg4);
60139   {
60140     try {
60141       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
60142     }
60143     catch (std::out_of_range & e) {
60144       {
60145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60146       };
60147     }
60148     catch (std::exception & e) {
60149       {
60150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60151       };
60152     }
60153     catch (Dali::DaliException e) {
60154       {
60155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60156       };
60157     }
60158     catch (...) {
60159       {
60160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60161       };
60162     }
60163   }
60164   return jresult;
60165 }
60166
60167 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
60168 {
60169   bool jresult;
60170   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
60171
60172   {
60173     try {
60174       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
60175     }
60176     catch (std::out_of_range & e) {
60177       {
60178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60179       };
60180     }
60181     catch (std::exception & e) {
60182       {
60183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60184       };
60185     }
60186     catch (Dali::DaliException e) {
60187       {
60188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60189       };
60190     }
60191     catch (...) {
60192       {
60193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60194       };
60195     }
60196   }
60197   return jresult;
60198 }
60199
60200 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_GenerateUrl(void* handle)
60201 {
60202   Dali::Toolkit::ImageUrl result;
60203   NativeImageSource* nativeImageSource = (NativeImageSource*)handle;
60204   void *jresult;
60205
60206   if (!nativeImageSource)
60207   {
60208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0);
60209     return 0;
60210   }
60211   {
60212     try
60213     {
60214       result = Dali::Toolkit::Image::GenerateUrl(nativeImageSource);
60215     }
60216     catch (std::out_of_range& e)
60217     {
60218       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
60219       return 0;
60220     }
60221     catch (std::exception& e)
60222     {
60223       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
60224       return 0;
60225     }
60226     catch (Dali::DaliException e)
60227     {
60228       SWIG_CSharpException(SWIG_UnknownError, e.condition);
60229       return 0;
60230     }
60231     catch (...)
60232     {
60233       SWIG_CSharpException(SWIG_UnknownError, "unknown error");
60234       return 0;
60235     }
60236   }
60237
60238   jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl &)result);
60239   return jresult;
60240 }
60241
60242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageUrl(void* jarg1)
60243 {
60244   Dali::Toolkit::ImageUrl* imageUrl = (Dali::Toolkit::ImageUrl*) 0;
60245
60246   imageUrl = (Dali::Toolkit::ImageUrl*)jarg1;
60247   {
60248     try
60249     {
60250       delete imageUrl;
60251     }
60252     catch (std::out_of_range& e)
60253     {
60254       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
60255       return;
60256     }
60257     catch (std::exception& e)
60258     {
60259       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
60260       return;
60261     }
60262     catch (Dali::DaliException e)
60263     {
60264       SWIG_CSharpException(SWIG_UnknownError, e.condition);
60265       return;
60266     }
60267     catch (...)
60268     {
60269       SWIG_CSharpException(SWIG_UnknownError, "unknown error");
60270       return;
60271     }
60272   }
60273 }
60274
60275 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImageUrl_Get(void* jarg1)
60276 {
60277   char *jresult;
60278   Dali::Toolkit::ImageUrl* imageUrl = (Dali::Toolkit::ImageUrl*) 0;
60279   std::string result;
60280
60281   imageUrl = (Dali::Toolkit::ImageUrl*)jarg1;
60282   {
60283     try
60284     {
60285       result = imageUrl->GetUrl();
60286     }
60287     catch (std::out_of_range& e)
60288     {
60289       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
60290       return 0;
60291     }
60292     catch (std::exception& e)
60293     {
60294       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
60295       return 0;
60296     }
60297     catch (Dali::DaliException e)
60298     {
60299       SWIG_CSharpException(SWIG_UnknownError, e.condition);
60300       return 0;
60301     }
60302     catch (...)
60303     {
60304       SWIG_CSharpException(SWIG_UnknownError, "unknown error");
60305       return 0;
60306     }
60307   }
60308
60309   jresult = SWIG_csharp_string_callback((&result)->c_str());
60310   return jresult;
60311 }
60312
60313 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetSuggestedMinimumWidth(void * jarg1) {
60314   Dali::Actor *arg1 = (Dali::Actor *) 0;
60315   Dali::Vector2 maximumSize;
60316   Dali::Vector2 minimumSize;
60317   Dali::Vector3 naturalSize;
60318   bool widthForHeight;
60319   float result;
60320   {
60321     try {
60322       arg1 = (Dali::Actor *)jarg1;
60323       maximumSize = arg1->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
60324       minimumSize = arg1->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
60325       naturalSize = arg1->GetNaturalSize();
60326       widthForHeight = arg1->GetProperty< bool >( Actor::Property::WIDTH_FOR_HEIGHT );
60327
60328       float baseWidth;
60329       if (widthForHeight)
60330       {
60331         float baseHeight = maximumSize.height > 0 ? std::min(maximumSize.height, naturalSize.height) : naturalSize.height;
60332         baseWidth = arg1->GetWidthForHeight(baseHeight);
60333       }
60334       else
60335       {
60336         baseWidth = naturalSize.width;
60337       }
60338
60339       result = minimumSize.width > 0 ? std::max(baseWidth, minimumSize.width) : baseWidth;
60340       result = maximumSize.width > 0 ? std::min(result, maximumSize.width) : result;
60341     } CALL_CATCH_EXCEPTION(0);
60342   }
60343
60344   return result;
60345 }
60346
60347 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetSuggestedMinimumHeight(void * jarg1) {
60348   Dali::Actor *arg1 = (Dali::Actor *) 0;
60349   Dali::Vector2 maximumSize;
60350   Dali::Vector2 minimumSize;
60351   Dali::Vector3 naturalSize;
60352   bool heightForWidth;
60353   float result;
60354   {
60355     try {
60356       arg1 = (Dali::Actor *)jarg1;
60357       maximumSize = arg1->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
60358       minimumSize = arg1->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
60359       naturalSize = arg1->GetNaturalSize();
60360       heightForWidth = arg1->GetProperty< bool >( Actor::Property::HEIGHT_FOR_WIDTH );
60361
60362       float baseHeight;
60363       if (heightForWidth)
60364       {
60365         float baseWidth = maximumSize.width > 0 ? std::min(maximumSize.width, naturalSize.width) : naturalSize.width;
60366         baseHeight = arg1->GetHeightForWidth(baseWidth);
60367       }
60368       else
60369       {
60370         baseHeight = naturalSize.height;
60371       }
60372
60373       result = minimumSize.height > 0 ? std::max(baseHeight, minimumSize.height) : baseHeight;
60374       result = maximumSize.height > 0 ? std::min(result, maximumSize.height) : result;
60375     } CALL_CATCH_EXCEPTION(0);
60376   }
60377
60378   return result;
60379 }
60380
60381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorVector2_BaseType_get() {
60382   int jresult ;
60383   int result;
60384
60385   result = (int)Dali::Vector< Dali::Vector2 >::BaseType;
60386   jresult = (int)result;
60387   return jresult;
60388 }
60389
60390
60391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorVector2__SWIG_0() {
60392   void * jresult ;
60393   Dali::Vector< Dali::Vector2 > *result = 0 ;
60394
60395   {
60396     try {
60397       result = (Dali::Vector< Dali::Vector2 > *)new Dali::Vector< Dali::Vector2 >();
60398     } CALL_CATCH_EXCEPTION(0);
60399   }
60400
60401   jresult = (void *)result;
60402   return jresult;
60403 }
60404
60405
60406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorVector2(void * jarg1) {
60407   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60408
60409   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60410   {
60411     try {
60412       delete arg1;
60413     } CALL_CATCH_EXCEPTION();
60414   }
60415 }
60416
60417
60418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorVector2__SWIG_1(void * jarg1) {
60419   void * jresult ;
60420   Dali::Vector< Dali::Vector2 > *arg1 = 0 ;
60421   Dali::Vector< Dali::Vector2 > *result = 0 ;
60422
60423   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60424   if (!arg1) {
60425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 > const & type is null", 0);
60426     return 0;
60427   }
60428   {
60429     try {
60430       result = (Dali::Vector< Dali::Vector2 > *)new Dali::Vector< Dali::Vector2 >((Dali::Vector< Dali::Vector2 > const &)*arg1);
60431     } CALL_CATCH_EXCEPTION(0);
60432   }
60433
60434   jresult = (void *)result;
60435   return jresult;
60436 }
60437
60438
60439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Assign(void * jarg1, void * jarg2) {
60440   void * jresult ;
60441   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60442   Dali::Vector< Dali::Vector2 > *arg2 = 0 ;
60443   Dali::Vector< Dali::Vector2 > *result = 0 ;
60444
60445   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60446   arg2 = (Dali::Vector< Dali::Vector2 > *)jarg2;
60447   if (!arg2) {
60448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 > const & type is null", 0);
60449     return 0;
60450   }
60451   {
60452     try {
60453       result = (Dali::Vector< Dali::Vector2 > *) &(arg1)->operator =((Dali::Vector< Dali::Vector2 > const &)*arg2);
60454     } CALL_CATCH_EXCEPTION(0);
60455   }
60456
60457   jresult = (void *)result;
60458   return jresult;
60459 }
60460
60461
60462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Begin(void * jarg1) {
60463   void * jresult ;
60464   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60465   Dali::Vector< Dali::Vector2 >::Iterator result;
60466
60467   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60468   {
60469     try {
60470       result = (Dali::Vector< Dali::Vector2 >::Iterator)((Dali::Vector< Dali::Vector2 > const *)arg1)->Begin();
60471     } CALL_CATCH_EXCEPTION(0);
60472   }
60473
60474   jresult = (void *)result;
60475   return jresult;
60476 }
60477
60478
60479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_End(void * jarg1) {
60480   void * jresult ;
60481   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60482   Dali::Vector< Dali::Vector2 >::Iterator result;
60483
60484   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60485   {
60486     try {
60487       result = (Dali::Vector< Dali::Vector2 >::Iterator)((Dali::Vector< Dali::Vector2 > const *)arg1)->End();
60488     } CALL_CATCH_EXCEPTION(0);
60489   }
60490
60491   jresult = (void *)result;
60492   return jresult;
60493 }
60494
60495
60496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
60497   void * jresult ;
60498   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60499   Dali::Vector< Dali::Vector2 >::SizeType arg2 ;
60500   Dali::Vector< Dali::Vector2 >::ItemType *result = 0 ;
60501
60502   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60503   arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2;
60504   {
60505     try {
60506       result = (Dali::Vector< Dali::Vector2 >::ItemType *) &(arg1)->operator [](arg2);
60507     } CALL_CATCH_EXCEPTION(0);
60508   }
60509
60510   jresult = (void *)result;
60511   return jresult;
60512 }
60513
60514
60515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_PushBack(void * jarg1, void * jarg2) {
60516   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60517   Dali::Vector< Dali::Vector2 >::ItemType *arg2 = 0 ;
60518
60519   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60520   arg2 = (Dali::Vector< Dali::Vector2 >::ItemType *)jarg2;
60521   if (!arg2) {
60522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 >::ItemType const & type is null", 0);
60523     return ;
60524   }
60525   {
60526     try {
60527       (arg1)->PushBack((Dali::Vector< Dali::Vector2 >::ItemType const &)*arg2);
60528     } CALL_CATCH_EXCEPTION();
60529   }
60530 }
60531
60532
60533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
60534   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60535   Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
60536   Dali::Vector< Dali::Vector2 >::ItemType *arg3 = 0 ;
60537
60538   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60539   arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2;
60540   arg3 = (Dali::Vector< Dali::Vector2 >::ItemType *)jarg3;
60541   if (!arg3) {
60542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 >::ItemType const & type is null", 0);
60543     return ;
60544   }
60545   {
60546     try {
60547       (arg1)->Insert(arg2,(Dali::Vector< Dali::Vector2 >::ItemType const &)*arg3);
60548     } CALL_CATCH_EXCEPTION();
60549   }
60550 }
60551
60552
60553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
60554   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60555   Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
60556   Dali::Vector< Dali::Vector2 >::Iterator arg3 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
60557   Dali::Vector< Dali::Vector2 >::Iterator arg4 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
60558
60559   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60560   arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2;
60561   arg3 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg3;
60562   arg4 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg4;
60563   {
60564     try {
60565       (arg1)->Insert(arg2,arg3,arg4);
60566     } CALL_CATCH_EXCEPTION();
60567   }
60568 }
60569
60570
60571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Reserve(void * jarg1, unsigned long jarg2) {
60572   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60573   Dali::Vector< Dali::Vector2 >::SizeType arg2 ;
60574
60575   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60576   arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2;
60577   {
60578     try {
60579       (arg1)->Reserve(arg2);
60580     } CALL_CATCH_EXCEPTION();
60581   }
60582 }
60583
60584
60585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
60586   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60587   Dali::Vector< Dali::Vector2 >::SizeType arg2 ;
60588
60589   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60590   arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2;
60591   {
60592     try {
60593       (arg1)->Resize(arg2);
60594     } CALL_CATCH_EXCEPTION();
60595   }
60596 }
60597
60598
60599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
60600   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60601   Dali::Vector< Dali::Vector2 >::SizeType arg2 ;
60602   Dali::Vector< Dali::Vector2 >::ItemType *arg3 = 0 ;
60603
60604   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60605   arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2;
60606   arg3 = (Dali::Vector< Dali::Vector2 >::ItemType *)jarg3;
60607   if (!arg3) {
60608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
60609     return ;
60610   }
60611   {
60612     try {
60613       (arg1)->Resize(arg2,(Dali::Vector< Dali::Vector2 >::ItemType const &)*arg3);
60614     } CALL_CATCH_EXCEPTION();
60615   }
60616 }
60617
60618
60619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Erase__SWIG_0(void * jarg1, void * jarg2) {
60620   void * jresult ;
60621   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60622   Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
60623   Dali::Vector< Dali::Vector2 >::Iterator result;
60624
60625   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60626   arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2;
60627   {
60628     try {
60629       result = (Dali::Vector< Dali::Vector2 >::Iterator)(arg1)->Erase(arg2);
60630     } CALL_CATCH_EXCEPTION(0);
60631   }
60632
60633   jresult = (void *)result;
60634   return jresult;
60635 }
60636
60637
60638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
60639   void * jresult ;
60640   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60641   Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
60642   Dali::Vector< Dali::Vector2 >::Iterator arg3 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
60643   Dali::Vector< Dali::Vector2 >::Iterator result;
60644
60645   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60646   arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2;
60647   arg3 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg3;
60648   {
60649     try {
60650       result = (Dali::Vector< Dali::Vector2 >::Iterator)(arg1)->Erase(arg2,arg3);
60651     } CALL_CATCH_EXCEPTION(0);
60652   }
60653
60654   jresult = (void *)result;
60655   return jresult;
60656 }
60657
60658
60659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Remove(void * jarg1, void * jarg2) {
60660   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60661   Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
60662
60663   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60664   arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2;
60665   {
60666     try {
60667       (arg1)->Remove(arg2);
60668     } CALL_CATCH_EXCEPTION();
60669   }
60670 }
60671
60672
60673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Swap(void * jarg1, void * jarg2) {
60674   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60675   Dali::Vector< Dali::Vector2 > *arg2 = 0 ;
60676
60677   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60678   arg2 = (Dali::Vector< Dali::Vector2 > *)jarg2;
60679   if (!arg2) {
60680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 > & type is null", 0);
60681     return ;
60682   }
60683   {
60684     try {
60685       (arg1)->Swap(*arg2);
60686     } CALL_CATCH_EXCEPTION();
60687   }
60688 }
60689
60690
60691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Clear(void * jarg1) {
60692   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60693
60694   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60695   {
60696     try {
60697       (arg1)->Clear();
60698     } CALL_CATCH_EXCEPTION();
60699   }
60700 }
60701
60702
60703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Release(void * jarg1) {
60704   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60705
60706   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60707   {
60708     try {
60709       (arg1)->Release();
60710     } CALL_CATCH_EXCEPTION();
60711   }
60712 }
60713
60714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorVector2_Size(void * jarg1) {
60715   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60716   int size;
60717
60718   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60719   {
60720     try {
60721       size = (arg1)->Size();
60722     } CALL_CATCH_EXCEPTION(0);
60723   }
60724
60725   return size;
60726 }
60727
60728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetScreenSize() {
60729   void * jresult ;
60730   int width, height;
60731
60732   try {
60733     Dali::DevelWindowSystem::GetScreenSize(width, height);
60734   } CALL_CATCH_EXCEPTION(0);
60735
60736   jresult = new Dali::Size(width, height);
60737   return jresult;
60738 }
60739
60740 #ifdef __cplusplus
60741 }
60742 #endif
60743