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 = strdup; ///< Use strdup instead of SWIGRegisterStringCallback_NDalic.
 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   // Let we don't use registered string callback. Instead, use strdup. Since 2024-02-21.
 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   void * jwindow  ;
1595
1596   if (!swig_callbackOnCreate) {
1597     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1598     return;
1599   } else {
1600     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1601     swig_callbackOnCreate(contentInfo.c_str(), jwindow);
1602   }
1603 }
1604
1605 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1606   int jtype  ;
1607
1608   if (!swig_callbackOnTerminate) {
1609     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1610     return;
1611   } else {
1612     jtype = (int)type;
1613     swig_callbackOnTerminate(contentInfo.c_str(), jtype);
1614   }
1615 }
1616
1617 void SwigDirector_WidgetImpl::OnPause() {
1618   if (!swig_callbackOnPause) {
1619     Dali::Internal::Adaptor::Widget::OnPause();
1620     return;
1621   } else {
1622     swig_callbackOnPause();
1623   }
1624 }
1625
1626 void SwigDirector_WidgetImpl::OnResume() {
1627   if (!swig_callbackOnResume) {
1628     Dali::Internal::Adaptor::Widget::OnResume();
1629     return;
1630   } else {
1631     swig_callbackOnResume();
1632   }
1633 }
1634
1635 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1636   void * jwindow  ;
1637
1638   if (!swig_callbackOnResize) {
1639     Dali::Internal::Adaptor::Widget::OnResize(window);
1640     return;
1641   } else {
1642     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1643     swig_callbackOnResize(jwindow);
1644   }
1645 }
1646
1647 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1648   int jforce  ;
1649
1650   if (!swig_callbackOnUpdate) {
1651     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1652     return;
1653   } else {
1654     jforce = force;
1655     swig_callbackOnUpdate(contentInfo.c_str(), jforce);
1656   }
1657 }
1658
1659 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1660   void * jslotObserver = 0 ;
1661   void * jcallback = 0 ;
1662
1663   if (!swig_callbackSignalConnected) {
1664     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1665     return;
1666   } else {
1667     jslotObserver = (void *) slotObserver;
1668     jcallback = (void *) callback;
1669     swig_callbackSignalConnected(jslotObserver, jcallback);
1670   }
1671 }
1672
1673 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1674   void * jslotObserver = 0 ;
1675   void * jcallback = 0 ;
1676
1677   if (!swig_callbackSignalDisconnected) {
1678     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1679     return;
1680   } else {
1681     jslotObserver = (void *) slotObserver;
1682     jcallback = (void *) callback;
1683     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1684   }
1685 }
1686
1687 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) {
1688
1689   swig_callbackOnCreate = callbackOnCreate;
1690   swig_callbackOnTerminate = callbackOnTerminate;
1691   swig_callbackOnPause = callbackOnPause;
1692   swig_callbackOnResume = callbackOnResume;
1693   swig_callbackOnResize = callbackOnResize;
1694   swig_callbackOnUpdate = callbackOnUpdate;
1695   swig_callbackSignalConnected = callbackSignalConnected;
1696   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1697 }
1698
1699 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1700   swig_callbackOnCreate = 0;
1701   swig_callbackOnTerminate = 0;
1702   swig_callbackOnPause = 0;
1703   swig_callbackOnResume = 0;
1704   swig_callbackOnResize = 0;
1705   swig_callbackOnUpdate = 0;
1706   swig_callbackSignalConnected = 0;
1707   swig_callbackSignalDisconnected = 0;
1708 }
1709
1710
1711 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1712   swig_init_callbacks();
1713 }
1714
1715 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1716
1717 }
1718
1719
1720 void SwigDirector_ViewImpl::OnSceneConnection(int depth) {
1721   int jdepth  ;
1722
1723   if (!swig_callbackOnSceneConnection) {
1724     Dali::Toolkit::Internal::Control::OnSceneConnection(depth);
1725     return;
1726   } else {
1727     jdepth = depth;
1728     swig_callbackOnSceneConnection(jdepth);
1729   }
1730 }
1731
1732 void SwigDirector_ViewImpl::OnSceneDisconnection() {
1733   if (!swig_callbackOnSceneDisconnection) {
1734     Dali::Toolkit::Internal::Control::OnSceneDisconnection();
1735     return;
1736   } else {
1737     swig_callbackOnSceneDisconnection();
1738   }
1739 }
1740
1741 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1742   void * jchild = 0 ;
1743
1744   if (!swig_callbackOnChildAdd) {
1745     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1746     return;
1747   } else {
1748     jchild = (Dali::Actor *) &child;
1749     swig_callbackOnChildAdd(jchild);
1750   }
1751 }
1752
1753 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1754   void * jchild = 0 ;
1755
1756   if (!swig_callbackOnChildRemove) {
1757     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1758     return;
1759   } else {
1760     jchild = (Dali::Actor *) &child;
1761     swig_callbackOnChildRemove(jchild);
1762   }
1763 }
1764
1765 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, const Dali::Property::Value& propertyValue) {
1766   int jindex  ;
1767   void * jpropertyValue  ;
1768
1769   if (!swig_callbackOnPropertySet) {
1770     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1771     return;
1772   } else {
1773     jindex = index;
1774     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1775     swig_callbackOnPropertySet(jindex, jpropertyValue);
1776   }
1777 }
1778
1779 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1780   void * jtargetSize = 0 ;
1781
1782   if (!swig_callbackOnSizeSet) {
1783     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1784     return;
1785   } else {
1786     jtargetSize = (Dali::Vector3 *) &targetSize;
1787     swig_callbackOnSizeSet(jtargetSize);
1788   }
1789 }
1790
1791 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1792   void * janimation = 0 ;
1793   void * jtargetSize = 0 ;
1794
1795   if (!swig_callbackOnSizeAnimation) {
1796     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1797     return;
1798   } else {
1799     janimation = (Dali::Animation *) &animation;
1800     jtargetSize = (Dali::Vector3 *) &targetSize;
1801     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1802   }
1803 }
1804
1805 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1806   bool c_result = SwigValueInit< bool >() ;
1807   unsigned int jresult = 0 ;
1808   void * jarg0 = 0 ;
1809
1810   if (!swig_callbackOnKeyEvent) {
1811     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1812   } else {
1813     jarg0 = (Dali::KeyEvent *) &event;
1814     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1815     c_result = jresult ? true : false;
1816   }
1817   return c_result;
1818 }
1819
1820 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1821   void * jsize = 0 ;
1822   void * jcontainer = 0 ;
1823
1824   if (!swig_callbackOnRelayout) {
1825     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1826     return;
1827   } else {
1828     jsize = (Dali::Vector2 *) &size;
1829     jcontainer = (Dali::RelayoutContainer *) &container;
1830     swig_callbackOnRelayout(jsize, jcontainer);
1831   }
1832 }
1833
1834 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1835   int jpolicy  ;
1836   int jdimension  ;
1837
1838   if (!swig_callbackOnSetResizePolicy) {
1839     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1840     return;
1841   } else {
1842     jpolicy = (int)policy;
1843     jdimension = (int)dimension;
1844     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1845   }
1846 }
1847
1848 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1849   Dali::Vector3 c_result ;
1850   void * jresult = 0 ;
1851
1852   if (!swig_callbackGetNaturalSize) {
1853     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1854   } else {
1855     jresult = (void *) swig_callbackGetNaturalSize();
1856     if (!jresult) {
1857       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1858       return c_result;
1859     }
1860     c_result = *(Dali::Vector3 *)jresult;
1861   }
1862   return c_result;
1863 }
1864
1865 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1866   float c_result = SwigValueInit< float >() ;
1867   float jresult = 0 ;
1868   void * jchild = 0 ;
1869   int jdimension  ;
1870
1871   if (!swig_callbackCalculateChildSize) {
1872     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1873   } else {
1874     jchild = (Dali::Actor *) &child;
1875     jdimension = (int)dimension;
1876     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1877     c_result = (float)jresult;
1878   }
1879   return c_result;
1880 }
1881
1882 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1883   float c_result = SwigValueInit< float >() ;
1884   float jresult = 0 ;
1885   float jwidth  ;
1886
1887   if (!swig_callbackGetHeightForWidth) {
1888     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1889   } else {
1890     jwidth = width;
1891     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1892     c_result = (float)jresult;
1893   }
1894   return c_result;
1895 }
1896
1897 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1898   float c_result = SwigValueInit< float >() ;
1899   float jresult = 0 ;
1900   float jheight  ;
1901
1902   if (!swig_callbackGetWidthForHeight) {
1903     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1904   } else {
1905     jheight = height;
1906     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1907     c_result = (float)jresult;
1908   }
1909   return c_result;
1910 }
1911
1912 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1913   bool c_result = SwigValueInit< bool >() ;
1914   unsigned int jresult = 0 ;
1915   int jdimension  ;
1916
1917   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1918     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1919   } else {
1920     jdimension = (int)dimension;
1921     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1922     c_result = jresult ? true : false;
1923   }
1924   return c_result;
1925 }
1926
1927 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1928   int jdimension  ;
1929
1930   if (!swig_callbackOnCalculateRelayoutSize) {
1931     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1932     return;
1933   } else {
1934     jdimension = (int)dimension;
1935     swig_callbackOnCalculateRelayoutSize(jdimension);
1936   }
1937 }
1938
1939 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1940   float jsize  ;
1941   int jdimension  ;
1942
1943   if (!swig_callbackOnLayoutNegotiated) {
1944     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
1945     return;
1946   } else {
1947     jsize = size;
1948     jdimension = (int)dimension;
1949     swig_callbackOnLayoutNegotiated(jsize, jdimension);
1950   }
1951 }
1952
1953 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
1954   return Dali::CustomActorImpl::GetExtension();
1955 }
1956
1957 void SwigDirector_ViewImpl::OnInitialize() {
1958   if (!swig_callbackOnInitialize) {
1959     Dali::Toolkit::Internal::Control::OnInitialize();
1960     return;
1961   } else {
1962     swig_callbackOnInitialize();
1963   }
1964 }
1965
1966 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
1967   void * jstyleManager  ;
1968   int jchange  ;
1969
1970   if (!swig_callbackOnStyleChange) {
1971     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
1972     return;
1973   } else {
1974     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
1975     jchange = (int)change;
1976     swig_callbackOnStyleChange(jstyleManager, jchange);
1977   }
1978 }
1979
1980 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
1981   bool c_result = SwigValueInit< bool >() ;
1982   unsigned int jresult = 0 ;
1983
1984   if (!swig_callbackOnAccessibilityActivated) {
1985     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
1986   } else {
1987     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
1988     c_result = jresult ? true : false;
1989   }
1990   return c_result;
1991 }
1992
1993 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
1994   bool c_result = SwigValueInit< bool >() ;
1995   unsigned int jresult = 0 ;
1996   void * jgesture  ;
1997
1998   if (!swig_callbackOnAccessibilityPan) {
1999     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2000   } else {
2001     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2002     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2003     c_result = jresult ? true : false;
2004   }
2005   return c_result;
2006 }
2007
2008 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2009   bool c_result = SwigValueInit< bool >() ;
2010   unsigned int jresult = 0 ;
2011   unsigned int jisIncrease  ;
2012
2013   if (!swig_callbackOnAccessibilityValueChange) {
2014     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2015   } else {
2016     jisIncrease = isIncrease;
2017     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2018     c_result = jresult ? true : false;
2019   }
2020   return c_result;
2021 }
2022
2023 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2024   bool c_result = SwigValueInit< bool >() ;
2025   unsigned int jresult = 0 ;
2026
2027   if (!swig_callbackOnAccessibilityZoom) {
2028     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2029   } else {
2030     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2031     c_result = jresult ? true : false;
2032   }
2033   return c_result;
2034 }
2035
2036 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2037   if (!swig_callbackOnKeyInputFocusGained) {
2038     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2039     return;
2040   } else {
2041     swig_callbackOnKeyInputFocusGained();
2042   }
2043 }
2044
2045 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2046   if (!swig_callbackOnKeyInputFocusLost) {
2047     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2048     return;
2049   } else {
2050     swig_callbackOnKeyInputFocusLost();
2051   }
2052 }
2053
2054
2055 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled)
2056 {
2057   Dali::Actor c_result;
2058   void* jresult = 0;
2059
2060   if(!swig_callbackGetNextKeyboardFocusableActor)
2061   {
2062     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2063   }
2064   else
2065   {
2066     jresult = (void*)swig_callbackGetNextKeyboardFocusableActor((void*)(&currentFocusedActor), (int)direction, loopEnabled);
2067
2068     if(!jresult)
2069     {
2070       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2071       return c_result;
2072     }
2073     c_result = *(Dali::Actor*)jresult;
2074   }
2075   return c_result;
2076 }
2077
2078 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor)
2079 {
2080   if(!swig_callbackOnKeyboardFocusChangeCommitted)
2081   {
2082     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2083     return;
2084   }
2085   else
2086   {
2087     swig_callbackOnKeyboardFocusChangeCommitted((void*)(&commitedFocusableActor));
2088   }
2089 }
2090
2091 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2092   bool c_result = SwigValueInit< bool >() ;
2093   unsigned int jresult = 0 ;
2094
2095   if (!swig_callbackOnKeyboardEnter) {
2096     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2097   } else {
2098     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2099     c_result = jresult ? true : false;
2100   }
2101   return c_result;
2102 }
2103
2104 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2105   void * jpinch = 0 ;
2106
2107   if (!swig_callbackOnPinch) {
2108     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2109     return;
2110   } else {
2111     jpinch = (Dali::PinchGesture *) &pinch;
2112     swig_callbackOnPinch(jpinch);
2113   }
2114 }
2115
2116 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2117   void * jpan = 0 ;
2118
2119   if (!swig_callbackOnPan) {
2120     Dali::Toolkit::Internal::Control::OnPan(pan);
2121     return;
2122   } else {
2123     jpan = (Dali::PanGesture *) &pan;
2124     swig_callbackOnPan(jpan);
2125   }
2126 }
2127
2128 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2129   void * jtap = 0 ;
2130
2131   if (!swig_callbackOnTap) {
2132     Dali::Toolkit::Internal::Control::OnTap(tap);
2133     return;
2134   } else {
2135     jtap = (Dali::TapGesture *) &tap;
2136     swig_callbackOnTap(jtap);
2137   }
2138 }
2139
2140 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2141   void * jlongPress = 0 ;
2142
2143   if (!swig_callbackOnLongPress) {
2144     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2145     return;
2146   } else {
2147     jlongPress = (Dali::LongPressGesture *) &longPress;
2148     swig_callbackOnLongPress(jlongPress);
2149   }
2150 }
2151
2152 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2153   void * jslotObserver = 0 ;
2154   void * jcallback = 0 ;
2155
2156   if (!swig_callbackSignalConnected) {
2157     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2158     return;
2159   } else {
2160     jslotObserver = (void *) slotObserver;
2161     jcallback = (void *) callback;
2162     swig_callbackSignalConnected(jslotObserver, jcallback);
2163   }
2164 }
2165
2166 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2167   void * jslotObserver = 0 ;
2168   void * jcallback = 0 ;
2169
2170   if (!swig_callbackSignalDisconnected) {
2171     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2172     return;
2173   } else {
2174     jslotObserver = (void *) slotObserver;
2175     jcallback = (void *) callback;
2176     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2177   }
2178 }
2179
2180 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2181   return Dali::Toolkit::Internal::Control::GetControlExtension();
2182 }
2183
2184 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) {
2185   swig_callbackOnSceneConnection = callbackOnSceneConnection;
2186   swig_callbackOnSceneDisconnection = callbackOnSceneDisconnection;
2187   swig_callbackOnChildAdd = callbackOnChildAdd;
2188   swig_callbackOnChildRemove = callbackOnChildRemove;
2189   swig_callbackOnPropertySet = callbackOnPropertySet;
2190   swig_callbackOnSizeSet = callbackOnSizeSet;
2191   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2192   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2193   swig_callbackOnRelayout = callbackOnRelayout;
2194   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2195   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2196   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2197   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2198   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2199   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2200   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2201   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2202   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2203   swig_callbackOnInitialize = callbackOnInitialize;
2204   swig_callbackOnStyleChange = callbackOnStyleChange;
2205   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2206   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2207   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2208   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2209   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2210   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2211   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2212   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2213   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2214   swig_callbackOnPinch = callbackOnPinch;
2215   swig_callbackOnPan = callbackOnPan;
2216   swig_callbackOnTap = callbackOnTap;
2217   swig_callbackOnLongPress = callbackOnLongPress;
2218   swig_callbackSignalConnected = callbackSignalConnected;
2219   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2220 }
2221
2222 void SwigDirector_ViewImpl::swig_init_callbacks() {
2223   swig_callbackOnSceneConnection = 0;
2224   swig_callbackOnSceneDisconnection = 0;
2225   swig_callbackOnChildAdd = 0;
2226   swig_callbackOnChildRemove = 0;
2227   swig_callbackOnPropertySet = 0;
2228   swig_callbackOnSizeSet = 0;
2229   swig_callbackOnSizeAnimation = 0;
2230   swig_callbackOnKeyEvent = 0;
2231   swig_callbackOnRelayout = 0;
2232   swig_callbackOnSetResizePolicy = 0;
2233   swig_callbackGetNaturalSize = 0;
2234   swig_callbackCalculateChildSize = 0;
2235   swig_callbackGetHeightForWidth = 0;
2236   swig_callbackGetWidthForHeight = 0;
2237   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2238   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2239   swig_callbackOnCalculateRelayoutSize = 0;
2240   swig_callbackOnLayoutNegotiated = 0;
2241   swig_callbackOnInitialize = 0;
2242   swig_callbackOnStyleChange = 0;
2243   swig_callbackOnAccessibilityActivated = 0;
2244   swig_callbackOnAccessibilityPan = 0;
2245   swig_callbackOnAccessibilityValueChange = 0;
2246   swig_callbackOnAccessibilityZoom = 0;
2247   swig_callbackOnKeyInputFocusGained = 0;
2248   swig_callbackOnKeyInputFocusLost = 0;
2249   swig_callbackGetNextKeyboardFocusableActor = 0;
2250   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2251   swig_callbackOnKeyboardEnter = 0;
2252   swig_callbackOnPinch = 0;
2253   swig_callbackOnPan = 0;
2254   swig_callbackOnTap = 0;
2255   swig_callbackOnLongPress = 0;
2256   swig_callbackSignalConnected = 0;
2257   swig_callbackSignalDisconnected = 0;
2258 }
2259
2260 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2261   swig_init_callbacks();
2262 }
2263
2264 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2265
2266 }
2267
2268
2269 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2270   unsigned int c_result = SwigValueInit< unsigned int >() ;
2271   unsigned int jresult = 0 ;
2272
2273   if (!swig_callbackGetNumberOfItems) {
2274     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2275   } else {
2276     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2277     c_result = (unsigned int)jresult;
2278   }
2279   return c_result;
2280 }
2281
2282 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2283   Dali::Actor c_result ;
2284   void * jresult = 0 ;
2285   unsigned int jitemId  ;
2286
2287   if (!swig_callbackNewItem) {
2288     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2289   } else {
2290     jitemId = itemId;
2291     jresult = (void *) swig_callbackNewItem(jitemId);
2292     if (!jresult) {
2293       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2294       return c_result;
2295     }
2296     c_result = *(Dali::Actor *)jresult;
2297   }
2298   return c_result;
2299 }
2300
2301 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor)
2302 {
2303   if(!swig_callbackItemReleased)
2304   {
2305     Dali::Toolkit::ItemFactory::ItemReleased(itemId, actor);
2306     return;
2307   }
2308   else
2309   {
2310     swig_callbackItemReleased(itemId, (void*)(&actor));
2311   }
2312 }
2313
2314 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2315   return Dali::Toolkit::ItemFactory::GetExtension();
2316 }
2317
2318 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2319   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2320   swig_callbackNewItem = callbackNewItem;
2321   swig_callbackItemReleased = callbackItemReleased;
2322 }
2323
2324 void SwigDirector_ItemFactory::swig_init_callbacks() {
2325   swig_callbackGetNumberOfItems = 0;
2326   swig_callbackNewItem = 0;
2327   swig_callbackItemReleased = 0;
2328 }
2329
2330 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2331   swig_init_callbacks();
2332 }
2333
2334 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2335
2336 }
2337
2338
2339 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction, const std::string& deviceName)
2340 {
2341   Dali::Actor c_result;
2342   void* jresult = 0;
2343
2344   if(!swig_callbackGetNextFocusableActor)
2345   {
2346     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2347   }
2348   else
2349   {
2350     jresult = (void*)swig_callbackGetNextFocusableActor((void*)(&current), (void*)(&proposed), direction, deviceName.c_str());
2351     if(!jresult)
2352     {
2353       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__);
2354       return c_result;
2355     }
2356     c_result = *(Dali::Actor*)jresult;
2357   }
2358   return c_result;
2359 }
2360
2361 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2362   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2363 }
2364
2365 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2366   swig_callbackGetNextFocusableActor = 0;
2367 }
2368
2369 SwigDirector_FrameCallbackInterface::SwigDirector_FrameCallbackInterface() : Dali::FrameCallbackInterface(), Swig::Director() {
2370   swig_callbackOnUpdate = 0;
2371 }
2372
2373 SwigDirector_FrameCallbackInterface::~SwigDirector_FrameCallbackInterface() {
2374
2375 }
2376
2377 void SwigDirector_FrameCallbackInterface::swig_connect_director(SWIG_Callback0_t callbackUpdate) {
2378   swig_callbackOnUpdate = callbackUpdate;
2379 }
2380
2381
2382 void SwigDirector_FrameCallbackInterface::Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) {
2383   void * jcurrent  ;
2384
2385   if (!swig_callbackOnUpdate) {
2386     throw Swig::DirectorPureVirtualException("Dali::FrameCallbackInterface::Update");
2387   } else {
2388     Dali::UpdateProxy* proxy = &updateProxy;
2389     jcurrent = (void *)proxy;
2390     swig_callbackOnUpdate(jcurrent, elapsedSeconds);
2391     if (!jcurrent) {
2392       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::UpdateProxy! ", __FILE__, __LINE__);
2393       return;
2394     }
2395   }
2396   return;
2397 }
2398
2399
2400 #ifdef __cplusplus
2401 extern "C" {
2402 #endif
2403
2404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2405   void * jresult ;
2406   floatp *result = 0 ;
2407
2408   {
2409     try {
2410       result = (floatp *)new_floatp();
2411     } CALL_CATCH_EXCEPTION(0);
2412   }
2413   jresult = (void *)result;
2414   return jresult;
2415 }
2416
2417
2418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2419   floatp *arg1 = (floatp *) 0 ;
2420
2421   arg1 = (floatp *)jarg1;
2422   {
2423     try {
2424       delete_floatp(arg1);
2425     } CALL_CATCH_EXCEPTION();
2426   }
2427
2428 }
2429
2430
2431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2432   floatp *arg1 = (floatp *) 0 ;
2433   float arg2 ;
2434
2435   arg1 = (floatp *)jarg1;
2436   arg2 = (float)jarg2;
2437   {
2438     try {
2439       floatp_assign(arg1,arg2);
2440     } CALL_CATCH_EXCEPTION();
2441   }
2442
2443 }
2444
2445
2446 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2447   float jresult ;
2448   floatp *arg1 = (floatp *) 0 ;
2449   float result;
2450
2451   arg1 = (floatp *)jarg1;
2452   {
2453     try {
2454       result = (float)floatp_value(arg1);
2455     } CALL_CATCH_EXCEPTION(0);
2456   }
2457   jresult = result;
2458   return jresult;
2459 }
2460
2461
2462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2463   void * jresult ;
2464   floatp *arg1 = (floatp *) 0 ;
2465   float *result = 0 ;
2466
2467   arg1 = (floatp *)jarg1;
2468   {
2469     try {
2470       result = (float *)floatp_cast(arg1);
2471     } CALL_CATCH_EXCEPTION(0);
2472   }
2473
2474   jresult = (void *)result;
2475   return jresult;
2476 }
2477
2478
2479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2480   void * jresult ;
2481   float *arg1 = (float *) 0 ;
2482   floatp *result = 0 ;
2483
2484   arg1 = (float *)jarg1;
2485   {
2486     try {
2487       result = (floatp *)floatp_frompointer(arg1);
2488     } CALL_CATCH_EXCEPTION(0);
2489   }
2490
2491   jresult = (void *)result;
2492   return jresult;
2493 }
2494
2495
2496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2497   void * jresult ;
2498   intp *result = 0 ;
2499
2500   {
2501     try {
2502       result = (intp *)new_intp();
2503     } CALL_CATCH_EXCEPTION(0);
2504   }
2505
2506   jresult = (void *)result;
2507   return jresult;
2508 }
2509
2510
2511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2512   intp *arg1 = (intp *) 0 ;
2513
2514   arg1 = (intp *)jarg1;
2515   {
2516     try {
2517       delete_intp(arg1);
2518     } CALL_CATCH_EXCEPTION();
2519   }
2520
2521 }
2522
2523
2524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2525   intp *arg1 = (intp *) 0 ;
2526   int arg2 ;
2527
2528   arg1 = (intp *)jarg1;
2529   arg2 = (int)jarg2;
2530   {
2531     try {
2532       intp_assign(arg1,arg2);
2533     } CALL_CATCH_EXCEPTION();
2534   }
2535
2536 }
2537
2538
2539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2540   int jresult ;
2541   intp *arg1 = (intp *) 0 ;
2542   int result;
2543
2544   arg1 = (intp *)jarg1;
2545   {
2546     try {
2547       result = (int)intp_value(arg1);
2548     } CALL_CATCH_EXCEPTION(0);
2549   }
2550
2551   jresult = result;
2552   return jresult;
2553 }
2554
2555
2556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2557   void * jresult ;
2558   intp *arg1 = (intp *) 0 ;
2559   int *result = 0 ;
2560
2561   arg1 = (intp *)jarg1;
2562   {
2563     try {
2564       result = (int *)intp_cast(arg1);
2565     } CALL_CATCH_EXCEPTION(0);
2566   }
2567
2568   jresult = (void *)result;
2569   return jresult;
2570 }
2571
2572
2573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2574   void * jresult ;
2575   int *arg1 = (int *) 0 ;
2576   intp *result = 0 ;
2577
2578   arg1 = (int *)jarg1;
2579   {
2580     try {
2581       result = (intp *)intp_frompointer(arg1);
2582     } CALL_CATCH_EXCEPTION(0);
2583   }
2584
2585   jresult = (void *)result;
2586   return jresult;
2587 }
2588
2589
2590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2591   void * jresult ;
2592   doublep *result = 0 ;
2593
2594   {
2595     try {
2596       result = (doublep *)new_doublep();
2597     } CALL_CATCH_EXCEPTION(0);
2598   }
2599
2600   jresult = (void *)result;
2601   return jresult;
2602 }
2603
2604
2605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2606   doublep *arg1 = (doublep *) 0 ;
2607
2608   arg1 = (doublep *)jarg1;
2609   {
2610     try {
2611       delete_doublep(arg1);
2612     } CALL_CATCH_EXCEPTION();
2613   }
2614
2615 }
2616
2617
2618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2619   doublep *arg1 = (doublep *) 0 ;
2620   double arg2 ;
2621
2622   arg1 = (doublep *)jarg1;
2623   arg2 = (double)jarg2;
2624   {
2625     try {
2626       doublep_assign(arg1,arg2);
2627     } CALL_CATCH_EXCEPTION();
2628   }
2629
2630 }
2631
2632
2633 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2634   double jresult ;
2635   doublep *arg1 = (doublep *) 0 ;
2636   double result;
2637
2638   arg1 = (doublep *)jarg1;
2639   {
2640     try {
2641       result = (double)doublep_value(arg1);
2642     } CALL_CATCH_EXCEPTION(0);
2643   }
2644
2645   jresult = result;
2646   return jresult;
2647 }
2648
2649
2650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2651   void * jresult ;
2652   doublep *arg1 = (doublep *) 0 ;
2653   double *result = 0 ;
2654
2655   arg1 = (doublep *)jarg1;
2656   {
2657     try {
2658       result = (double *)doublep_cast(arg1);
2659     } CALL_CATCH_EXCEPTION(0);
2660   }
2661
2662   jresult = (void *)result;
2663   return jresult;
2664 }
2665
2666
2667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2668   void * jresult ;
2669   double *arg1 = (double *) 0 ;
2670   doublep *result = 0 ;
2671
2672   arg1 = (double *)jarg1;
2673   {
2674     try {
2675       result = (doublep *)doublep_frompointer(arg1);
2676     } CALL_CATCH_EXCEPTION(0);
2677   }
2678
2679   jresult = (void *)result;
2680   return jresult;
2681 }
2682
2683
2684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2685   void * jresult ;
2686   uintp *result = 0 ;
2687
2688   {
2689     try {
2690       result = (uintp *)new_uintp();
2691     } CALL_CATCH_EXCEPTION(0);
2692   }
2693
2694   jresult = (void *)result;
2695   return jresult;
2696 }
2697
2698
2699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2700   uintp *arg1 = (uintp *) 0 ;
2701
2702   arg1 = (uintp *)jarg1;
2703   {
2704     try {
2705       delete_uintp(arg1);
2706     } CALL_CATCH_EXCEPTION();
2707   }
2708
2709 }
2710
2711
2712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2713   uintp *arg1 = (uintp *) 0 ;
2714   unsigned int arg2 ;
2715
2716   arg1 = (uintp *)jarg1;
2717   arg2 = (unsigned int)jarg2;
2718   {
2719     try {
2720       uintp_assign(arg1,arg2);
2721     } CALL_CATCH_EXCEPTION();
2722   }
2723
2724 }
2725
2726
2727 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
2728   unsigned int jresult ;
2729   uintp *arg1 = (uintp *) 0 ;
2730   unsigned int result;
2731
2732   arg1 = (uintp *)jarg1;
2733   {
2734     try {
2735       result = (unsigned int)uintp_value(arg1);
2736     } CALL_CATCH_EXCEPTION(0);
2737   }
2738
2739   jresult = result;
2740   return jresult;
2741 }
2742
2743
2744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
2745   void * jresult ;
2746   uintp *arg1 = (uintp *) 0 ;
2747   unsigned int *result = 0 ;
2748
2749   arg1 = (uintp *)jarg1;
2750   {
2751     try {
2752       result = (unsigned int *)uintp_cast(arg1);
2753     } CALL_CATCH_EXCEPTION(0);
2754   }
2755
2756   jresult = (void *)result;
2757   return jresult;
2758 }
2759
2760
2761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
2762   void * jresult ;
2763   unsigned int *arg1 = (unsigned int *) 0 ;
2764   uintp *result = 0 ;
2765
2766   arg1 = (unsigned int *)jarg1;
2767   {
2768     try {
2769       result = (uintp *)uintp_frompointer(arg1);
2770     } CALL_CATCH_EXCEPTION(0);
2771   }
2772
2773   jresult = (void *)result;
2774   return jresult;
2775 }
2776
2777
2778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
2779   void * jresult ;
2780   ushortp *result = 0 ;
2781
2782   {
2783     try {
2784       result = (ushortp *)new_ushortp();
2785     } CALL_CATCH_EXCEPTION(0);
2786   }
2787
2788   jresult = (void *)result;
2789   return jresult;
2790 }
2791
2792
2793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
2794   ushortp *arg1 = (ushortp *) 0 ;
2795
2796   arg1 = (ushortp *)jarg1;
2797   {
2798     try {
2799       delete_ushortp(arg1);
2800     } CALL_CATCH_EXCEPTION();
2801   }
2802
2803 }
2804
2805
2806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
2807   ushortp *arg1 = (ushortp *) 0 ;
2808   unsigned short arg2 ;
2809
2810   arg1 = (ushortp *)jarg1;
2811   arg2 = (unsigned short)jarg2;
2812   {
2813     try {
2814       ushortp_assign(arg1,arg2);
2815     } CALL_CATCH_EXCEPTION();
2816   }
2817
2818 }
2819
2820
2821 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
2822   unsigned short jresult ;
2823   ushortp *arg1 = (ushortp *) 0 ;
2824   unsigned short result;
2825
2826   arg1 = (ushortp *)jarg1;
2827   {
2828     try {
2829       result = (unsigned short)ushortp_value(arg1);
2830     } CALL_CATCH_EXCEPTION(0);
2831   }
2832
2833   jresult = result;
2834   return jresult;
2835 }
2836
2837
2838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
2839   void * jresult ;
2840   ushortp *arg1 = (ushortp *) 0 ;
2841   unsigned short *result = 0 ;
2842
2843   arg1 = (ushortp *)jarg1;
2844   {
2845     try {
2846       result = (unsigned short *)ushortp_cast(arg1);
2847     } CALL_CATCH_EXCEPTION(0);
2848   }
2849
2850   jresult = (void *)result;
2851   return jresult;
2852 }
2853
2854
2855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
2856   void * jresult ;
2857   unsigned short *arg1 = (unsigned short *) 0 ;
2858   ushortp *result = 0 ;
2859
2860   arg1 = (unsigned short *)jarg1;
2861   {
2862     try {
2863       result = (ushortp *)ushortp_frompointer(arg1);
2864     } CALL_CATCH_EXCEPTION(0);
2865   }
2866
2867   jresult = (void *)result;
2868   return jresult;
2869 }
2870
2871
2872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
2873   unsigned int jresult ;
2874   int arg1 ;
2875   unsigned int result;
2876
2877   arg1 = (int)jarg1;
2878   {
2879     try {
2880       result = (unsigned int)int_to_uint(arg1);
2881     } CALL_CATCH_EXCEPTION(0);
2882   }
2883
2884   jresult = result;
2885   return jresult;
2886 }
2887
2888
2889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
2890   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
2891
2892   arg1 = (Dali::RefObject *)jarg1;
2893   {
2894     try {
2895       (arg1)->Reference();
2896     } CALL_CATCH_EXCEPTION();
2897   }
2898
2899 }
2900
2901
2902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
2903   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
2904
2905   arg1 = (Dali::RefObject *)jarg1;
2906   {
2907     try {
2908       (arg1)->Unreference();
2909     } CALL_CATCH_EXCEPTION();
2910   }
2911
2912 }
2913
2914
2915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
2916   int jresult ;
2917   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
2918   int result;
2919
2920   arg1 = (Dali::RefObject *)jarg1;
2921   {
2922     try {
2923       result = (int)(arg1)->ReferenceCount();
2924     } CALL_CATCH_EXCEPTION(0);
2925   }
2926
2927   jresult = result;
2928   return jresult;
2929 }
2930
2931
2932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
2933   void * jresult ;
2934   Dali::Any *result = 0 ;
2935
2936   {
2937     try {
2938       result = (Dali::Any *)new Dali::Any();
2939     } CALL_CATCH_EXCEPTION(0);
2940   }
2941
2942   jresult = (void *)result;
2943   return jresult;
2944 }
2945
2946
2947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
2948   Dali::Any *arg1 = (Dali::Any *) 0 ;
2949
2950   arg1 = (Dali::Any *)jarg1;
2951   {
2952     try {
2953       delete arg1;
2954     } CALL_CATCH_EXCEPTION();
2955   }
2956
2957 }
2958
2959
2960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
2961   char *arg1 = (char *) 0 ;
2962
2963   arg1 = (char *)jarg1;
2964   {
2965     try {
2966       Dali::Any::AssertAlways((char const *)arg1);
2967     } CALL_CATCH_EXCEPTION();
2968   }
2969
2970 }
2971
2972
2973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
2974   void * jresult ;
2975   Dali::Any *arg1 = 0 ;
2976   Dali::Any *result = 0 ;
2977
2978   arg1 = (Dali::Any *)jarg1;
2979   if (!arg1) {
2980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
2981     return 0;
2982   }
2983   {
2984     try {
2985       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
2986     } CALL_CATCH_EXCEPTION(0);
2987   }
2988
2989   jresult = (void *)result;
2990   return jresult;
2991 }
2992
2993
2994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
2995   void * jresult ;
2996   Dali::Any *arg1 = (Dali::Any *) 0 ;
2997   Dali::Any *arg2 = 0 ;
2998   Dali::Any *result = 0 ;
2999
3000   arg1 = (Dali::Any *)jarg1;
3001   arg2 = (Dali::Any *)jarg2;
3002   if (!arg2) {
3003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3004     return 0;
3005   }
3006   {
3007     try {
3008       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3009     } CALL_CATCH_EXCEPTION(0);
3010   }
3011
3012   jresult = (void *)result;
3013   return jresult;
3014 }
3015
3016
3017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3018   void * jresult ;
3019   Dali::Any *arg1 = (Dali::Any *) 0 ;
3020   std::type_info *result = 0 ;
3021
3022   arg1 = (Dali::Any *)jarg1;
3023   {
3024     try {
3025       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3026     } CALL_CATCH_EXCEPTION(0);
3027   }
3028
3029   jresult = (void *)result;
3030   return jresult;
3031 }
3032
3033
3034 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3035   bool jresult ;
3036   Dali::Any *arg1 = (Dali::Any *) 0 ;
3037   bool result;
3038
3039   arg1 = (Dali::Any *)jarg1;
3040   {
3041     try {
3042       result = (bool)((Dali::Any const *)arg1)->Empty();
3043     } CALL_CATCH_EXCEPTION(0);
3044   }
3045
3046   jresult = result;
3047   return jresult;
3048 }
3049
3050
3051
3052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3053   char *arg1 = (char *) 0 ;
3054   char *arg2 = (char *) 0 ;
3055
3056   arg1 = (char *)jarg1;
3057   arg2 = (char *)jarg2;
3058   {
3059     try {
3060       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3061     } CALL_CATCH_EXCEPTION();
3062   }
3063
3064 }
3065
3066
3067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3068   void * jresult ;
3069   char *arg1 = (char *) 0 ;
3070   char *arg2 = (char *) 0 ;
3071   Dali::DaliException *result = 0 ;
3072
3073   arg1 = (char *)jarg1;
3074   arg2 = (char *)jarg2;
3075   {
3076     try {
3077       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3078     } CALL_CATCH_EXCEPTION(0);
3079   }
3080
3081   jresult = (void *)result;
3082   return jresult;
3083 }
3084
3085
3086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3087   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3088   std::string arg2 = std::string(jarg2);
3089
3090   arg1 = (Dali::DaliException *)jarg1;
3091   {
3092     if (!arg2.empty()) {
3093       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
3094     } else {
3095       arg1->location = 0;
3096     }
3097   }
3098 }
3099
3100 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3101   char * jresult ;
3102   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3103   char *result = 0 ;
3104
3105   arg1 = (Dali::DaliException *)jarg1;
3106   result = (char *) ((arg1)->location);
3107   jresult = SWIG_csharp_string_callback((const char *)result);
3108   return jresult;
3109 }
3110
3111
3112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3113   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3114   std::string arg2 = std::string(jarg2);
3115
3116   arg1 = (Dali::DaliException *)jarg1;
3117   {
3118     if (!arg2.empty()) {
3119       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
3120     } else {
3121       arg1->condition = 0;
3122     }
3123   }
3124 }
3125
3126
3127 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3128   char * jresult ;
3129   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3130   char *result = 0 ;
3131
3132   arg1 = (Dali::DaliException *)jarg1;
3133   result = (char *) ((arg1)->condition);
3134   jresult = SWIG_csharp_string_callback((const char *)result);
3135   return jresult;
3136 }
3137
3138
3139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3140   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3141
3142   arg1 = (Dali::DaliException *)jarg1;
3143   {
3144     try {
3145       delete arg1;
3146     } CALL_CATCH_EXCEPTION();
3147   }
3148
3149 }
3150
3151
3152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3153   void * jresult ;
3154   Dali::Vector2 *result = 0 ;
3155
3156   {
3157     try {
3158       result = (Dali::Vector2 *)new Dali::Vector2();
3159     } CALL_CATCH_EXCEPTION(0);
3160   }
3161
3162   jresult = (void *)result;
3163   return jresult;
3164 }
3165
3166
3167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3168   void * jresult ;
3169   float arg1 ;
3170   float arg2 ;
3171   Dali::Vector2 *result = 0 ;
3172
3173   arg1 = (float)jarg1;
3174   arg2 = (float)jarg2;
3175   {
3176     try {
3177       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3178     } CALL_CATCH_EXCEPTION(0);
3179   }
3180
3181   jresult = (void *)result;
3182   return jresult;
3183 }
3184
3185
3186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3187   void * jresult ;
3188   float *arg1 = (float *) 0 ;
3189   Dali::Vector2 *result = 0 ;
3190
3191   arg1 = jarg1;
3192   {
3193     try {
3194       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3195     } CALL_CATCH_EXCEPTION(0);
3196   }
3197
3198   jresult = (void *)result;
3199
3200
3201   return jresult;
3202 }
3203
3204
3205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3206   void * jresult ;
3207   Dali::Vector3 *arg1 = 0 ;
3208   Dali::Vector2 *result = 0 ;
3209
3210   arg1 = (Dali::Vector3 *)jarg1;
3211   if (!arg1) {
3212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3213     return 0;
3214   }
3215   {
3216     try {
3217       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3218     } CALL_CATCH_EXCEPTION(0);
3219   }
3220
3221   jresult = (void *)result;
3222   return jresult;
3223 }
3224
3225
3226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
3227   void * jresult ;
3228   Dali::Vector4 *arg1 = 0 ;
3229   Dali::Vector2 *result = 0 ;
3230
3231   arg1 = (Dali::Vector4 *)jarg1;
3232   if (!arg1) {
3233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3234     return 0;
3235   }
3236   {
3237     try {
3238       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3239     } CALL_CATCH_EXCEPTION(0);
3240   }
3241
3242   jresult = (void *)result;
3243   return jresult;
3244 }
3245
3246
3247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
3248   void * jresult ;
3249   Dali::Vector2 *result = 0 ;
3250
3251   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
3252   jresult = (void *)result;
3253   return jresult;
3254 }
3255
3256
3257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
3258   void * jresult ;
3259   Dali::Vector2 *result = 0 ;
3260
3261   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
3262   jresult = (void *)result;
3263   return jresult;
3264 }
3265
3266
3267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
3268   void * jresult ;
3269   Dali::Vector2 *result = 0 ;
3270
3271   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
3272   jresult = (void *)result;
3273   return jresult;
3274 }
3275
3276
3277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
3278   void * jresult ;
3279   Dali::Vector2 *result = 0 ;
3280
3281   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
3282   jresult = (void *)result;
3283   return jresult;
3284 }
3285
3286
3287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
3288   void * jresult ;
3289   Dali::Vector2 *result = 0 ;
3290
3291   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
3292   jresult = (void *)result;
3293   return jresult;
3294 }
3295
3296
3297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
3298   void * jresult ;
3299   Dali::Vector2 *result = 0 ;
3300
3301   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
3302   jresult = (void *)result;
3303   return jresult;
3304 }
3305
3306
3307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
3308   void * jresult ;
3309   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3310   float *arg2 = (float *) 0 ;
3311   Dali::Vector2 *result = 0 ;
3312
3313   arg1 = (Dali::Vector2 *)jarg1;
3314   arg2 = jarg2;
3315   {
3316     try {
3317       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
3318     } CALL_CATCH_EXCEPTION(0);
3319   }
3320
3321   jresult = (void *)result;
3322
3323
3324   return jresult;
3325 }
3326
3327
3328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
3329   void * jresult ;
3330   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3331   Dali::Vector3 *arg2 = 0 ;
3332   Dali::Vector2 *result = 0 ;
3333
3334   arg1 = (Dali::Vector2 *)jarg1;
3335   arg2 = (Dali::Vector3 *)jarg2;
3336   if (!arg2) {
3337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3338     return 0;
3339   }
3340   {
3341     try {
3342       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
3343     } CALL_CATCH_EXCEPTION(0);
3344   }
3345
3346   jresult = (void *)result;
3347   return jresult;
3348 }
3349
3350
3351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
3352   void * jresult ;
3353   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3354   Dali::Vector4 *arg2 = 0 ;
3355   Dali::Vector2 *result = 0 ;
3356
3357   arg1 = (Dali::Vector2 *)jarg1;
3358   arg2 = (Dali::Vector4 *)jarg2;
3359   if (!arg2) {
3360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3361     return 0;
3362   }
3363   {
3364     try {
3365       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
3366     } CALL_CATCH_EXCEPTION(0);
3367   }
3368
3369   jresult = (void *)result;
3370   return jresult;
3371 }
3372
3373
3374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
3375   void * jresult ;
3376   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3377   Dali::Vector2 *arg2 = 0 ;
3378   Dali::Vector2 result;
3379
3380   arg1 = (Dali::Vector2 *)jarg1;
3381   arg2 = (Dali::Vector2 *)jarg2;
3382   if (!arg2) {
3383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3384     return 0;
3385   }
3386   {
3387     try {
3388       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
3389     } CALL_CATCH_EXCEPTION(0);
3390   }
3391
3392   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3393   return jresult;
3394 }
3395
3396
3397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
3398   void * jresult ;
3399   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3400   Dali::Vector2 *arg2 = 0 ;
3401   Dali::Vector2 *result = 0 ;
3402
3403   arg1 = (Dali::Vector2 *)jarg1;
3404   arg2 = (Dali::Vector2 *)jarg2;
3405   if (!arg2) {
3406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3407     return 0;
3408   }
3409   {
3410     try {
3411       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
3412     } CALL_CATCH_EXCEPTION(0);
3413   }
3414
3415   jresult = (void *)result;
3416   return jresult;
3417 }
3418
3419
3420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
3421   void * jresult ;
3422   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3423   Dali::Vector2 *arg2 = 0 ;
3424   Dali::Vector2 result;
3425
3426   arg1 = (Dali::Vector2 *)jarg1;
3427   arg2 = (Dali::Vector2 *)jarg2;
3428   if (!arg2) {
3429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3430     return 0;
3431   }
3432   {
3433     try {
3434       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
3435     } CALL_CATCH_EXCEPTION(0);
3436   }
3437
3438   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3439   return jresult;
3440 }
3441
3442
3443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
3444   void * jresult ;
3445   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3446   Dali::Vector2 *arg2 = 0 ;
3447   Dali::Vector2 *result = 0 ;
3448
3449   arg1 = (Dali::Vector2 *)jarg1;
3450   arg2 = (Dali::Vector2 *)jarg2;
3451   if (!arg2) {
3452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3453     return 0;
3454   }
3455   {
3456     try {
3457       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
3458     } CALL_CATCH_EXCEPTION(0);
3459   }
3460
3461   jresult = (void *)result;
3462   return jresult;
3463 }
3464
3465
3466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
3467   void * jresult ;
3468   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3469   Dali::Vector2 *arg2 = 0 ;
3470   Dali::Vector2 result;
3471
3472   arg1 = (Dali::Vector2 *)jarg1;
3473   arg2 = (Dali::Vector2 *)jarg2;
3474   if (!arg2) {
3475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3476     return 0;
3477   }
3478   {
3479     try {
3480       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
3481     } CALL_CATCH_EXCEPTION(0);
3482   }
3483
3484   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3485   return jresult;
3486 }
3487
3488
3489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
3490   void * jresult ;
3491   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3492   float arg2 ;
3493   Dali::Vector2 result;
3494
3495   arg1 = (Dali::Vector2 *)jarg1;
3496   arg2 = (float)jarg2;
3497   {
3498     try {
3499       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
3500     } CALL_CATCH_EXCEPTION(0);
3501   }
3502
3503   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3504   return jresult;
3505 }
3506
3507
3508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
3509   void * jresult ;
3510   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3511   Dali::Vector2 *arg2 = 0 ;
3512   Dali::Vector2 *result = 0 ;
3513
3514   arg1 = (Dali::Vector2 *)jarg1;
3515   arg2 = (Dali::Vector2 *)jarg2;
3516   if (!arg2) {
3517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3518     return 0;
3519   }
3520   {
3521     try {
3522       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
3523     } CALL_CATCH_EXCEPTION(0);
3524   }
3525
3526   jresult = (void *)result;
3527   return jresult;
3528 }
3529
3530
3531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
3532   void * jresult ;
3533   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3534   float arg2 ;
3535   Dali::Vector2 *result = 0 ;
3536
3537   arg1 = (Dali::Vector2 *)jarg1;
3538   arg2 = (float)jarg2;
3539   {
3540     try {
3541       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
3542     } CALL_CATCH_EXCEPTION(0);
3543   }
3544
3545   jresult = (void *)result;
3546   return jresult;
3547 }
3548
3549
3550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
3551   void * jresult ;
3552   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3553   Dali::Vector2 *arg2 = 0 ;
3554   Dali::Vector2 result;
3555
3556   arg1 = (Dali::Vector2 *)jarg1;
3557   arg2 = (Dali::Vector2 *)jarg2;
3558   if (!arg2) {
3559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3560     return 0;
3561   }
3562   {
3563     try {
3564       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
3565     } CALL_CATCH_EXCEPTION(0);
3566   }
3567
3568   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3569   return jresult;
3570 }
3571
3572
3573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
3574   void * jresult ;
3575   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3576   float arg2 ;
3577   Dali::Vector2 result;
3578
3579   arg1 = (Dali::Vector2 *)jarg1;
3580   arg2 = (float)jarg2;
3581   {
3582     try {
3583       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
3584     } CALL_CATCH_EXCEPTION(0);
3585   }
3586
3587   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3588   return jresult;
3589 }
3590
3591
3592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
3593   void * jresult ;
3594   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3595   Dali::Vector2 *arg2 = 0 ;
3596   Dali::Vector2 *result = 0 ;
3597
3598   arg1 = (Dali::Vector2 *)jarg1;
3599   arg2 = (Dali::Vector2 *)jarg2;
3600   if (!arg2) {
3601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3602     return 0;
3603   }
3604   {
3605     try {
3606       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
3607     } CALL_CATCH_EXCEPTION(0);
3608   }
3609
3610   jresult = (void *)result;
3611   return jresult;
3612 }
3613
3614
3615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
3616   void * jresult ;
3617   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3618   float arg2 ;
3619   Dali::Vector2 *result = 0 ;
3620
3621   arg1 = (Dali::Vector2 *)jarg1;
3622   arg2 = (float)jarg2;
3623   {
3624     try {
3625       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
3626     } CALL_CATCH_EXCEPTION(0);
3627   }
3628
3629   jresult = (void *)result;
3630   return jresult;
3631 }
3632
3633
3634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
3635   void * jresult ;
3636   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3637   Dali::Vector2 result;
3638
3639   arg1 = (Dali::Vector2 *)jarg1;
3640   {
3641     try {
3642       result = ((Dali::Vector2 const *)arg1)->operator -();
3643     } CALL_CATCH_EXCEPTION(0);
3644   }
3645
3646   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3647   return jresult;
3648 }
3649
3650
3651 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
3652   bool jresult ;
3653   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3654   Dali::Vector2 *arg2 = 0 ;
3655   bool result;
3656
3657   arg1 = (Dali::Vector2 *)jarg1;
3658   arg2 = (Dali::Vector2 *)jarg2;
3659   if (!arg2) {
3660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3661     return 0;
3662   }
3663   {
3664     try {
3665       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
3666     } CALL_CATCH_EXCEPTION(0);
3667   }
3668
3669   jresult = result;
3670   return jresult;
3671 }
3672
3673
3674 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
3675   bool jresult ;
3676   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3677   Dali::Vector2 *arg2 = 0 ;
3678   bool result;
3679
3680   arg1 = (Dali::Vector2 *)jarg1;
3681   arg2 = (Dali::Vector2 *)jarg2;
3682   if (!arg2) {
3683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3684     return 0;
3685   }
3686   {
3687     try {
3688       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
3689     } CALL_CATCH_EXCEPTION(0);
3690   }
3691
3692   jresult = result;
3693   return jresult;
3694 }
3695
3696
3697 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
3698   float jresult ;
3699   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3700   unsigned int arg2 ;
3701   float *result = 0 ;
3702
3703   arg1 = (Dali::Vector2 *)jarg1;
3704   arg2 = (unsigned int)jarg2;
3705   {
3706     try {
3707       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
3708     } CALL_CATCH_EXCEPTION(0);
3709   }
3710
3711   jresult = *result;
3712   return jresult;
3713 }
3714
3715
3716 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
3717   float jresult ;
3718   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3719   float result;
3720
3721   arg1 = (Dali::Vector2 *)jarg1;
3722   {
3723     try {
3724       result = (float)((Dali::Vector2 const *)arg1)->Length();
3725     } CALL_CATCH_EXCEPTION(0);
3726   }
3727
3728   jresult = result;
3729   return jresult;
3730 }
3731
3732
3733 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
3734   float jresult ;
3735   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3736   float result;
3737
3738   arg1 = (Dali::Vector2 *)jarg1;
3739   {
3740     try {
3741       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
3742     } CALL_CATCH_EXCEPTION(0);
3743   }
3744
3745   jresult = result;
3746   return jresult;
3747 }
3748
3749
3750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
3751   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3752
3753   arg1 = (Dali::Vector2 *)jarg1;
3754   {
3755     try {
3756       (arg1)->Normalize();
3757     } CALL_CATCH_EXCEPTION();
3758   }
3759
3760 }
3761
3762
3763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
3764   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3765   Dali::Vector2 *arg2 = 0 ;
3766   Dali::Vector2 *arg3 = 0 ;
3767
3768   arg1 = (Dali::Vector2 *)jarg1;
3769   arg2 = (Dali::Vector2 *)jarg2;
3770   if (!arg2) {
3771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3772     return ;
3773   }
3774   arg3 = (Dali::Vector2 *)jarg3;
3775   if (!arg3) {
3776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3777     return ;
3778   }
3779   {
3780     try {
3781       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
3782     } CALL_CATCH_EXCEPTION();
3783   }
3784
3785 }
3786
3787
3788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
3789   void * jresult ;
3790   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3791   float *result = 0 ;
3792
3793   arg1 = (Dali::Vector2 *)jarg1;
3794   {
3795     try {
3796       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
3797     } CALL_CATCH_EXCEPTION(0);
3798   }
3799
3800   jresult = (void *)result;
3801   return jresult;
3802 }
3803
3804
3805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
3806   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3807   float arg2 ;
3808
3809   arg1 = (Dali::Vector2 *)jarg1;
3810   arg2 = (float)jarg2;
3811   if (arg1) (arg1)->x = arg2;
3812 }
3813
3814
3815 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
3816   float jresult ;
3817   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3818   float result;
3819
3820   arg1 = (Dali::Vector2 *)jarg1;
3821   result = (float) ((arg1)->x);
3822   jresult = result;
3823   return jresult;
3824 }
3825
3826
3827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
3828   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3829   float arg2 ;
3830
3831   arg1 = (Dali::Vector2 *)jarg1;
3832   arg2 = (float)jarg2;
3833   if (arg1) (arg1)->width = arg2;
3834 }
3835
3836
3837 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
3838   float jresult ;
3839   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3840   float result;
3841
3842   arg1 = (Dali::Vector2 *)jarg1;
3843   result = (float) ((arg1)->width);
3844   jresult = result;
3845   return jresult;
3846 }
3847
3848
3849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
3850   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3851   float arg2 ;
3852
3853   arg1 = (Dali::Vector2 *)jarg1;
3854   arg2 = (float)jarg2;
3855   if (arg1) (arg1)->y = arg2;
3856 }
3857
3858
3859 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
3860   float jresult ;
3861   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3862   float result;
3863
3864   arg1 = (Dali::Vector2 *)jarg1;
3865   result = (float) ((arg1)->y);
3866   jresult = result;
3867   return jresult;
3868 }
3869
3870
3871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
3872   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3873   float arg2 ;
3874
3875   arg1 = (Dali::Vector2 *)jarg1;
3876   arg2 = (float)jarg2;
3877   if (arg1) (arg1)->height = arg2;
3878 }
3879
3880
3881 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
3882   float jresult ;
3883   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3884   float result;
3885
3886   arg1 = (Dali::Vector2 *)jarg1;
3887   result = (float) ((arg1)->height);
3888   jresult = result;
3889   return jresult;
3890 }
3891
3892
3893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
3894   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3895
3896   arg1 = (Dali::Vector2 *)jarg1;
3897   {
3898     try {
3899       delete arg1;
3900     } CALL_CATCH_EXCEPTION();
3901   }
3902
3903 }
3904
3905
3906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
3907   void * jresult ;
3908   Dali::Vector2 *arg1 = 0 ;
3909   Dali::Vector2 *arg2 = 0 ;
3910   Dali::Vector2 result;
3911
3912   arg1 = (Dali::Vector2 *)jarg1;
3913   if (!arg1) {
3914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3915     return 0;
3916   }
3917   arg2 = (Dali::Vector2 *)jarg2;
3918   if (!arg2) {
3919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3920     return 0;
3921   }
3922   {
3923     try {
3924       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
3925     } CALL_CATCH_EXCEPTION(0);
3926   }
3927
3928   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3929   return jresult;
3930 }
3931
3932
3933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
3934   void * jresult ;
3935   Dali::Vector2 *arg1 = 0 ;
3936   Dali::Vector2 *arg2 = 0 ;
3937   Dali::Vector2 result;
3938
3939   arg1 = (Dali::Vector2 *)jarg1;
3940   if (!arg1) {
3941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3942     return 0;
3943   }
3944   arg2 = (Dali::Vector2 *)jarg2;
3945   if (!arg2) {
3946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3947     return 0;
3948   }
3949   {
3950     try {
3951       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
3952     } CALL_CATCH_EXCEPTION(0);
3953   }
3954
3955   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3956   return jresult;
3957 }
3958
3959
3960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
3961   void * jresult ;
3962   Dali::Vector2 *arg1 = 0 ;
3963   float *arg2 = 0 ;
3964   float *arg3 = 0 ;
3965   float temp2 ;
3966   float temp3 ;
3967   Dali::Vector2 result;
3968
3969   arg1 = (Dali::Vector2 *)jarg1;
3970   if (!arg1) {
3971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3972     return 0;
3973   }
3974   temp2 = (float)jarg2;
3975   arg2 = &temp2;
3976   temp3 = (float)jarg3;
3977   arg3 = &temp3;
3978   {
3979     try {
3980       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
3981     } CALL_CATCH_EXCEPTION(0);
3982   }
3983
3984   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3985   return jresult;
3986 }
3987
3988
3989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
3990   void * jresult ;
3991   Dali::Vector3 *result = 0 ;
3992
3993   {
3994     try {
3995       result = (Dali::Vector3 *)new Dali::Vector3();
3996     } CALL_CATCH_EXCEPTION(0);
3997   }
3998
3999   jresult = (void *)result;
4000   return jresult;
4001 }
4002
4003
4004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
4005   void * jresult ;
4006   float arg1 ;
4007   float arg2 ;
4008   float arg3 ;
4009   Dali::Vector3 *result = 0 ;
4010
4011   arg1 = (float)jarg1;
4012   arg2 = (float)jarg2;
4013   arg3 = (float)jarg3;
4014   {
4015     try {
4016       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
4017     } CALL_CATCH_EXCEPTION(0);
4018   }
4019
4020   jresult = (void *)result;
4021   return jresult;
4022 }
4023
4024
4025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
4026   void * jresult ;
4027   float *arg1 = (float *) 0 ;
4028   Dali::Vector3 *result = 0 ;
4029
4030   arg1 = jarg1;
4031   {
4032     try {
4033       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
4034     } CALL_CATCH_EXCEPTION(0);
4035   }
4036
4037   jresult = (void *)result;
4038
4039
4040   return jresult;
4041 }
4042
4043
4044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
4045   void * jresult ;
4046   Dali::Vector2 *arg1 = 0 ;
4047   Dali::Vector3 *result = 0 ;
4048
4049   arg1 = (Dali::Vector2 *)jarg1;
4050   if (!arg1) {
4051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4052     return 0;
4053   }
4054   {
4055     try {
4056       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
4057     } CALL_CATCH_EXCEPTION(0);
4058   }
4059
4060   jresult = (void *)result;
4061   return jresult;
4062 }
4063
4064
4065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
4066   void * jresult ;
4067   Dali::Vector4 *arg1 = 0 ;
4068   Dali::Vector3 *result = 0 ;
4069
4070   arg1 = (Dali::Vector4 *)jarg1;
4071   if (!arg1) {
4072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4073     return 0;
4074   }
4075   {
4076     try {
4077       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
4078     } CALL_CATCH_EXCEPTION(0);
4079   }
4080
4081   jresult = (void *)result;
4082   return jresult;
4083 }
4084
4085
4086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
4087   void * jresult ;
4088   Dali::Vector3 *result = 0 ;
4089
4090   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
4091   jresult = (void *)result;
4092   return jresult;
4093 }
4094
4095
4096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
4097   void * jresult ;
4098   Dali::Vector3 *result = 0 ;
4099
4100   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
4101   jresult = (void *)result;
4102   return jresult;
4103 }
4104
4105
4106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
4107   void * jresult ;
4108   Dali::Vector3 *result = 0 ;
4109
4110   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
4111   jresult = (void *)result;
4112   return jresult;
4113 }
4114
4115
4116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
4117   void * jresult ;
4118   Dali::Vector3 *result = 0 ;
4119
4120   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
4121   jresult = (void *)result;
4122   return jresult;
4123 }
4124
4125
4126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
4127   void * jresult ;
4128   Dali::Vector3 *result = 0 ;
4129
4130   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
4131   jresult = (void *)result;
4132   return jresult;
4133 }
4134
4135
4136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
4137   void * jresult ;
4138   Dali::Vector3 *result = 0 ;
4139
4140   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
4141   jresult = (void *)result;
4142   return jresult;
4143 }
4144
4145
4146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
4147   void * jresult ;
4148   Dali::Vector3 *result = 0 ;
4149
4150   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
4151   jresult = (void *)result;
4152   return jresult;
4153 }
4154
4155
4156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
4157   void * jresult ;
4158   Dali::Vector3 *result = 0 ;
4159
4160   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
4161   jresult = (void *)result;
4162   return jresult;
4163 }
4164
4165
4166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
4167   void * jresult ;
4168   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4169   float *arg2 = (float *) 0 ;
4170   Dali::Vector3 *result = 0 ;
4171
4172   arg1 = (Dali::Vector3 *)jarg1;
4173   arg2 = jarg2;
4174   {
4175     try {
4176       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
4177     } CALL_CATCH_EXCEPTION(0);
4178   }
4179
4180   jresult = (void *)result;
4181
4182
4183   return jresult;
4184 }
4185
4186
4187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
4188   void * jresult ;
4189   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4190   Dali::Vector2 *arg2 = 0 ;
4191   Dali::Vector3 *result = 0 ;
4192
4193   arg1 = (Dali::Vector3 *)jarg1;
4194   arg2 = (Dali::Vector2 *)jarg2;
4195   if (!arg2) {
4196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4197     return 0;
4198   }
4199   {
4200     try {
4201       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
4202     } CALL_CATCH_EXCEPTION(0);
4203   }
4204
4205   jresult = (void *)result;
4206   return jresult;
4207 }
4208
4209
4210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
4211   void * jresult ;
4212   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4213   Dali::Vector4 *arg2 = 0 ;
4214   Dali::Vector3 *result = 0 ;
4215
4216   arg1 = (Dali::Vector3 *)jarg1;
4217   arg2 = (Dali::Vector4 *)jarg2;
4218   if (!arg2) {
4219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4220     return 0;
4221   }
4222   {
4223     try {
4224       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4225     } CALL_CATCH_EXCEPTION(0);
4226   }
4227
4228   jresult = (void *)result;
4229   return jresult;
4230 }
4231
4232
4233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
4234   void * jresult ;
4235   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4236   Dali::Vector3 *arg2 = 0 ;
4237   Dali::Vector3 result;
4238
4239   arg1 = (Dali::Vector3 *)jarg1;
4240   arg2 = (Dali::Vector3 *)jarg2;
4241   if (!arg2) {
4242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4243     return 0;
4244   }
4245   {
4246     try {
4247       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
4248     } CALL_CATCH_EXCEPTION(0);
4249   }
4250
4251   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4252   return jresult;
4253 }
4254
4255
4256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
4257   void * jresult ;
4258   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4259   Dali::Vector3 *arg2 = 0 ;
4260   Dali::Vector3 *result = 0 ;
4261
4262   arg1 = (Dali::Vector3 *)jarg1;
4263   arg2 = (Dali::Vector3 *)jarg2;
4264   if (!arg2) {
4265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4266     return 0;
4267   }
4268   {
4269     try {
4270       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
4271     } CALL_CATCH_EXCEPTION(0);
4272   }
4273
4274   jresult = (void *)result;
4275   return jresult;
4276 }
4277
4278
4279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4280   void * jresult ;
4281   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4282   Dali::Vector3 *arg2 = 0 ;
4283   Dali::Vector3 result;
4284
4285   arg1 = (Dali::Vector3 *)jarg1;
4286   arg2 = (Dali::Vector3 *)jarg2;
4287   if (!arg2) {
4288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4289     return 0;
4290   }
4291   {
4292     try {
4293       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
4294     } CALL_CATCH_EXCEPTION(0);
4295   }
4296
4297   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4298   return jresult;
4299 }
4300
4301
4302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
4303   void * jresult ;
4304   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4305   Dali::Vector3 *arg2 = 0 ;
4306   Dali::Vector3 *result = 0 ;
4307
4308   arg1 = (Dali::Vector3 *)jarg1;
4309   arg2 = (Dali::Vector3 *)jarg2;
4310   if (!arg2) {
4311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4312     return 0;
4313   }
4314   {
4315     try {
4316       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
4317     } CALL_CATCH_EXCEPTION(0);
4318   }
4319
4320   jresult = (void *)result;
4321   return jresult;
4322 }
4323
4324
4325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4326   void * jresult ;
4327   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4328   Dali::Vector3 *arg2 = 0 ;
4329   Dali::Vector3 result;
4330
4331   arg1 = (Dali::Vector3 *)jarg1;
4332   arg2 = (Dali::Vector3 *)jarg2;
4333   if (!arg2) {
4334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4335     return 0;
4336   }
4337   {
4338     try {
4339       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
4340     } CALL_CATCH_EXCEPTION(0);
4341   }
4342
4343   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4344   return jresult;
4345 }
4346
4347
4348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
4349   void * jresult ;
4350   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4351   float arg2 ;
4352   Dali::Vector3 result;
4353
4354   arg1 = (Dali::Vector3 *)jarg1;
4355   arg2 = (float)jarg2;
4356   {
4357     try {
4358       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
4359     } CALL_CATCH_EXCEPTION(0);
4360   }
4361
4362   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4363   return jresult;
4364 }
4365
4366
4367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4368   void * jresult ;
4369   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4370   Dali::Vector3 *arg2 = 0 ;
4371   Dali::Vector3 *result = 0 ;
4372
4373   arg1 = (Dali::Vector3 *)jarg1;
4374   arg2 = (Dali::Vector3 *)jarg2;
4375   if (!arg2) {
4376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4377     return 0;
4378   }
4379   {
4380     try {
4381       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
4382     } CALL_CATCH_EXCEPTION(0);
4383   }
4384
4385   jresult = (void *)result;
4386   return jresult;
4387 }
4388
4389
4390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4391   void * jresult ;
4392   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4393   float arg2 ;
4394   Dali::Vector3 *result = 0 ;
4395
4396   arg1 = (Dali::Vector3 *)jarg1;
4397   arg2 = (float)jarg2;
4398   {
4399     try {
4400       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
4401     } CALL_CATCH_EXCEPTION(0);
4402   }
4403
4404   jresult = (void *)result;
4405   return jresult;
4406 }
4407
4408
4409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
4410   void * jresult ;
4411   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4412   Dali::Quaternion *arg2 = 0 ;
4413   Dali::Vector3 *result = 0 ;
4414
4415   arg1 = (Dali::Vector3 *)jarg1;
4416   arg2 = (Dali::Quaternion *)jarg2;
4417   if (!arg2) {
4418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
4419     return 0;
4420   }
4421   {
4422     try {
4423       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
4424     } CALL_CATCH_EXCEPTION(0);
4425   }
4426
4427   jresult = (void *)result;
4428   return jresult;
4429 }
4430
4431
4432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
4433   void * jresult ;
4434   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4435   Dali::Vector3 *arg2 = 0 ;
4436   Dali::Vector3 result;
4437
4438   arg1 = (Dali::Vector3 *)jarg1;
4439   arg2 = (Dali::Vector3 *)jarg2;
4440   if (!arg2) {
4441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4442     return 0;
4443   }
4444   {
4445     try {
4446       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
4447     } CALL_CATCH_EXCEPTION(0);
4448   }
4449
4450   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4451   return jresult;
4452 }
4453
4454
4455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
4456   void * jresult ;
4457   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4458   float arg2 ;
4459   Dali::Vector3 result;
4460
4461   arg1 = (Dali::Vector3 *)jarg1;
4462   arg2 = (float)jarg2;
4463   {
4464     try {
4465       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
4466     } CALL_CATCH_EXCEPTION(0);
4467   }
4468
4469   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4470   return jresult;
4471 }
4472
4473
4474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4475   void * jresult ;
4476   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4477   Dali::Vector3 *arg2 = 0 ;
4478   Dali::Vector3 *result = 0 ;
4479
4480   arg1 = (Dali::Vector3 *)jarg1;
4481   arg2 = (Dali::Vector3 *)jarg2;
4482   if (!arg2) {
4483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4484     return 0;
4485   }
4486   {
4487     try {
4488       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
4489     } CALL_CATCH_EXCEPTION(0);
4490   }
4491
4492   jresult = (void *)result;
4493   return jresult;
4494 }
4495
4496
4497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4498   void * jresult ;
4499   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4500   float arg2 ;
4501   Dali::Vector3 *result = 0 ;
4502
4503   arg1 = (Dali::Vector3 *)jarg1;
4504   arg2 = (float)jarg2;
4505   {
4506     try {
4507       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
4508     } CALL_CATCH_EXCEPTION(0);
4509   }
4510
4511   jresult = (void *)result;
4512   return jresult;
4513 }
4514
4515
4516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
4517   void * jresult ;
4518   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4519   Dali::Vector3 result;
4520
4521   arg1 = (Dali::Vector3 *)jarg1;
4522   {
4523     try {
4524       result = ((Dali::Vector3 const *)arg1)->operator -();
4525     } CALL_CATCH_EXCEPTION(0);
4526   }
4527
4528   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4529   return jresult;
4530 }
4531
4532
4533 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
4534   bool jresult ;
4535   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4536   Dali::Vector3 *arg2 = 0 ;
4537   bool result;
4538
4539   arg1 = (Dali::Vector3 *)jarg1;
4540   arg2 = (Dali::Vector3 *)jarg2;
4541   if (!arg2) {
4542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4543     return 0;
4544   }
4545   {
4546     try {
4547       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
4548     } CALL_CATCH_EXCEPTION(0);
4549   }
4550
4551   jresult = result;
4552   return jresult;
4553 }
4554
4555
4556 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
4557   bool jresult ;
4558   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4559   Dali::Vector3 *arg2 = 0 ;
4560   bool result;
4561
4562   arg1 = (Dali::Vector3 *)jarg1;
4563   arg2 = (Dali::Vector3 *)jarg2;
4564   if (!arg2) {
4565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4566     return 0;
4567   }
4568   {
4569     try {
4570       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
4571     } CALL_CATCH_EXCEPTION(0);
4572   }
4573
4574   jresult = result;
4575   return jresult;
4576 }
4577
4578
4579 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4580   float jresult ;
4581   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4582   unsigned int arg2 ;
4583   float *result = 0 ;
4584
4585   arg1 = (Dali::Vector3 *)jarg1;
4586   arg2 = (unsigned int)jarg2;
4587   {
4588     try {
4589       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
4590     } CALL_CATCH_EXCEPTION(0);
4591   }
4592
4593   jresult = *result;
4594   return jresult;
4595 }
4596
4597
4598 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
4599   float jresult ;
4600   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4601   Dali::Vector3 *arg2 = 0 ;
4602   float result;
4603
4604   arg1 = (Dali::Vector3 *)jarg1;
4605   arg2 = (Dali::Vector3 *)jarg2;
4606   if (!arg2) {
4607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4608     return 0;
4609   }
4610   {
4611     try {
4612       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
4613     } CALL_CATCH_EXCEPTION(0);
4614   }
4615
4616   jresult = result;
4617   return jresult;
4618 }
4619
4620
4621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
4622   void * jresult ;
4623   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4624   Dali::Vector3 *arg2 = 0 ;
4625   Dali::Vector3 result;
4626
4627   arg1 = (Dali::Vector3 *)jarg1;
4628   arg2 = (Dali::Vector3 *)jarg2;
4629   if (!arg2) {
4630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4631     return 0;
4632   }
4633   {
4634     try {
4635       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
4636     } CALL_CATCH_EXCEPTION(0);
4637   }
4638
4639   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4640   return jresult;
4641 }
4642
4643
4644 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
4645   float jresult ;
4646   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4647   float result;
4648
4649   arg1 = (Dali::Vector3 *)jarg1;
4650   {
4651     try {
4652       result = (float)((Dali::Vector3 const *)arg1)->Length();
4653     } CALL_CATCH_EXCEPTION(0);
4654   }
4655
4656   jresult = result;
4657   return jresult;
4658 }
4659
4660
4661 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
4662   float jresult ;
4663   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4664   float result;
4665
4666   arg1 = (Dali::Vector3 *)jarg1;
4667   {
4668     try {
4669       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
4670     } CALL_CATCH_EXCEPTION(0);
4671   }
4672
4673   jresult = result;
4674   return jresult;
4675 }
4676
4677
4678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
4679   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4680
4681   arg1 = (Dali::Vector3 *)jarg1;
4682   {
4683     try {
4684       (arg1)->Normalize();
4685     } CALL_CATCH_EXCEPTION();
4686   }
4687
4688 }
4689
4690
4691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4692   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4693   Dali::Vector3 *arg2 = 0 ;
4694   Dali::Vector3 *arg3 = 0 ;
4695
4696   arg1 = (Dali::Vector3 *)jarg1;
4697   arg2 = (Dali::Vector3 *)jarg2;
4698   if (!arg2) {
4699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4700     return ;
4701   }
4702   arg3 = (Dali::Vector3 *)jarg3;
4703   if (!arg3) {
4704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4705     return ;
4706   }
4707   {
4708     try {
4709       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
4710     } CALL_CATCH_EXCEPTION();
4711   }
4712
4713 }
4714
4715
4716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
4717   void * jresult ;
4718   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4719   float *result = 0 ;
4720
4721   arg1 = (Dali::Vector3 *)jarg1;
4722   {
4723     try {
4724       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
4725     } CALL_CATCH_EXCEPTION(0);
4726   }
4727
4728   jresult = (void *)result;
4729   return jresult;
4730 }
4731
4732
4733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
4734   void * jresult ;
4735   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4736   Dali::Vector2 *result = 0 ;
4737
4738   arg1 = (Dali::Vector3 *)jarg1;
4739   {
4740     try {
4741       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
4742     } CALL_CATCH_EXCEPTION(0);
4743   }
4744
4745   jresult = (void *)result;
4746   return jresult;
4747 }
4748
4749
4750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
4751   void * jresult ;
4752   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4753   Dali::Vector2 *result = 0 ;
4754
4755   arg1 = (Dali::Vector3 *)jarg1;
4756   {
4757     try {
4758       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
4759     } CALL_CATCH_EXCEPTION(0);
4760   }
4761
4762   jresult = (void *)result;
4763   return jresult;
4764 }
4765
4766
4767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
4768   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4769   float arg2 ;
4770
4771   arg1 = (Dali::Vector3 *)jarg1;
4772   arg2 = (float)jarg2;
4773   if (arg1) (arg1)->x = arg2;
4774 }
4775
4776
4777 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
4778   float jresult ;
4779   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4780   float result;
4781
4782   arg1 = (Dali::Vector3 *)jarg1;
4783   result = (float) ((arg1)->x);
4784   jresult = result;
4785   return jresult;
4786 }
4787
4788
4789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
4790   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4791   float arg2 ;
4792
4793   arg1 = (Dali::Vector3 *)jarg1;
4794   arg2 = (float)jarg2;
4795   if (arg1) (arg1)->width = arg2;
4796 }
4797
4798
4799 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
4800   float jresult ;
4801   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4802   float result;
4803
4804   arg1 = (Dali::Vector3 *)jarg1;
4805   result = (float) ((arg1)->width);
4806   jresult = result;
4807   return jresult;
4808 }
4809
4810
4811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
4812   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4813   float arg2 ;
4814
4815   arg1 = (Dali::Vector3 *)jarg1;
4816   arg2 = (float)jarg2;
4817   if (arg1) (arg1)->r = arg2;
4818 }
4819
4820
4821 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
4822   float jresult ;
4823   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4824   float result;
4825
4826   arg1 = (Dali::Vector3 *)jarg1;
4827   result = (float) ((arg1)->r);
4828   jresult = result;
4829   return jresult;
4830 }
4831
4832
4833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
4834   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4835   float arg2 ;
4836
4837   arg1 = (Dali::Vector3 *)jarg1;
4838   arg2 = (float)jarg2;
4839   if (arg1) (arg1)->y = arg2;
4840 }
4841
4842
4843 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
4844   float jresult ;
4845   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4846   float result;
4847
4848   arg1 = (Dali::Vector3 *)jarg1;
4849   result = (float) ((arg1)->y);
4850   jresult = result;
4851   return jresult;
4852 }
4853
4854
4855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
4856   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4857   float arg2 ;
4858
4859   arg1 = (Dali::Vector3 *)jarg1;
4860   arg2 = (float)jarg2;
4861   if (arg1) (arg1)->height = arg2;
4862 }
4863
4864
4865 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
4866   float jresult ;
4867   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4868   float result;
4869
4870   arg1 = (Dali::Vector3 *)jarg1;
4871   result = (float) ((arg1)->height);
4872   jresult = result;
4873   return jresult;
4874 }
4875
4876
4877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
4878   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4879   float arg2 ;
4880
4881   arg1 = (Dali::Vector3 *)jarg1;
4882   arg2 = (float)jarg2;
4883   if (arg1) (arg1)->g = arg2;
4884 }
4885
4886
4887 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
4888   float jresult ;
4889   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4890   float result;
4891
4892   arg1 = (Dali::Vector3 *)jarg1;
4893   result = (float) ((arg1)->g);
4894   jresult = result;
4895   return jresult;
4896 }
4897
4898
4899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
4900   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4901   float arg2 ;
4902
4903   arg1 = (Dali::Vector3 *)jarg1;
4904   arg2 = (float)jarg2;
4905   if (arg1) (arg1)->z = arg2;
4906 }
4907
4908
4909 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
4910   float jresult ;
4911   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4912   float result;
4913
4914   arg1 = (Dali::Vector3 *)jarg1;
4915   result = (float) ((arg1)->z);
4916   jresult = result;
4917   return jresult;
4918 }
4919
4920
4921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
4922   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4923   float arg2 ;
4924
4925   arg1 = (Dali::Vector3 *)jarg1;
4926   arg2 = (float)jarg2;
4927   if (arg1) (arg1)->depth = arg2;
4928 }
4929
4930
4931 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
4932   float jresult ;
4933   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4934   float result;
4935
4936   arg1 = (Dali::Vector3 *)jarg1;
4937   result = (float) ((arg1)->depth);
4938   jresult = result;
4939   return jresult;
4940 }
4941
4942
4943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
4944   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4945   float arg2 ;
4946
4947   arg1 = (Dali::Vector3 *)jarg1;
4948   arg2 = (float)jarg2;
4949   if (arg1) (arg1)->b = arg2;
4950 }
4951
4952
4953 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
4954   float jresult ;
4955   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4956   float result;
4957
4958   arg1 = (Dali::Vector3 *)jarg1;
4959   result = (float) ((arg1)->b);
4960   jresult = result;
4961   return jresult;
4962 }
4963
4964
4965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
4966   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4967
4968   arg1 = (Dali::Vector3 *)jarg1;
4969   {
4970     try {
4971       delete arg1;
4972     } CALL_CATCH_EXCEPTION();
4973   }
4974
4975 }
4976
4977
4978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
4979   void * jresult ;
4980   Dali::Vector3 *arg1 = 0 ;
4981   Dali::Vector3 *arg2 = 0 ;
4982   Dali::Vector3 result;
4983
4984   arg1 = (Dali::Vector3 *)jarg1;
4985   if (!arg1) {
4986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4987     return 0;
4988   }
4989   arg2 = (Dali::Vector3 *)jarg2;
4990   if (!arg2) {
4991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4992     return 0;
4993   }
4994   {
4995     try {
4996       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
4997     } CALL_CATCH_EXCEPTION(0);
4998   }
4999
5000   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5001   return jresult;
5002 }
5003
5004
5005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
5006   void * jresult ;
5007   Dali::Vector3 *arg1 = 0 ;
5008   Dali::Vector3 *arg2 = 0 ;
5009   Dali::Vector3 result;
5010
5011   arg1 = (Dali::Vector3 *)jarg1;
5012   if (!arg1) {
5013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5014     return 0;
5015   }
5016   arg2 = (Dali::Vector3 *)jarg2;
5017   if (!arg2) {
5018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5019     return 0;
5020   }
5021   {
5022     try {
5023       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
5024     } CALL_CATCH_EXCEPTION(0);
5025   }
5026
5027   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5028   return jresult;
5029 }
5030
5031
5032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
5033   void * jresult ;
5034   Dali::Vector3 *arg1 = 0 ;
5035   float *arg2 = 0 ;
5036   float *arg3 = 0 ;
5037   float temp2 ;
5038   float temp3 ;
5039   Dali::Vector3 result;
5040
5041   arg1 = (Dali::Vector3 *)jarg1;
5042   if (!arg1) {
5043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5044     return 0;
5045   }
5046   temp2 = (float)jarg2;
5047   arg2 = &temp2;
5048   temp3 = (float)jarg3;
5049   arg3 = &temp3;
5050   {
5051     try {
5052       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5053     } CALL_CATCH_EXCEPTION(0);
5054   }
5055
5056   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5057   return jresult;
5058 }
5059
5060
5061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
5062   void * jresult ;
5063   Dali::Vector4 *result = 0 ;
5064
5065   {
5066     try {
5067       result = (Dali::Vector4 *)new Dali::Vector4();
5068     } CALL_CATCH_EXCEPTION(0);
5069   }
5070
5071   jresult = (void *)result;
5072   return jresult;
5073 }
5074
5075
5076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
5077   void * jresult ;
5078   float arg1 ;
5079   float arg2 ;
5080   float arg3 ;
5081   float arg4 ;
5082   Dali::Vector4 *result = 0 ;
5083
5084   arg1 = (float)jarg1;
5085   arg2 = (float)jarg2;
5086   arg3 = (float)jarg3;
5087   arg4 = (float)jarg4;
5088   {
5089     try {
5090       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
5091     } CALL_CATCH_EXCEPTION(0);
5092   }
5093
5094   jresult = (void *)result;
5095   return jresult;
5096 }
5097
5098
5099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
5100   void * jresult ;
5101   float *arg1 = (float *) 0 ;
5102   Dali::Vector4 *result = 0 ;
5103
5104   arg1 = jarg1;
5105   {
5106     try {
5107       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
5108     } CALL_CATCH_EXCEPTION(0);
5109   }
5110
5111   jresult = (void *)result;
5112
5113
5114   return jresult;
5115 }
5116
5117
5118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
5119   void * jresult ;
5120   Dali::Vector2 *arg1 = 0 ;
5121   Dali::Vector4 *result = 0 ;
5122
5123   arg1 = (Dali::Vector2 *)jarg1;
5124   if (!arg1) {
5125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5126     return 0;
5127   }
5128   {
5129     try {
5130       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
5131     } CALL_CATCH_EXCEPTION(0);
5132   }
5133
5134   jresult = (void *)result;
5135   return jresult;
5136 }
5137
5138
5139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
5140   void * jresult ;
5141   Dali::Vector3 *arg1 = 0 ;
5142   Dali::Vector4 *result = 0 ;
5143
5144   arg1 = (Dali::Vector3 *)jarg1;
5145   if (!arg1) {
5146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5147     return 0;
5148   }
5149   {
5150     try {
5151       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
5152     } CALL_CATCH_EXCEPTION(0);
5153   }
5154
5155   jresult = (void *)result;
5156   return jresult;
5157 }
5158
5159
5160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
5161   void * jresult ;
5162   Dali::Vector4 *result = 0 ;
5163
5164   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
5165   jresult = (void *)result;
5166   return jresult;
5167 }
5168
5169
5170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
5171   void * jresult ;
5172   Dali::Vector4 *result = 0 ;
5173
5174   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
5175   jresult = (void *)result;
5176   return jresult;
5177 }
5178
5179
5180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
5181   void * jresult ;
5182   Dali::Vector4 *result = 0 ;
5183
5184   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
5185   jresult = (void *)result;
5186   return jresult;
5187 }
5188
5189
5190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
5191   void * jresult ;
5192   Dali::Vector4 *result = 0 ;
5193
5194   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
5195   jresult = (void *)result;
5196   return jresult;
5197 }
5198
5199
5200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
5201   void * jresult ;
5202   Dali::Vector4 *result = 0 ;
5203
5204   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
5205   jresult = (void *)result;
5206   return jresult;
5207 }
5208
5209
5210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
5211   void * jresult ;
5212   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5213   float *arg2 = (float *) 0 ;
5214   Dali::Vector4 *result = 0 ;
5215
5216   arg1 = (Dali::Vector4 *)jarg1;
5217   arg2 = jarg2;
5218   {
5219     try {
5220       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
5221     } CALL_CATCH_EXCEPTION(0);
5222   }
5223
5224   jresult = (void *)result;
5225
5226
5227   return jresult;
5228 }
5229
5230
5231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
5232   void * jresult ;
5233   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5234   Dali::Vector2 *arg2 = 0 ;
5235   Dali::Vector4 *result = 0 ;
5236
5237   arg1 = (Dali::Vector4 *)jarg1;
5238   arg2 = (Dali::Vector2 *)jarg2;
5239   if (!arg2) {
5240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5241     return 0;
5242   }
5243   {
5244     try {
5245       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5246     } CALL_CATCH_EXCEPTION(0);
5247   }
5248
5249   jresult = (void *)result;
5250   return jresult;
5251 }
5252
5253
5254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
5255   void * jresult ;
5256   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5257   Dali::Vector3 *arg2 = 0 ;
5258   Dali::Vector4 *result = 0 ;
5259
5260   arg1 = (Dali::Vector4 *)jarg1;
5261   arg2 = (Dali::Vector3 *)jarg2;
5262   if (!arg2) {
5263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5264     return 0;
5265   }
5266   {
5267     try {
5268       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
5269     } CALL_CATCH_EXCEPTION(0);
5270   }
5271
5272   jresult = (void *)result;
5273   return jresult;
5274 }
5275
5276
5277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
5278   void * jresult ;
5279   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5280   Dali::Vector4 *arg2 = 0 ;
5281   Dali::Vector4 result;
5282
5283   arg1 = (Dali::Vector4 *)jarg1;
5284   arg2 = (Dali::Vector4 *)jarg2;
5285   if (!arg2) {
5286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5287     return 0;
5288   }
5289   {
5290     try {
5291       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
5292     } CALL_CATCH_EXCEPTION(0);
5293   }
5294
5295   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5296   return jresult;
5297 }
5298
5299
5300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
5301   void * jresult ;
5302   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5303   Dali::Vector4 *arg2 = 0 ;
5304   Dali::Vector4 *result = 0 ;
5305
5306   arg1 = (Dali::Vector4 *)jarg1;
5307   arg2 = (Dali::Vector4 *)jarg2;
5308   if (!arg2) {
5309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5310     return 0;
5311   }
5312   {
5313     try {
5314       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
5315     } CALL_CATCH_EXCEPTION(0);
5316   }
5317
5318   jresult = (void *)result;
5319   return jresult;
5320 }
5321
5322
5323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5324   void * jresult ;
5325   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5326   Dali::Vector4 *arg2 = 0 ;
5327   Dali::Vector4 result;
5328
5329   arg1 = (Dali::Vector4 *)jarg1;
5330   arg2 = (Dali::Vector4 *)jarg2;
5331   if (!arg2) {
5332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5333     return 0;
5334   }
5335   {
5336     try {
5337       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
5338     } CALL_CATCH_EXCEPTION(0);
5339   }
5340
5341   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5342   return jresult;
5343 }
5344
5345
5346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
5347   void * jresult ;
5348   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5349   Dali::Vector4 *arg2 = 0 ;
5350   Dali::Vector4 *result = 0 ;
5351
5352   arg1 = (Dali::Vector4 *)jarg1;
5353   arg2 = (Dali::Vector4 *)jarg2;
5354   if (!arg2) {
5355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5356     return 0;
5357   }
5358   {
5359     try {
5360       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
5361     } CALL_CATCH_EXCEPTION(0);
5362   }
5363
5364   jresult = (void *)result;
5365   return jresult;
5366 }
5367
5368
5369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5370   void * jresult ;
5371   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5372   Dali::Vector4 *arg2 = 0 ;
5373   Dali::Vector4 result;
5374
5375   arg1 = (Dali::Vector4 *)jarg1;
5376   arg2 = (Dali::Vector4 *)jarg2;
5377   if (!arg2) {
5378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5379     return 0;
5380   }
5381   {
5382     try {
5383       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
5384     } CALL_CATCH_EXCEPTION(0);
5385   }
5386
5387   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5388   return jresult;
5389 }
5390
5391
5392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
5393   void * jresult ;
5394   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5395   float arg2 ;
5396   Dali::Vector4 result;
5397
5398   arg1 = (Dali::Vector4 *)jarg1;
5399   arg2 = (float)jarg2;
5400   {
5401     try {
5402       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
5403     } CALL_CATCH_EXCEPTION(0);
5404   }
5405
5406   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5407   return jresult;
5408 }
5409
5410
5411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5412   void * jresult ;
5413   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5414   Dali::Vector4 *arg2 = 0 ;
5415   Dali::Vector4 *result = 0 ;
5416
5417   arg1 = (Dali::Vector4 *)jarg1;
5418   arg2 = (Dali::Vector4 *)jarg2;
5419   if (!arg2) {
5420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5421     return 0;
5422   }
5423   {
5424     try {
5425       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
5426     } CALL_CATCH_EXCEPTION(0);
5427   }
5428
5429   jresult = (void *)result;
5430   return jresult;
5431 }
5432
5433
5434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5435   void * jresult ;
5436   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5437   float arg2 ;
5438   Dali::Vector4 *result = 0 ;
5439
5440   arg1 = (Dali::Vector4 *)jarg1;
5441   arg2 = (float)jarg2;
5442   {
5443     try {
5444       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
5445     } CALL_CATCH_EXCEPTION(0);
5446   }
5447
5448   jresult = (void *)result;
5449   return jresult;
5450 }
5451
5452
5453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
5454   void * jresult ;
5455   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5456   Dali::Vector4 *arg2 = 0 ;
5457   Dali::Vector4 result;
5458
5459   arg1 = (Dali::Vector4 *)jarg1;
5460   arg2 = (Dali::Vector4 *)jarg2;
5461   if (!arg2) {
5462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5463     return 0;
5464   }
5465   {
5466     try {
5467       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
5468     } CALL_CATCH_EXCEPTION(0);
5469   }
5470
5471   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5472   return jresult;
5473 }
5474
5475
5476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
5477   void * jresult ;
5478   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5479   float arg2 ;
5480   Dali::Vector4 result;
5481
5482   arg1 = (Dali::Vector4 *)jarg1;
5483   arg2 = (float)jarg2;
5484   {
5485     try {
5486       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
5487     } CALL_CATCH_EXCEPTION(0);
5488   }
5489
5490   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5491   return jresult;
5492 }
5493
5494
5495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5496   void * jresult ;
5497   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5498   Dali::Vector4 *arg2 = 0 ;
5499   Dali::Vector4 *result = 0 ;
5500
5501   arg1 = (Dali::Vector4 *)jarg1;
5502   arg2 = (Dali::Vector4 *)jarg2;
5503   if (!arg2) {
5504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5505     return 0;
5506   }
5507   {
5508     try {
5509       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
5510     } CALL_CATCH_EXCEPTION(0);
5511   }
5512
5513   jresult = (void *)result;
5514   return jresult;
5515 }
5516
5517
5518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5519   void * jresult ;
5520   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5521   float arg2 ;
5522   Dali::Vector4 *result = 0 ;
5523
5524   arg1 = (Dali::Vector4 *)jarg1;
5525   arg2 = (float)jarg2;
5526   {
5527     try {
5528       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
5529     } CALL_CATCH_EXCEPTION(0);
5530   }
5531
5532   jresult = (void *)result;
5533   return jresult;
5534 }
5535
5536
5537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
5538   void * jresult ;
5539   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5540   Dali::Vector4 result;
5541
5542   arg1 = (Dali::Vector4 *)jarg1;
5543   {
5544     try {
5545       result = ((Dali::Vector4 const *)arg1)->operator -();
5546     } CALL_CATCH_EXCEPTION(0);
5547   }
5548
5549   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5550   return jresult;
5551 }
5552
5553
5554 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
5555   bool jresult ;
5556   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5557   Dali::Vector4 *arg2 = 0 ;
5558   bool result;
5559
5560   arg1 = (Dali::Vector4 *)jarg1;
5561   arg2 = (Dali::Vector4 *)jarg2;
5562   if (!arg2) {
5563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5564     return 0;
5565   }
5566   {
5567     try {
5568       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
5569     } CALL_CATCH_EXCEPTION(0);
5570   }
5571
5572   jresult = result;
5573   return jresult;
5574 }
5575
5576
5577 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
5578   bool jresult ;
5579   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5580   Dali::Vector4 *arg2 = 0 ;
5581   bool result;
5582
5583   arg1 = (Dali::Vector4 *)jarg1;
5584   arg2 = (Dali::Vector4 *)jarg2;
5585   if (!arg2) {
5586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5587     return 0;
5588   }
5589   {
5590     try {
5591       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
5592     } CALL_CATCH_EXCEPTION(0);
5593   }
5594
5595   jresult = result;
5596   return jresult;
5597 }
5598
5599
5600 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5601   float jresult ;
5602   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5603   unsigned int arg2 ;
5604   float *result = 0 ;
5605
5606   arg1 = (Dali::Vector4 *)jarg1;
5607   arg2 = (unsigned int)jarg2;
5608   {
5609     try {
5610       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
5611     } CALL_CATCH_EXCEPTION(0);
5612   }
5613
5614   jresult = *result;
5615   return jresult;
5616 }
5617
5618
5619 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
5620   float jresult ;
5621   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5622   Dali::Vector3 *arg2 = 0 ;
5623   float result;
5624
5625   arg1 = (Dali::Vector4 *)jarg1;
5626   arg2 = (Dali::Vector3 *)jarg2;
5627   if (!arg2) {
5628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5629     return 0;
5630   }
5631   {
5632     try {
5633       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5634     } CALL_CATCH_EXCEPTION(0);
5635   }
5636
5637   jresult = result;
5638   return jresult;
5639 }
5640
5641
5642 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
5643   float jresult ;
5644   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5645   Dali::Vector4 *arg2 = 0 ;
5646   float result;
5647
5648   arg1 = (Dali::Vector4 *)jarg1;
5649   arg2 = (Dali::Vector4 *)jarg2;
5650   if (!arg2) {
5651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5652     return 0;
5653   }
5654   {
5655     try {
5656       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
5657     } CALL_CATCH_EXCEPTION(0);
5658   }
5659
5660   jresult = result;
5661   return jresult;
5662 }
5663
5664
5665 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
5666   float jresult ;
5667   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5668   Dali::Vector4 *arg2 = 0 ;
5669   float result;
5670
5671   arg1 = (Dali::Vector4 *)jarg1;
5672   arg2 = (Dali::Vector4 *)jarg2;
5673   if (!arg2) {
5674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5675     return 0;
5676   }
5677   {
5678     try {
5679       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
5680     } CALL_CATCH_EXCEPTION(0);
5681   }
5682
5683   jresult = result;
5684   return jresult;
5685 }
5686
5687
5688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
5689   void * jresult ;
5690   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5691   Dali::Vector4 *arg2 = 0 ;
5692   Dali::Vector4 result;
5693
5694   arg1 = (Dali::Vector4 *)jarg1;
5695   arg2 = (Dali::Vector4 *)jarg2;
5696   if (!arg2) {
5697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5698     return 0;
5699   }
5700   {
5701     try {
5702       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
5703     } CALL_CATCH_EXCEPTION(0);
5704   }
5705
5706   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5707   return jresult;
5708 }
5709
5710
5711 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
5712   float jresult ;
5713   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5714   float result;
5715
5716   arg1 = (Dali::Vector4 *)jarg1;
5717   {
5718     try {
5719       result = (float)((Dali::Vector4 const *)arg1)->Length();
5720     } CALL_CATCH_EXCEPTION(0);
5721   }
5722
5723   jresult = result;
5724   return jresult;
5725 }
5726
5727
5728 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
5729   float jresult ;
5730   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5731   float result;
5732
5733   arg1 = (Dali::Vector4 *)jarg1;
5734   {
5735     try {
5736       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
5737     } CALL_CATCH_EXCEPTION(0);
5738   }
5739
5740   jresult = result;
5741   return jresult;
5742 }
5743
5744
5745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
5746   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5747
5748   arg1 = (Dali::Vector4 *)jarg1;
5749   {
5750     try {
5751       (arg1)->Normalize();
5752     } CALL_CATCH_EXCEPTION();
5753   }
5754
5755 }
5756
5757
5758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5759   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5760   Dali::Vector4 *arg2 = 0 ;
5761   Dali::Vector4 *arg3 = 0 ;
5762
5763   arg1 = (Dali::Vector4 *)jarg1;
5764   arg2 = (Dali::Vector4 *)jarg2;
5765   if (!arg2) {
5766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5767     return ;
5768   }
5769   arg3 = (Dali::Vector4 *)jarg3;
5770   if (!arg3) {
5771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5772     return ;
5773   }
5774   {
5775     try {
5776       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
5777     } CALL_CATCH_EXCEPTION();
5778   }
5779
5780 }
5781
5782
5783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
5784   void * jresult ;
5785   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5786   float *result = 0 ;
5787
5788   arg1 = (Dali::Vector4 *)jarg1;
5789   {
5790     try {
5791       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
5792     } CALL_CATCH_EXCEPTION(0);
5793   }
5794
5795   jresult = (void *)result;
5796   return jresult;
5797 }
5798
5799
5800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
5801   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5802   float arg2 ;
5803
5804   arg1 = (Dali::Vector4 *)jarg1;
5805   arg2 = (float)jarg2;
5806   if (arg1) (arg1)->x = arg2;
5807 }
5808
5809
5810 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
5811   float jresult ;
5812   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5813   float result;
5814
5815   arg1 = (Dali::Vector4 *)jarg1;
5816   result = (float) ((arg1)->x);
5817   jresult = result;
5818   return jresult;
5819 }
5820
5821
5822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
5823   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5824   float arg2 ;
5825
5826   arg1 = (Dali::Vector4 *)jarg1;
5827   arg2 = (float)jarg2;
5828   if (arg1) (arg1)->r = arg2;
5829 }
5830
5831
5832 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
5833   float jresult ;
5834   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5835   float result;
5836
5837   arg1 = (Dali::Vector4 *)jarg1;
5838   result = (float) ((arg1)->r);
5839   jresult = result;
5840   return jresult;
5841 }
5842
5843
5844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
5845   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5846   float arg2 ;
5847
5848   arg1 = (Dali::Vector4 *)jarg1;
5849   arg2 = (float)jarg2;
5850   if (arg1) (arg1)->s = arg2;
5851 }
5852
5853
5854 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
5855   float jresult ;
5856   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5857   float result;
5858
5859   arg1 = (Dali::Vector4 *)jarg1;
5860   result = (float) ((arg1)->s);
5861   jresult = result;
5862   return jresult;
5863 }
5864
5865
5866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
5867   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5868   float arg2 ;
5869
5870   arg1 = (Dali::Vector4 *)jarg1;
5871   arg2 = (float)jarg2;
5872   if (arg1) (arg1)->y = arg2;
5873 }
5874
5875
5876 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
5877   float jresult ;
5878   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5879   float result;
5880
5881   arg1 = (Dali::Vector4 *)jarg1;
5882   result = (float) ((arg1)->y);
5883   jresult = result;
5884   return jresult;
5885 }
5886
5887
5888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
5889   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5890   float arg2 ;
5891
5892   arg1 = (Dali::Vector4 *)jarg1;
5893   arg2 = (float)jarg2;
5894   if (arg1) (arg1)->g = arg2;
5895 }
5896
5897
5898 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
5899   float jresult ;
5900   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5901   float result;
5902
5903   arg1 = (Dali::Vector4 *)jarg1;
5904   result = (float) ((arg1)->g);
5905   jresult = result;
5906   return jresult;
5907 }
5908
5909
5910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
5911   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5912   float arg2 ;
5913
5914   arg1 = (Dali::Vector4 *)jarg1;
5915   arg2 = (float)jarg2;
5916   if (arg1) (arg1)->t = arg2;
5917 }
5918
5919
5920 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
5921   float jresult ;
5922   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5923   float result;
5924
5925   arg1 = (Dali::Vector4 *)jarg1;
5926   result = (float) ((arg1)->t);
5927   jresult = result;
5928   return jresult;
5929 }
5930
5931
5932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
5933   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5934   float arg2 ;
5935
5936   arg1 = (Dali::Vector4 *)jarg1;
5937   arg2 = (float)jarg2;
5938   if (arg1) (arg1)->z = arg2;
5939 }
5940
5941
5942 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
5943   float jresult ;
5944   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5945   float result;
5946
5947   arg1 = (Dali::Vector4 *)jarg1;
5948   result = (float) ((arg1)->z);
5949   jresult = result;
5950   return jresult;
5951 }
5952
5953
5954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
5955   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5956   float arg2 ;
5957
5958   arg1 = (Dali::Vector4 *)jarg1;
5959   arg2 = (float)jarg2;
5960   if (arg1) (arg1)->b = arg2;
5961 }
5962
5963
5964 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
5965   float jresult ;
5966   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5967   float result;
5968
5969   arg1 = (Dali::Vector4 *)jarg1;
5970   result = (float) ((arg1)->b);
5971   jresult = result;
5972   return jresult;
5973 }
5974
5975
5976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
5977   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5978   float arg2 ;
5979
5980   arg1 = (Dali::Vector4 *)jarg1;
5981   arg2 = (float)jarg2;
5982   if (arg1) (arg1)->p = arg2;
5983 }
5984
5985
5986 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
5987   float jresult ;
5988   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5989   float result;
5990
5991   arg1 = (Dali::Vector4 *)jarg1;
5992   result = (float) ((arg1)->p);
5993   jresult = result;
5994   return jresult;
5995 }
5996
5997
5998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
5999   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6000   float arg2 ;
6001
6002   arg1 = (Dali::Vector4 *)jarg1;
6003   arg2 = (float)jarg2;
6004   if (arg1) (arg1)->w = arg2;
6005 }
6006
6007
6008 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
6009   float jresult ;
6010   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6011   float result;
6012
6013   arg1 = (Dali::Vector4 *)jarg1;
6014   result = (float) ((arg1)->w);
6015   jresult = result;
6016   return jresult;
6017 }
6018
6019
6020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
6021   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6022   float arg2 ;
6023
6024   arg1 = (Dali::Vector4 *)jarg1;
6025   arg2 = (float)jarg2;
6026   if (arg1) (arg1)->a = arg2;
6027 }
6028
6029
6030 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
6031   float jresult ;
6032   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6033   float result;
6034
6035   arg1 = (Dali::Vector4 *)jarg1;
6036   result = (float) ((arg1)->a);
6037   jresult = result;
6038   return jresult;
6039 }
6040
6041
6042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
6043   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6044   float arg2 ;
6045
6046   arg1 = (Dali::Vector4 *)jarg1;
6047   arg2 = (float)jarg2;
6048   if (arg1) (arg1)->q = arg2;
6049 }
6050
6051
6052 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
6053   float jresult ;
6054   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6055   float result;
6056
6057   arg1 = (Dali::Vector4 *)jarg1;
6058   result = (float) ((arg1)->q);
6059   jresult = result;
6060   return jresult;
6061 }
6062
6063
6064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
6065   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6066
6067   arg1 = (Dali::Vector4 *)jarg1;
6068   {
6069     try {
6070       delete arg1;
6071     } CALL_CATCH_EXCEPTION();
6072   }
6073
6074 }
6075
6076
6077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
6078   void * jresult ;
6079   Dali::Vector4 *arg1 = 0 ;
6080   Dali::Vector4 *arg2 = 0 ;
6081   Dali::Vector4 result;
6082
6083   arg1 = (Dali::Vector4 *)jarg1;
6084   if (!arg1) {
6085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6086     return 0;
6087   }
6088   arg2 = (Dali::Vector4 *)jarg2;
6089   if (!arg2) {
6090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6091     return 0;
6092   }
6093   {
6094     try {
6095       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
6096     } CALL_CATCH_EXCEPTION(0);
6097   }
6098
6099   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6100   return jresult;
6101 }
6102
6103
6104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
6105   void * jresult ;
6106   Dali::Vector4 *arg1 = 0 ;
6107   Dali::Vector4 *arg2 = 0 ;
6108   Dali::Vector4 result;
6109
6110   arg1 = (Dali::Vector4 *)jarg1;
6111   if (!arg1) {
6112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6113     return 0;
6114   }
6115   arg2 = (Dali::Vector4 *)jarg2;
6116   if (!arg2) {
6117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6118     return 0;
6119   }
6120   {
6121     try {
6122       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
6123     } CALL_CATCH_EXCEPTION(0);
6124   }
6125
6126   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6127   return jresult;
6128 }
6129
6130
6131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
6132   void * jresult ;
6133   Dali::Vector4 *arg1 = 0 ;
6134   float *arg2 = 0 ;
6135   float *arg3 = 0 ;
6136   float temp2 ;
6137   float temp3 ;
6138   Dali::Vector4 result;
6139
6140   arg1 = (Dali::Vector4 *)jarg1;
6141   if (!arg1) {
6142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6143     return 0;
6144   }
6145   temp2 = (float)jarg2;
6146   arg2 = &temp2;
6147   temp3 = (float)jarg3;
6148   arg3 = &temp3;
6149   {
6150     try {
6151       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6152     } CALL_CATCH_EXCEPTION(0);
6153   }
6154
6155   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6156   return jresult;
6157 }
6158
6159
6160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
6161   void * jresult ;
6162   Dali::Uint16Pair *result = 0 ;
6163
6164   {
6165     try {
6166       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
6167     } CALL_CATCH_EXCEPTION(0);
6168   }
6169
6170   jresult = (void *)result;
6171   return jresult;
6172 }
6173
6174
6175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
6176   void * jresult ;
6177   uint32_t arg1 ;
6178   uint32_t arg2 ;
6179   Dali::Uint16Pair *result = 0 ;
6180
6181   arg1 = (uint32_t)jarg1;
6182   arg2 = (uint32_t)jarg2;
6183   {
6184     try {
6185       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
6186     } CALL_CATCH_EXCEPTION(0);
6187   }
6188
6189   jresult = (void *)result;
6190   return jresult;
6191 }
6192
6193
6194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
6195   void * jresult ;
6196   Dali::Uint16Pair *arg1 = 0 ;
6197   Dali::Uint16Pair *result = 0 ;
6198
6199   arg1 = (Dali::Uint16Pair *)jarg1;
6200   if (!arg1) {
6201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6202     return 0;
6203   }
6204   {
6205     try {
6206       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
6207     } CALL_CATCH_EXCEPTION(0);
6208   }
6209
6210   jresult = (void *)result;
6211   return jresult;
6212 }
6213
6214
6215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
6216   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6217   uint16_t arg2 ;
6218
6219   arg1 = (Dali::Uint16Pair *)jarg1;
6220   arg2 = (uint16_t)jarg2;
6221   {
6222     try {
6223       (arg1)->SetWidth(arg2);
6224     } CALL_CATCH_EXCEPTION();
6225   }
6226
6227 }
6228
6229
6230 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
6231   unsigned short jresult ;
6232   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6233   uint16_t result;
6234
6235   arg1 = (Dali::Uint16Pair *)jarg1;
6236   {
6237     try {
6238       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
6239     } CALL_CATCH_EXCEPTION(0);
6240   }
6241
6242   jresult = result;
6243   return jresult;
6244 }
6245
6246
6247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
6248   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6249   uint16_t arg2 ;
6250
6251   arg1 = (Dali::Uint16Pair *)jarg1;
6252   arg2 = (uint16_t)jarg2;
6253   {
6254     try {
6255       (arg1)->SetHeight(arg2);
6256     } CALL_CATCH_EXCEPTION();
6257   }
6258
6259 }
6260
6261
6262 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
6263   unsigned short jresult ;
6264   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6265   uint16_t result;
6266
6267   arg1 = (Dali::Uint16Pair *)jarg1;
6268   {
6269     try {
6270       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
6271     } CALL_CATCH_EXCEPTION(0);
6272   }
6273
6274   jresult = result;
6275   return jresult;
6276 }
6277
6278
6279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
6280   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6281   uint16_t arg2 ;
6282
6283   arg1 = (Dali::Uint16Pair *)jarg1;
6284   arg2 = (uint16_t)jarg2;
6285   {
6286     try {
6287       (arg1)->SetX(arg2);
6288     } CALL_CATCH_EXCEPTION();
6289   }
6290
6291 }
6292
6293
6294 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
6295   unsigned short jresult ;
6296   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6297   uint16_t result;
6298
6299   arg1 = (Dali::Uint16Pair *)jarg1;
6300   {
6301     try {
6302       result = ((Dali::Uint16Pair const *)arg1)->GetX();
6303     } CALL_CATCH_EXCEPTION(0);
6304   }
6305
6306   jresult = result;
6307   return jresult;
6308 }
6309
6310
6311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
6312   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6313   uint16_t arg2 ;
6314
6315   arg1 = (Dali::Uint16Pair *)jarg1;
6316   arg2 = (uint16_t)jarg2;
6317   {
6318     try {
6319       (arg1)->SetY(arg2);
6320     } CALL_CATCH_EXCEPTION();
6321   }
6322
6323 }
6324
6325
6326 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
6327   unsigned short jresult ;
6328   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6329   uint16_t result;
6330
6331   arg1 = (Dali::Uint16Pair *)jarg1;
6332   {
6333     try {
6334       result = ((Dali::Uint16Pair const *)arg1)->GetY();
6335     } CALL_CATCH_EXCEPTION(0);
6336   }
6337
6338   jresult = result;
6339   return jresult;
6340 }
6341
6342
6343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
6344   void * jresult ;
6345   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6346   Dali::Uint16Pair *arg2 = 0 ;
6347   Dali::Uint16Pair *result = 0 ;
6348
6349   arg1 = (Dali::Uint16Pair *)jarg1;
6350   arg2 = (Dali::Uint16Pair *)jarg2;
6351   if (!arg2) {
6352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6353     return 0;
6354   }
6355   {
6356     try {
6357       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
6358     } CALL_CATCH_EXCEPTION(0);
6359   }
6360
6361   jresult = (void *)result;
6362   return jresult;
6363 }
6364
6365
6366 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
6367   bool jresult ;
6368   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6369   Dali::Uint16Pair *arg2 = 0 ;
6370   bool result;
6371
6372   arg1 = (Dali::Uint16Pair *)jarg1;
6373   arg2 = (Dali::Uint16Pair *)jarg2;
6374   if (!arg2) {
6375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6376     return 0;
6377   }
6378   {
6379     try {
6380       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
6381     } CALL_CATCH_EXCEPTION(0);
6382   }
6383
6384   jresult = result;
6385   return jresult;
6386 }
6387
6388
6389 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
6390   bool jresult ;
6391   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6392   Dali::Uint16Pair *arg2 = 0 ;
6393   bool result;
6394
6395   arg1 = (Dali::Uint16Pair *)jarg1;
6396   arg2 = (Dali::Uint16Pair *)jarg2;
6397   if (!arg2) {
6398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6399     return 0;
6400   }
6401   {
6402     try {
6403       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
6404     } CALL_CATCH_EXCEPTION(0);
6405   }
6406
6407   jresult = result;
6408   return jresult;
6409 }
6410
6411
6412 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
6413   bool jresult ;
6414   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6415   Dali::Uint16Pair *arg2 = 0 ;
6416   bool result;
6417
6418   arg1 = (Dali::Uint16Pair *)jarg1;
6419   arg2 = (Dali::Uint16Pair *)jarg2;
6420   if (!arg2) {
6421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6422     return 0;
6423   }
6424   {
6425     try {
6426       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
6427     } CALL_CATCH_EXCEPTION(0);
6428   }
6429
6430   jresult = result;
6431   return jresult;
6432 }
6433
6434
6435 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
6436   bool jresult ;
6437   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6438   Dali::Uint16Pair *arg2 = 0 ;
6439   bool result;
6440
6441   arg1 = (Dali::Uint16Pair *)jarg1;
6442   arg2 = (Dali::Uint16Pair *)jarg2;
6443   if (!arg2) {
6444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6445     return 0;
6446   }
6447   {
6448     try {
6449       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
6450     } CALL_CATCH_EXCEPTION(0);
6451   }
6452
6453   jresult = result;
6454   return jresult;
6455 }
6456
6457
6458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
6459   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6460
6461   arg1 = (Dali::Uint16Pair *)jarg1;
6462   {
6463     try {
6464       delete arg1;
6465     } CALL_CATCH_EXCEPTION();
6466   }
6467
6468 }
6469
6470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Int32Pair__SWIG_0() {
6471   void * jresult ;
6472   Dali::Int32Pair *result = 0 ;
6473
6474   {
6475     try {
6476       result = (Dali::Int32Pair *)new Dali::Int32Pair();
6477     } CALL_CATCH_EXCEPTION(0);
6478   }
6479
6480   jresult = (void *)result;
6481   return jresult;
6482 }
6483
6484
6485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Int32Pair__SWIG_1(int32_t x, int32_t y) {
6486   void * jresult ;
6487   Dali::Int32Pair *result = 0 ;
6488
6489   {
6490     try {
6491       result = (Dali::Int32Pair *)new Dali::Int32Pair(x,y);
6492     } CALL_CATCH_EXCEPTION(0);
6493   }
6494
6495   jresult = (void *)result;
6496   return jresult;
6497 }
6498
6499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Int32Pair_SetX(void * int32Pair, int32_t x) {
6500   Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ;
6501
6502   {
6503     try {
6504       (pInt32Pair)->SetX(x);
6505     } CALL_CATCH_EXCEPTION();
6506   }
6507 }
6508
6509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Int32Pair_GetX(void * int32Pair) {
6510   int result ;
6511   Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair);
6512
6513   {
6514     try {
6515       result = ((Dali::Int32Pair const *)pInt32Pair)->GetX();
6516     } CALL_CATCH_EXCEPTION(0);
6517   }
6518
6519   return result;
6520 }
6521
6522
6523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Int32Pair_SetY(void * int32Pair, int32_t y) {
6524   Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ;
6525
6526   {
6527     try {
6528       (pInt32Pair)->SetY(y);
6529     } CALL_CATCH_EXCEPTION();
6530   }
6531
6532 }
6533
6534
6535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Int32Pair_GetY(void * int32Pair) {
6536   Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ;
6537   int result;
6538
6539   {
6540     try {
6541       result = ((Dali::Int32Pair const *)pInt32Pair)->GetY();
6542     } CALL_CATCH_EXCEPTION(0);
6543   }
6544
6545   return result;
6546 }
6547
6548
6549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Int32Pair(void * int32Pair) {
6550   Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ;
6551
6552   {
6553     try {
6554       delete pInt32Pair;
6555     } CALL_CATCH_EXCEPTION();
6556   }
6557
6558 }
6559
6560
6561
6562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
6563   void * jresult ;
6564   Dali::Degree *result = 0 ;
6565
6566   {
6567     try {
6568       result = (Dali::Degree *)new Dali::Degree();
6569     } CALL_CATCH_EXCEPTION(0);
6570   }
6571
6572   jresult = (void *)result;
6573   return jresult;
6574 }
6575
6576
6577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
6578   void * jresult ;
6579   float arg1 ;
6580   Dali::Degree *result = 0 ;
6581
6582   arg1 = (float)jarg1;
6583   {
6584     try {
6585       result = (Dali::Degree *)new Dali::Degree(arg1);
6586     } CALL_CATCH_EXCEPTION(0);
6587   }
6588
6589   jresult = (void *)result;
6590   return jresult;
6591 }
6592
6593
6594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
6595   void * jresult ;
6596   Dali::Radian arg1 ;
6597   Dali::Radian *argp1 ;
6598   Dali::Degree *result = 0 ;
6599
6600   argp1 = (Dali::Radian *)jarg1;
6601   if (!argp1) {
6602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
6603     return 0;
6604   }
6605   arg1 = *argp1;
6606   {
6607     try {
6608       result = (Dali::Degree *)new Dali::Degree(arg1);
6609     } CALL_CATCH_EXCEPTION(0);
6610   }
6611
6612   jresult = (void *)result;
6613   return jresult;
6614 }
6615
6616
6617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
6618   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
6619   float arg2 ;
6620
6621   arg1 = (Dali::Degree *)jarg1;
6622   arg2 = (float)jarg2;
6623   if (arg1) (arg1)->degree = arg2;
6624 }
6625
6626
6627 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
6628   float jresult ;
6629   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
6630   float result;
6631
6632   arg1 = (Dali::Degree *)jarg1;
6633   result = (float) ((arg1)->degree);
6634   jresult = result;
6635   return jresult;
6636 }
6637
6638
6639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
6640   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
6641
6642   arg1 = (Dali::Degree *)jarg1;
6643   {
6644     try {
6645       delete arg1;
6646     } CALL_CATCH_EXCEPTION();
6647   }
6648
6649 }
6650
6651
6652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
6653   void * jresult ;
6654   Dali::Radian *result = 0 ;
6655
6656   result = (Dali::Radian *)&Dali::ANGLE_360;
6657   jresult = (void *)result;
6658   return jresult;
6659 }
6660
6661
6662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
6663   void * jresult ;
6664   Dali::Radian *result = 0 ;
6665
6666   result = (Dali::Radian *)&Dali::ANGLE_315;
6667   jresult = (void *)result;
6668   return jresult;
6669 }
6670
6671
6672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
6673   void * jresult ;
6674   Dali::Radian *result = 0 ;
6675
6676   result = (Dali::Radian *)&Dali::ANGLE_270;
6677   jresult = (void *)result;
6678   return jresult;
6679 }
6680
6681
6682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
6683   void * jresult ;
6684   Dali::Radian *result = 0 ;
6685
6686   result = (Dali::Radian *)&Dali::ANGLE_225;
6687   jresult = (void *)result;
6688   return jresult;
6689 }
6690
6691
6692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
6693   void * jresult ;
6694   Dali::Radian *result = 0 ;
6695
6696   result = (Dali::Radian *)&Dali::ANGLE_180;
6697   jresult = (void *)result;
6698   return jresult;
6699 }
6700
6701
6702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
6703   void * jresult ;
6704   Dali::Radian *result = 0 ;
6705
6706   result = (Dali::Radian *)&Dali::ANGLE_135;
6707   jresult = (void *)result;
6708   return jresult;
6709 }
6710
6711
6712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
6713   void * jresult ;
6714   Dali::Radian *result = 0 ;
6715
6716   result = (Dali::Radian *)&Dali::ANGLE_120;
6717   jresult = (void *)result;
6718   return jresult;
6719 }
6720
6721
6722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
6723   void * jresult ;
6724   Dali::Radian *result = 0 ;
6725
6726   result = (Dali::Radian *)&Dali::ANGLE_90;
6727   jresult = (void *)result;
6728   return jresult;
6729 }
6730
6731
6732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
6733   void * jresult ;
6734   Dali::Radian *result = 0 ;
6735
6736   result = (Dali::Radian *)&Dali::ANGLE_60;
6737   jresult = (void *)result;
6738   return jresult;
6739 }
6740
6741
6742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
6743   void * jresult ;
6744   Dali::Radian *result = 0 ;
6745
6746   result = (Dali::Radian *)&Dali::ANGLE_45;
6747   jresult = (void *)result;
6748   return jresult;
6749 }
6750
6751
6752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
6753   void * jresult ;
6754   Dali::Radian *result = 0 ;
6755
6756   result = (Dali::Radian *)&Dali::ANGLE_30;
6757   jresult = (void *)result;
6758   return jresult;
6759 }
6760
6761
6762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
6763   void * jresult ;
6764   Dali::Radian *result = 0 ;
6765
6766   result = (Dali::Radian *)&Dali::ANGLE_0;
6767   jresult = (void *)result;
6768   return jresult;
6769 }
6770
6771
6772 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
6773   bool jresult ;
6774   Dali::Degree *arg1 = 0 ;
6775   Dali::Degree *arg2 = 0 ;
6776   bool result;
6777
6778   arg1 = (Dali::Degree *)jarg1;
6779   if (!arg1) {
6780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6781     return 0;
6782   }
6783   arg2 = (Dali::Degree *)jarg2;
6784   if (!arg2) {
6785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6786     return 0;
6787   }
6788   {
6789     try {
6790       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
6791     } CALL_CATCH_EXCEPTION(0);
6792   }
6793
6794   jresult = result;
6795   return jresult;
6796 }
6797
6798
6799 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
6800   bool jresult ;
6801   Dali::Degree *arg1 = 0 ;
6802   Dali::Degree *arg2 = 0 ;
6803   bool result;
6804
6805   arg1 = (Dali::Degree *)jarg1;
6806   if (!arg1) {
6807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6808     return 0;
6809   }
6810   arg2 = (Dali::Degree *)jarg2;
6811   if (!arg2) {
6812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6813     return 0;
6814   }
6815   {
6816     try {
6817       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
6818     } CALL_CATCH_EXCEPTION(0);
6819   }
6820
6821   jresult = result;
6822   return jresult;
6823 }
6824
6825
6826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
6827   void * jresult ;
6828   Dali::Degree arg1 ;
6829   float arg2 ;
6830   float arg3 ;
6831   Dali::Degree *argp1 ;
6832   Dali::Degree result;
6833
6834   argp1 = (Dali::Degree *)jarg1;
6835   if (!argp1) {
6836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
6837     return 0;
6838   }
6839   arg1 = *argp1;
6840   arg2 = (float)jarg2;
6841   arg3 = (float)jarg3;
6842   {
6843     try {
6844       result = Dali::Clamp(arg1,arg2,arg3);
6845     } CALL_CATCH_EXCEPTION(0);
6846   }
6847
6848   jresult = new Dali::Degree((const Dali::Degree &)result);
6849   return jresult;
6850 }
6851
6852
6853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
6854   void * jresult ;
6855   Dali::Radian *result = 0 ;
6856
6857   {
6858     try {
6859       result = (Dali::Radian *)new Dali::Radian();
6860     } CALL_CATCH_EXCEPTION(0);
6861   }
6862
6863   jresult = (void *)result;
6864   return jresult;
6865 }
6866
6867
6868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
6869   void * jresult ;
6870   float arg1 ;
6871   Dali::Radian *result = 0 ;
6872
6873   arg1 = (float)jarg1;
6874   {
6875     try {
6876       result = (Dali::Radian *)new Dali::Radian(arg1);
6877     } CALL_CATCH_EXCEPTION(0);
6878   }
6879
6880   jresult = (void *)result;
6881   return jresult;
6882 }
6883
6884
6885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
6886   void * jresult ;
6887   Dali::Degree arg1 ;
6888   Dali::Degree *argp1 ;
6889   Dali::Radian *result = 0 ;
6890
6891   argp1 = (Dali::Degree *)jarg1;
6892   if (!argp1) {
6893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
6894     return 0;
6895   }
6896   arg1 = *argp1;
6897   {
6898     try {
6899       result = (Dali::Radian *)new Dali::Radian(arg1);
6900     } CALL_CATCH_EXCEPTION(0);
6901   }
6902
6903   jresult = (void *)result;
6904   return jresult;
6905 }
6906
6907
6908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
6909   void * jresult ;
6910   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
6911   float arg2 ;
6912   Dali::Radian *result = 0 ;
6913
6914   arg1 = (Dali::Radian *)jarg1;
6915   arg2 = (float)jarg2;
6916   {
6917     try {
6918       result = (Dali::Radian *) &(arg1)->operator =(arg2);
6919     } CALL_CATCH_EXCEPTION(0);
6920   }
6921
6922   jresult = (void *)result;
6923   return jresult;
6924 }
6925
6926
6927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
6928   void * jresult ;
6929   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
6930   Dali::Degree arg2 ;
6931   Dali::Degree *argp2 ;
6932   Dali::Radian *result = 0 ;
6933
6934   arg1 = (Dali::Radian *)jarg1;
6935   argp2 = (Dali::Degree *)jarg2;
6936   if (!argp2) {
6937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
6938     return 0;
6939   }
6940   arg2 = *argp2;
6941   {
6942     try {
6943       result = (Dali::Radian *) &(arg1)->operator =(arg2);
6944     } CALL_CATCH_EXCEPTION(0);
6945   }
6946
6947   jresult = (void *)result;
6948   return jresult;
6949 }
6950
6951
6952 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
6953   float jresult ;
6954   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
6955   float result;
6956
6957   arg1 = (Dali::Radian *)jarg1;
6958   {
6959     try {
6960       result = (float)((Dali::Radian const *)arg1)->operator float();
6961     } CALL_CATCH_EXCEPTION(0);
6962   }
6963
6964   jresult = result;
6965   return jresult;
6966 }
6967
6968
6969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
6970   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
6971   float arg2 ;
6972
6973   arg1 = (Dali::Radian *)jarg1;
6974   arg2 = (float)jarg2;
6975   if (arg1) (arg1)->radian = arg2;
6976 }
6977
6978
6979 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
6980   float jresult ;
6981   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
6982   float result;
6983
6984   arg1 = (Dali::Radian *)jarg1;
6985   result = (float) ((arg1)->radian);
6986   jresult = result;
6987   return jresult;
6988 }
6989
6990
6991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
6992   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
6993
6994   arg1 = (Dali::Radian *)jarg1;
6995   {
6996     try {
6997       delete arg1;
6998     } CALL_CATCH_EXCEPTION();
6999   }
7000
7001 }
7002
7003
7004 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
7005   bool jresult ;
7006   Dali::Radian arg1 ;
7007   Dali::Radian arg2 ;
7008   Dali::Radian *argp1 ;
7009   Dali::Radian *argp2 ;
7010   bool result;
7011
7012   argp1 = (Dali::Radian *)jarg1;
7013   if (!argp1) {
7014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7015     return 0;
7016   }
7017   arg1 = *argp1;
7018   argp2 = (Dali::Radian *)jarg2;
7019   if (!argp2) {
7020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7021     return 0;
7022   }
7023   arg2 = *argp2;
7024   {
7025     try {
7026       result = (bool)Dali::operator ==(arg1,arg2);
7027     } CALL_CATCH_EXCEPTION(0);
7028   }
7029
7030   jresult = result;
7031   return jresult;
7032 }
7033
7034
7035 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
7036   bool jresult ;
7037   Dali::Radian arg1 ;
7038   Dali::Radian arg2 ;
7039   Dali::Radian *argp1 ;
7040   Dali::Radian *argp2 ;
7041   bool result;
7042
7043   argp1 = (Dali::Radian *)jarg1;
7044   if (!argp1) {
7045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7046     return 0;
7047   }
7048   arg1 = *argp1;
7049   argp2 = (Dali::Radian *)jarg2;
7050   if (!argp2) {
7051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7052     return 0;
7053   }
7054   arg2 = *argp2;
7055   {
7056     try {
7057       result = (bool)Dali::operator !=(arg1,arg2);
7058     } CALL_CATCH_EXCEPTION(0);
7059   }
7060
7061   jresult = result;
7062   return jresult;
7063 }
7064
7065
7066 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
7067   bool jresult ;
7068   Dali::Radian arg1 ;
7069   Dali::Degree arg2 ;
7070   Dali::Radian *argp1 ;
7071   Dali::Degree *argp2 ;
7072   bool result;
7073
7074   argp1 = (Dali::Radian *)jarg1;
7075   if (!argp1) {
7076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7077     return 0;
7078   }
7079   arg1 = *argp1;
7080   argp2 = (Dali::Degree *)jarg2;
7081   if (!argp2) {
7082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7083     return 0;
7084   }
7085   arg2 = *argp2;
7086   {
7087     try {
7088       result = (bool)Dali::operator ==(arg1,arg2);
7089     } CALL_CATCH_EXCEPTION(0);
7090   }
7091
7092   jresult = result;
7093   return jresult;
7094 }
7095
7096
7097 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
7098   bool jresult ;
7099   Dali::Radian arg1 ;
7100   Dali::Degree arg2 ;
7101   Dali::Radian *argp1 ;
7102   Dali::Degree *argp2 ;
7103   bool result;
7104
7105   argp1 = (Dali::Radian *)jarg1;
7106   if (!argp1) {
7107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7108     return 0;
7109   }
7110   arg1 = *argp1;
7111   argp2 = (Dali::Degree *)jarg2;
7112   if (!argp2) {
7113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7114     return 0;
7115   }
7116   arg2 = *argp2;
7117   {
7118     try {
7119       result = (bool)Dali::operator !=(arg1,arg2);
7120     } CALL_CATCH_EXCEPTION(0);
7121   }
7122
7123   jresult = result;
7124   return jresult;
7125 }
7126
7127
7128 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
7129   bool jresult ;
7130   Dali::Degree arg1 ;
7131   Dali::Radian arg2 ;
7132   Dali::Degree *argp1 ;
7133   Dali::Radian *argp2 ;
7134   bool result;
7135
7136   argp1 = (Dali::Degree *)jarg1;
7137   if (!argp1) {
7138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7139     return 0;
7140   }
7141   arg1 = *argp1;
7142   argp2 = (Dali::Radian *)jarg2;
7143   if (!argp2) {
7144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7145     return 0;
7146   }
7147   arg2 = *argp2;
7148   {
7149     try {
7150       result = (bool)Dali::operator ==(arg1,arg2);
7151     } CALL_CATCH_EXCEPTION(0);
7152   }
7153
7154   jresult = result;
7155   return jresult;
7156 }
7157
7158
7159 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
7160   bool jresult ;
7161   Dali::Degree arg1 ;
7162   Dali::Radian arg2 ;
7163   Dali::Degree *argp1 ;
7164   Dali::Radian *argp2 ;
7165   bool result;
7166
7167   argp1 = (Dali::Degree *)jarg1;
7168   if (!argp1) {
7169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7170     return 0;
7171   }
7172   arg1 = *argp1;
7173   argp2 = (Dali::Radian *)jarg2;
7174   if (!argp2) {
7175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7176     return 0;
7177   }
7178   arg2 = *argp2;
7179   {
7180     try {
7181       result = (bool)Dali::operator !=(arg1,arg2);
7182     } CALL_CATCH_EXCEPTION(0);
7183   }
7184
7185   jresult = result;
7186   return jresult;
7187 }
7188
7189
7190 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
7191   bool jresult ;
7192   Dali::Radian arg1 ;
7193   Dali::Radian arg2 ;
7194   Dali::Radian *argp1 ;
7195   Dali::Radian *argp2 ;
7196   bool result;
7197
7198   argp1 = (Dali::Radian *)jarg1;
7199   if (!argp1) {
7200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7201     return 0;
7202   }
7203   arg1 = *argp1;
7204   argp2 = (Dali::Radian *)jarg2;
7205   if (!argp2) {
7206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7207     return 0;
7208   }
7209   arg2 = *argp2;
7210   {
7211     try {
7212       result = (bool)Dali::operator >(arg1,arg2);
7213     } CALL_CATCH_EXCEPTION(0);
7214   }
7215
7216   jresult = result;
7217   return jresult;
7218 }
7219
7220
7221 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
7222   bool jresult ;
7223   Dali::Radian arg1 ;
7224   Dali::Degree arg2 ;
7225   Dali::Radian *argp1 ;
7226   Dali::Degree *argp2 ;
7227   bool result;
7228
7229   argp1 = (Dali::Radian *)jarg1;
7230   if (!argp1) {
7231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7232     return 0;
7233   }
7234   arg1 = *argp1;
7235   argp2 = (Dali::Degree *)jarg2;
7236   if (!argp2) {
7237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7238     return 0;
7239   }
7240   arg2 = *argp2;
7241   {
7242     try {
7243       result = (bool)Dali::operator >(arg1,arg2);
7244     } CALL_CATCH_EXCEPTION(0);
7245   }
7246
7247   jresult = result;
7248   return jresult;
7249 }
7250
7251
7252 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
7253   bool jresult ;
7254   Dali::Degree arg1 ;
7255   Dali::Radian arg2 ;
7256   Dali::Degree *argp1 ;
7257   Dali::Radian *argp2 ;
7258   bool result;
7259
7260   argp1 = (Dali::Degree *)jarg1;
7261   if (!argp1) {
7262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7263     return 0;
7264   }
7265   arg1 = *argp1;
7266   argp2 = (Dali::Radian *)jarg2;
7267   if (!argp2) {
7268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7269     return 0;
7270   }
7271   arg2 = *argp2;
7272   {
7273     try {
7274       result = (bool)Dali::operator >(arg1,arg2);
7275     } CALL_CATCH_EXCEPTION(0);
7276   }
7277
7278   jresult = result;
7279   return jresult;
7280 }
7281
7282
7283 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
7284   bool jresult ;
7285   Dali::Radian arg1 ;
7286   Dali::Radian arg2 ;
7287   Dali::Radian *argp1 ;
7288   Dali::Radian *argp2 ;
7289   bool result;
7290
7291   argp1 = (Dali::Radian *)jarg1;
7292   if (!argp1) {
7293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7294     return 0;
7295   }
7296   arg1 = *argp1;
7297   argp2 = (Dali::Radian *)jarg2;
7298   if (!argp2) {
7299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7300     return 0;
7301   }
7302   arg2 = *argp2;
7303   {
7304     try {
7305       result = (bool)Dali::operator <(arg1,arg2);
7306     } CALL_CATCH_EXCEPTION(0);
7307   }
7308
7309   jresult = result;
7310   return jresult;
7311 }
7312
7313
7314 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
7315   bool jresult ;
7316   Dali::Radian arg1 ;
7317   Dali::Degree arg2 ;
7318   Dali::Radian *argp1 ;
7319   Dali::Degree *argp2 ;
7320   bool result;
7321
7322   argp1 = (Dali::Radian *)jarg1;
7323   if (!argp1) {
7324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7325     return 0;
7326   }
7327   arg1 = *argp1;
7328   argp2 = (Dali::Degree *)jarg2;
7329   if (!argp2) {
7330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7331     return 0;
7332   }
7333   arg2 = *argp2;
7334   {
7335     try {
7336       result = (bool)Dali::operator <(arg1,arg2);
7337     } CALL_CATCH_EXCEPTION(0);
7338   }
7339
7340   jresult = result;
7341   return jresult;
7342 }
7343
7344
7345 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
7346   bool jresult ;
7347   Dali::Degree arg1 ;
7348   Dali::Radian arg2 ;
7349   Dali::Degree *argp1 ;
7350   Dali::Radian *argp2 ;
7351   bool result;
7352
7353   argp1 = (Dali::Degree *)jarg1;
7354   if (!argp1) {
7355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7356     return 0;
7357   }
7358   arg1 = *argp1;
7359   argp2 = (Dali::Radian *)jarg2;
7360   if (!argp2) {
7361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7362     return 0;
7363   }
7364   arg2 = *argp2;
7365   {
7366     try {
7367       result = (bool)Dali::operator <(arg1,arg2);
7368     } CALL_CATCH_EXCEPTION(0);
7369   }
7370
7371   jresult = result;
7372   return jresult;
7373 }
7374
7375
7376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
7377   void * jresult ;
7378   Dali::Radian arg1 ;
7379   float arg2 ;
7380   Dali::Radian *argp1 ;
7381   Dali::Radian result;
7382
7383   argp1 = (Dali::Radian *)jarg1;
7384   if (!argp1) {
7385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7386     return 0;
7387   }
7388   arg1 = *argp1;
7389   arg2 = (float)jarg2;
7390   {
7391     try {
7392       result = Dali::operator *(arg1,arg2);
7393     } CALL_CATCH_EXCEPTION(0);
7394   }
7395
7396   jresult = new Dali::Radian((const Dali::Radian &)result);
7397   return jresult;
7398 }
7399
7400
7401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
7402   void * jresult ;
7403   Dali::Radian arg1 ;
7404   Dali::Radian *argp1 ;
7405   Dali::Radian result;
7406
7407   argp1 = (Dali::Radian *)jarg1;
7408   if (!argp1) {
7409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7410     return 0;
7411   }
7412   arg1 = *argp1;
7413   {
7414     try {
7415       result = Dali::operator -(arg1);
7416     } CALL_CATCH_EXCEPTION(0);
7417   }
7418
7419   jresult = new Dali::Radian((const Dali::Radian &)result);
7420   return jresult;
7421 }
7422
7423
7424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
7425   void * jresult ;
7426   Dali::Radian arg1 ;
7427   float arg2 ;
7428   float arg3 ;
7429   Dali::Radian *argp1 ;
7430   Dali::Radian result;
7431
7432   argp1 = (Dali::Radian *)jarg1;
7433   if (!argp1) {
7434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7435     return 0;
7436   }
7437   arg1 = *argp1;
7438   arg2 = (float)jarg2;
7439   arg3 = (float)jarg3;
7440   {
7441     try {
7442       result = Dali::Clamp(arg1,arg2,arg3);
7443     } CALL_CATCH_EXCEPTION(0);
7444   }
7445
7446   jresult = new Dali::Radian((const Dali::Radian &)result);
7447   return jresult;
7448 }
7449
7450
7451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
7452   void * jresult ;
7453   Dali::Matrix *result = 0 ;
7454
7455   {
7456     try {
7457       result = (Dali::Matrix *)new Dali::Matrix();
7458     } CALL_CATCH_EXCEPTION(0);
7459   }
7460
7461   jresult = (void *)result;
7462   return jresult;
7463 }
7464
7465
7466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(bool jarg1) {
7467   void * jresult ;
7468   bool arg1 ;
7469   Dali::Matrix *result = 0 ;
7470
7471   arg1 = jarg1 ? true : false;
7472   {
7473     try {
7474       result = (Dali::Matrix *)new Dali::Matrix(arg1);
7475     } CALL_CATCH_EXCEPTION(0);
7476   }
7477
7478   jresult = (void *)result;
7479   return jresult;
7480 }
7481
7482
7483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
7484   void * jresult ;
7485   float *arg1 = (float *) 0 ;
7486   Dali::Matrix *result = 0 ;
7487
7488   arg1 = jarg1;
7489   {
7490     try {
7491       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
7492     } CALL_CATCH_EXCEPTION(0);
7493   }
7494
7495   jresult = (void *)result;
7496
7497
7498   return jresult;
7499 }
7500
7501
7502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
7503   void * jresult ;
7504   Dali::Quaternion *arg1 = 0 ;
7505   Dali::Matrix *result = 0 ;
7506
7507   arg1 = (Dali::Quaternion *)jarg1;
7508   if (!arg1) {
7509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7510     return 0;
7511   }
7512   {
7513     try {
7514       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
7515     } CALL_CATCH_EXCEPTION(0);
7516   }
7517
7518   jresult = (void *)result;
7519   return jresult;
7520 }
7521
7522
7523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
7524   void * jresult ;
7525   Dali::Matrix *arg1 = 0 ;
7526   Dali::Matrix *result = 0 ;
7527
7528   arg1 = (Dali::Matrix *)jarg1;
7529   if (!arg1) {
7530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7531     return 0;
7532   }
7533   {
7534     try {
7535       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
7536     } CALL_CATCH_EXCEPTION(0);
7537   }
7538
7539   jresult = (void *)result;
7540   return jresult;
7541 }
7542
7543
7544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
7545   void * jresult ;
7546   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7547   Dali::Matrix *arg2 = 0 ;
7548   Dali::Matrix *result = 0 ;
7549
7550   arg1 = (Dali::Matrix *)jarg1;
7551   arg2 = (Dali::Matrix *)jarg2;
7552   if (!arg2) {
7553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7554     return 0;
7555   }
7556   {
7557     try {
7558       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
7559     } CALL_CATCH_EXCEPTION(0);
7560   }
7561
7562   jresult = (void *)result;
7563   return jresult;
7564 }
7565
7566
7567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
7568   void * jresult ;
7569   Dali::Matrix *result = 0 ;
7570
7571   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
7572   jresult = (void *)result;
7573   return jresult;
7574 }
7575
7576
7577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
7578   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7579
7580   arg1 = (Dali::Matrix *)jarg1;
7581   {
7582     try {
7583       (arg1)->SetIdentity();
7584     } CALL_CATCH_EXCEPTION();
7585   }
7586
7587 }
7588
7589
7590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
7591   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7592   Dali::Vector3 *arg2 = 0 ;
7593
7594   arg1 = (Dali::Matrix *)jarg1;
7595   arg2 = (Dali::Vector3 *)jarg2;
7596   if (!arg2) {
7597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7598     return ;
7599   }
7600   {
7601     try {
7602       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
7603     } CALL_CATCH_EXCEPTION();
7604   }
7605
7606 }
7607
7608
7609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
7610   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7611   Dali::Matrix *arg2 = 0 ;
7612
7613   arg1 = (Dali::Matrix *)jarg1;
7614   arg2 = (Dali::Matrix *)jarg2;
7615   if (!arg2) {
7616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
7617     return ;
7618   }
7619   {
7620     try {
7621       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
7622     } CALL_CATCH_EXCEPTION();
7623   }
7624
7625 }
7626
7627
7628 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
7629   bool jresult ;
7630   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7631   bool result;
7632
7633   arg1 = (Dali::Matrix *)jarg1;
7634   {
7635     try {
7636       result = (bool)(arg1)->Invert();
7637     } CALL_CATCH_EXCEPTION(0);
7638   }
7639
7640   jresult = result;
7641   return jresult;
7642 }
7643
7644
7645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
7646   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7647
7648   arg1 = (Dali::Matrix *)jarg1;
7649   {
7650     try {
7651       (arg1)->Transpose();
7652     } CALL_CATCH_EXCEPTION();
7653   }
7654
7655 }
7656
7657
7658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
7659   void * jresult ;
7660   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7661   Dali::Vector3 result;
7662
7663   arg1 = (Dali::Matrix *)jarg1;
7664   {
7665     try {
7666       result = ((Dali::Matrix const *)arg1)->GetXAxis();
7667     } CALL_CATCH_EXCEPTION(0);
7668   }
7669
7670   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7671   return jresult;
7672 }
7673
7674
7675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
7676   void * jresult ;
7677   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7678   Dali::Vector3 result;
7679
7680   arg1 = (Dali::Matrix *)jarg1;
7681   {
7682     try {
7683       result = ((Dali::Matrix const *)arg1)->GetYAxis();
7684     } CALL_CATCH_EXCEPTION(0);
7685   }
7686
7687   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7688   return jresult;
7689 }
7690
7691
7692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
7693   void * jresult ;
7694   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7695   Dali::Vector3 result;
7696
7697   arg1 = (Dali::Matrix *)jarg1;
7698   {
7699     try {
7700       result = ((Dali::Matrix const *)arg1)->GetZAxis();
7701     } CALL_CATCH_EXCEPTION(0);
7702   }
7703
7704   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7705   return jresult;
7706 }
7707
7708
7709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
7710   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7711   Dali::Vector3 *arg2 = 0 ;
7712
7713   arg1 = (Dali::Matrix *)jarg1;
7714   arg2 = (Dali::Vector3 *)jarg2;
7715   if (!arg2) {
7716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7717     return ;
7718   }
7719   {
7720     try {
7721       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
7722     } CALL_CATCH_EXCEPTION();
7723   }
7724
7725 }
7726
7727
7728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
7729   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7730   Dali::Vector3 *arg2 = 0 ;
7731
7732   arg1 = (Dali::Matrix *)jarg1;
7733   arg2 = (Dali::Vector3 *)jarg2;
7734   if (!arg2) {
7735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7736     return ;
7737   }
7738   {
7739     try {
7740       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
7741     } CALL_CATCH_EXCEPTION();
7742   }
7743
7744 }
7745
7746
7747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
7748   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7749   Dali::Vector3 *arg2 = 0 ;
7750
7751   arg1 = (Dali::Matrix *)jarg1;
7752   arg2 = (Dali::Vector3 *)jarg2;
7753   if (!arg2) {
7754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7755     return ;
7756   }
7757   {
7758     try {
7759       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
7760     } CALL_CATCH_EXCEPTION();
7761   }
7762
7763 }
7764
7765
7766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
7767   void * jresult ;
7768   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7769   Dali::Vector4 *result = 0 ;
7770
7771   arg1 = (Dali::Matrix *)jarg1;
7772   {
7773     try {
7774       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
7775     } CALL_CATCH_EXCEPTION(0);
7776   }
7777
7778   jresult = (void *)result;
7779   return jresult;
7780 }
7781
7782
7783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
7784   void * jresult ;
7785   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7786   Dali::Vector3 *result = 0 ;
7787
7788   arg1 = (Dali::Matrix *)jarg1;
7789   {
7790     try {
7791       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
7792     } CALL_CATCH_EXCEPTION(0);
7793   }
7794
7795   jresult = (void *)result;
7796   return jresult;
7797 }
7798
7799
7800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
7801   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7802   Dali::Vector4 *arg2 = 0 ;
7803
7804   arg1 = (Dali::Matrix *)jarg1;
7805   arg2 = (Dali::Vector4 *)jarg2;
7806   if (!arg2) {
7807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7808     return ;
7809   }
7810   {
7811     try {
7812       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
7813     } CALL_CATCH_EXCEPTION();
7814   }
7815
7816 }
7817
7818
7819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
7820   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7821   Dali::Vector3 *arg2 = 0 ;
7822
7823   arg1 = (Dali::Matrix *)jarg1;
7824   arg2 = (Dali::Vector3 *)jarg2;
7825   if (!arg2) {
7826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7827     return ;
7828   }
7829   {
7830     try {
7831       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
7832     } CALL_CATCH_EXCEPTION();
7833   }
7834
7835 }
7836
7837
7838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
7839   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7840
7841   arg1 = (Dali::Matrix *)jarg1;
7842   {
7843     try {
7844       (arg1)->OrthoNormalize();
7845     } CALL_CATCH_EXCEPTION();
7846   }
7847
7848 }
7849
7850
7851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
7852   void * jresult ;
7853   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7854   float *result = 0 ;
7855
7856   arg1 = (Dali::Matrix *)jarg1;
7857   {
7858     try {
7859       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
7860     } CALL_CATCH_EXCEPTION(0);
7861   }
7862
7863   jresult = (void *)result;
7864   return jresult;
7865 }
7866
7867
7868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
7869   Dali::Matrix *arg1 = 0 ;
7870   Dali::Matrix *arg2 = 0 ;
7871   Dali::Matrix *arg3 = 0 ;
7872
7873   arg1 = (Dali::Matrix *)jarg1;
7874   if (!arg1) {
7875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
7876     return ;
7877   }
7878   arg2 = (Dali::Matrix *)jarg2;
7879   if (!arg2) {
7880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7881     return ;
7882   }
7883   arg3 = (Dali::Matrix *)jarg3;
7884   if (!arg3) {
7885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7886     return ;
7887   }
7888   {
7889     try {
7890       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
7891     } CALL_CATCH_EXCEPTION();
7892   }
7893
7894 }
7895
7896
7897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
7898   Dali::Matrix *arg1 = 0 ;
7899   Dali::Matrix *arg2 = 0 ;
7900   Dali::Quaternion *arg3 = 0 ;
7901
7902   arg1 = (Dali::Matrix *)jarg1;
7903   if (!arg1) {
7904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
7905     return ;
7906   }
7907   arg2 = (Dali::Matrix *)jarg2;
7908   if (!arg2) {
7909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7910     return ;
7911   }
7912   arg3 = (Dali::Quaternion *)jarg3;
7913   if (!arg3) {
7914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7915     return ;
7916   }
7917   {
7918     try {
7919       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
7920     } CALL_CATCH_EXCEPTION();
7921   }
7922
7923 }
7924
7925
7926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
7927   void * jresult ;
7928   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7929   Dali::Vector4 *arg2 = 0 ;
7930   Dali::Vector4 result;
7931
7932   arg1 = (Dali::Matrix *)jarg1;
7933   if (!arg1) {
7934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7935     return 0;
7936   }
7937   arg2 = (Dali::Vector4 *)jarg2;
7938   if (!arg2) {
7939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7940     return 0;
7941   }
7942   {
7943     try {
7944       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7945     } CALL_CATCH_EXCEPTION(0);
7946   }
7947
7948   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7949   return jresult;
7950 }
7951
7952
7953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_3(void * nuiMatrixLhs, void * nuiMatrixRhs) {
7954   void * jresult ;
7955   Dali::Matrix *lhsPtr = (Dali::Matrix *) 0 ;
7956   Dali::Matrix *rhsPtr = (Dali::Matrix *) 0 ;
7957   Dali::Matrix result(false);
7958
7959   lhsPtr = (Dali::Matrix *)nuiMatrixLhs;
7960   if (!lhsPtr) {
7961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix const & type is null", 0);
7962     return 0;
7963   }
7964   rhsPtr = (Dali::Matrix *)nuiMatrixRhs;
7965   if (!rhsPtr) {
7966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix const & type is null", 0);
7967     return 0;
7968   }
7969   {
7970     try {
7971       result = ((Dali::Matrix const *)lhsPtr)->operator *((Dali::Matrix const &)*rhsPtr);
7972     } CALL_CATCH_EXCEPTION(0);
7973   }
7974
7975   jresult = new Dali::Matrix((const Dali::Matrix &)result);
7976   return jresult;
7977 }
7978
7979
7980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_4(void * nuiMatrixLhs, void * nuiMatrixRhs) {
7981   // Faster mulitply operation without memcpy
7982
7983   Dali::Matrix *jresult = (Dali::Matrix *)0;
7984   Dali::Matrix *lhsPtr  = (Dali::Matrix *)0;
7985   Dali::Matrix *rhsPtr  = (Dali::Matrix *)0;
7986
7987   lhsPtr = (Dali::Matrix *)nuiMatrixLhs;
7988   if (!lhsPtr) {
7989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix const & type is null", 0);
7990     return 0;
7991   }
7992   rhsPtr = (Dali::Matrix *)nuiMatrixRhs;
7993   if (!rhsPtr) {
7994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix const & type is null", 0);
7995     return 0;
7996   }
7997   {
7998     try {
7999       jresult = new Dali::Matrix(false);
8000       Dali::Matrix::Multiply((Dali::Matrix &)*jresult,(Dali::Matrix const &)*rhsPtr,(Dali::Matrix const &)*lhsPtr);
8001     } CALL_CATCH_EXCEPTION(0);
8002   }
8003
8004   return jresult;
8005 }
8006
8007
8008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_MultiplyAssign(void * nuiMatrix, void * nuiMatrixRhs) {
8009   void * jresult = 0;
8010   Dali::Matrix *lhsPtr = (Dali::Matrix *) 0 ;
8011   Dali::Matrix *rhsPtr = (Dali::Matrix *) 0 ;
8012   Dali::Matrix *retPtr = (Dali::Matrix *) 0 ;
8013
8014   lhsPtr = (Dali::Matrix *)nuiMatrix;
8015   if (!lhsPtr) {
8016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix const & type is null", 0);
8017     return 0;
8018   }
8019   rhsPtr = (Dali::Matrix *)nuiMatrixRhs;
8020   if (!rhsPtr) {
8021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix const & type is null", 0);
8022     return 0;
8023   }
8024   {
8025     try {
8026       retPtr = (Dali::Matrix *) &(lhsPtr)->operator *=((Dali::Matrix const &)*rhsPtr);
8027     } CALL_CATCH_EXCEPTION(0);
8028   }
8029
8030   jresult = (void *)retPtr;
8031   return jresult;
8032 }
8033
8034
8035 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
8036   bool jresult ;
8037   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8038   Dali::Matrix *arg2 = 0 ;
8039   bool result;
8040
8041   arg1 = (Dali::Matrix *)jarg1;
8042   arg2 = (Dali::Matrix *)jarg2;
8043   if (!arg2) {
8044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8045     return 0;
8046   }
8047   {
8048     try {
8049       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
8050     } CALL_CATCH_EXCEPTION(0);
8051   }
8052
8053   jresult = result;
8054   return jresult;
8055 }
8056
8057
8058 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
8059   bool jresult ;
8060   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8061   Dali::Matrix *arg2 = 0 ;
8062   bool result;
8063
8064   arg1 = (Dali::Matrix *)jarg1;
8065   arg2 = (Dali::Matrix *)jarg2;
8066   if (!arg2) {
8067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8068     return 0;
8069   }
8070   {
8071     try {
8072       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
8073     } CALL_CATCH_EXCEPTION(0);
8074   }
8075
8076   jresult = result;
8077   return jresult;
8078 }
8079
8080 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix_ValueOfIndex__SWIG_0(void * nuiMatrix, unsigned int index) {
8081   float jresult ;
8082   Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ;
8083
8084   pMatrix = (Dali::Matrix *)nuiMatrix;
8085   if (!pMatrix) {
8086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8087     return 0;
8088   }
8089   if (index >= 16) {
8090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 16.)", 0);
8091     return 0;
8092   }
8093   {
8094     try {
8095       const float* temp = ((Dali::Matrix const *)pMatrix)->AsFloat();
8096       jresult = temp[index];
8097     } CALL_CATCH_EXCEPTION(0);
8098   }
8099   return jresult;
8100 }
8101
8102 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix_ValueOfIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn) {
8103   float jresult ;
8104   Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ;
8105
8106   pMatrix = (Dali::Matrix *)nuiMatrix;
8107   if (!pMatrix) {
8108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8109     return 0;
8110   }
8111   if (indexRow >= 4) {
8112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 4.)", 0);
8113     return 0;
8114   }
8115   if (indexColumn >= 4) {
8116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 4.)", 0);
8117     return 0;
8118   }
8119   {
8120     try {
8121       const float* temp = ((Dali::Matrix const *)pMatrix)->AsFloat();
8122       jresult = temp[(indexColumn << 2) | indexRow];
8123     } CALL_CATCH_EXCEPTION(0);
8124   }
8125   return jresult;
8126 }
8127
8128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetValueAtIndex__SWIG_0(void * nuiMatrix, unsigned int index, float value) {
8129   Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ;
8130
8131   pMatrix = (Dali::Matrix *)nuiMatrix;
8132   if (!pMatrix) {
8133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8134     return;
8135   }
8136   if (index >= 16) {
8137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 16.)", 0);
8138     return;
8139   }
8140   {
8141     try {
8142       float* temp = ((Dali::Matrix *)pMatrix)->AsFloat();
8143       temp[index] = value;
8144     } CALL_CATCH_EXCEPTION();
8145   }
8146 }
8147
8148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetValueAtIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn, float value) {
8149   Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ;
8150
8151   pMatrix = (Dali::Matrix *)nuiMatrix;
8152   if (!pMatrix) {
8153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8154     return;
8155   }
8156   if (indexRow >= 4) {
8157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 4.)", 0);
8158     return;
8159   }
8160   if (indexColumn >= 4) {
8161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 4.)", 0);
8162     return;
8163   }
8164   {
8165     try {
8166       float* temp = ((Dali::Matrix *)pMatrix)->AsFloat();
8167       temp[(indexColumn << 2) | indexRow] = value;
8168     } CALL_CATCH_EXCEPTION();
8169   }
8170 }
8171
8172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
8173   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8174   Dali::Vector3 *arg2 = 0 ;
8175   Dali::Quaternion *arg3 = 0 ;
8176   Dali::Vector3 *arg4 = 0 ;
8177
8178   arg1 = (Dali::Matrix *)jarg1;
8179   arg2 = (Dali::Vector3 *)jarg2;
8180   if (!arg2) {
8181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8182     return ;
8183   }
8184   arg3 = (Dali::Quaternion *)jarg3;
8185   if (!arg3) {
8186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8187     return ;
8188   }
8189   arg4 = (Dali::Vector3 *)jarg4;
8190   if (!arg4) {
8191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8192     return ;
8193   }
8194   {
8195     try {
8196       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
8197     } CALL_CATCH_EXCEPTION();
8198   }
8199
8200 }
8201
8202
8203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
8204   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8205   Dali::Vector3 *arg2 = 0 ;
8206   Dali::Quaternion *arg3 = 0 ;
8207   Dali::Vector3 *arg4 = 0 ;
8208
8209   arg1 = (Dali::Matrix *)jarg1;
8210   arg2 = (Dali::Vector3 *)jarg2;
8211   if (!arg2) {
8212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8213     return ;
8214   }
8215   arg3 = (Dali::Quaternion *)jarg3;
8216   if (!arg3) {
8217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8218     return ;
8219   }
8220   arg4 = (Dali::Vector3 *)jarg4;
8221   if (!arg4) {
8222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8223     return ;
8224   }
8225   {
8226     try {
8227       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
8228     } CALL_CATCH_EXCEPTION();
8229   }
8230
8231 }
8232
8233
8234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
8235   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8236   Dali::Vector3 *arg2 = 0 ;
8237   Dali::Vector3 *arg3 = 0 ;
8238   Dali::Vector3 *arg4 = 0 ;
8239   Dali::Vector3 *arg5 = 0 ;
8240
8241   arg1 = (Dali::Matrix *)jarg1;
8242   arg2 = (Dali::Vector3 *)jarg2;
8243   if (!arg2) {
8244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8245     return ;
8246   }
8247   arg3 = (Dali::Vector3 *)jarg3;
8248   if (!arg3) {
8249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8250     return ;
8251   }
8252   arg4 = (Dali::Vector3 *)jarg4;
8253   if (!arg4) {
8254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8255     return ;
8256   }
8257   arg5 = (Dali::Vector3 *)jarg5;
8258   if (!arg5) {
8259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8260     return ;
8261   }
8262   {
8263     try {
8264       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
8265     } CALL_CATCH_EXCEPTION();
8266   }
8267
8268 }
8269
8270
8271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
8272   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8273   Dali::Vector3 *arg2 = 0 ;
8274   Dali::Quaternion *arg3 = 0 ;
8275   Dali::Vector3 *arg4 = 0 ;
8276
8277   arg1 = (Dali::Matrix *)jarg1;
8278   arg2 = (Dali::Vector3 *)jarg2;
8279   if (!arg2) {
8280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
8281     return ;
8282   }
8283   arg3 = (Dali::Quaternion *)jarg3;
8284   if (!arg3) {
8285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
8286     return ;
8287   }
8288   arg4 = (Dali::Vector3 *)jarg4;
8289   if (!arg4) {
8290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
8291     return ;
8292   }
8293   {
8294     try {
8295       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
8296     } CALL_CATCH_EXCEPTION();
8297   }
8298
8299 }
8300
8301
8302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
8303   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8304
8305   arg1 = (Dali::Matrix *)jarg1;
8306   {
8307     try {
8308       delete arg1;
8309     } CALL_CATCH_EXCEPTION();
8310   }
8311
8312 }
8313
8314
8315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
8316   void * jresult ;
8317   Dali::Matrix3 *result = 0 ;
8318
8319   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
8320   jresult = (void *)result;
8321   return jresult;
8322 }
8323
8324
8325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
8326   void * jresult ;
8327   Dali::Matrix3 *result = 0 ;
8328
8329   {
8330     try {
8331       result = (Dali::Matrix3 *)new Dali::Matrix3();
8332     } CALL_CATCH_EXCEPTION(0);
8333   }
8334
8335   jresult = (void *)result;
8336   return jresult;
8337 }
8338
8339
8340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
8341   void * jresult ;
8342   Dali::Matrix3 *arg1 = 0 ;
8343   Dali::Matrix3 *result = 0 ;
8344
8345   arg1 = (Dali::Matrix3 *)jarg1;
8346   if (!arg1) {
8347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8348     return 0;
8349   }
8350   {
8351     try {
8352       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
8353     } CALL_CATCH_EXCEPTION(0);
8354   }
8355
8356   jresult = (void *)result;
8357   return jresult;
8358 }
8359
8360
8361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
8362   void * jresult ;
8363   Dali::Matrix *arg1 = 0 ;
8364   Dali::Matrix3 *result = 0 ;
8365
8366   arg1 = (Dali::Matrix *)jarg1;
8367   if (!arg1) {
8368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8369     return 0;
8370   }
8371   {
8372     try {
8373       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
8374     } CALL_CATCH_EXCEPTION(0);
8375   }
8376
8377   jresult = (void *)result;
8378   return jresult;
8379 }
8380
8381
8382 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) {
8383   void * jresult ;
8384   float arg1 ;
8385   float arg2 ;
8386   float arg3 ;
8387   float arg4 ;
8388   float arg5 ;
8389   float arg6 ;
8390   float arg7 ;
8391   float arg8 ;
8392   float arg9 ;
8393   Dali::Matrix3 *result = 0 ;
8394
8395   arg1 = (float)jarg1;
8396   arg2 = (float)jarg2;
8397   arg3 = (float)jarg3;
8398   arg4 = (float)jarg4;
8399   arg5 = (float)jarg5;
8400   arg6 = (float)jarg6;
8401   arg7 = (float)jarg7;
8402   arg8 = (float)jarg8;
8403   arg9 = (float)jarg9;
8404   {
8405     try {
8406       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
8407     } CALL_CATCH_EXCEPTION(0);
8408   }
8409
8410   jresult = (void *)result;
8411   return jresult;
8412 }
8413
8414
8415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
8416   void * jresult ;
8417   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8418   Dali::Matrix3 *arg2 = 0 ;
8419   Dali::Matrix3 *result = 0 ;
8420
8421   arg1 = (Dali::Matrix3 *)jarg1;
8422   arg2 = (Dali::Matrix3 *)jarg2;
8423   if (!arg2) {
8424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8425     return 0;
8426   }
8427   {
8428     try {
8429       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
8430     } CALL_CATCH_EXCEPTION(0);
8431   }
8432
8433   jresult = (void *)result;
8434   return jresult;
8435 }
8436
8437
8438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
8439   void * jresult ;
8440   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8441   Dali::Matrix *arg2 = 0 ;
8442   Dali::Matrix3 *result = 0 ;
8443
8444   arg1 = (Dali::Matrix3 *)jarg1;
8445   arg2 = (Dali::Matrix *)jarg2;
8446   if (!arg2) {
8447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8448     return 0;
8449   }
8450   {
8451     try {
8452       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
8453     } CALL_CATCH_EXCEPTION(0);
8454   }
8455
8456   jresult = (void *)result;
8457   return jresult;
8458 }
8459
8460
8461 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
8462   bool jresult ;
8463   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8464   Dali::Matrix3 *arg2 = 0 ;
8465   bool result;
8466
8467   arg1 = (Dali::Matrix3 *)jarg1;
8468   arg2 = (Dali::Matrix3 *)jarg2;
8469   if (!arg2) {
8470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8471     return 0;
8472   }
8473   {
8474     try {
8475       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
8476     } CALL_CATCH_EXCEPTION(0);
8477   }
8478
8479   jresult = result;
8480   return jresult;
8481 }
8482
8483
8484 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
8485   bool jresult ;
8486   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8487   Dali::Matrix3 *arg2 = 0 ;
8488   bool result;
8489
8490   arg1 = (Dali::Matrix3 *)jarg1;
8491   arg2 = (Dali::Matrix3 *)jarg2;
8492   if (!arg2) {
8493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8494     return 0;
8495   }
8496   {
8497     try {
8498       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
8499     } CALL_CATCH_EXCEPTION(0);
8500   }
8501
8502   jresult = result;
8503   return jresult;
8504 }
8505
8506
8507 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_ValueOfIndex__SWIG_0(void * nuiMatrix, unsigned int index) {
8508   float jresult ;
8509   Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ;
8510
8511   pMatrix = (Dali::Matrix3 *)nuiMatrix;
8512   if (!pMatrix) {
8513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8514     return 0;
8515   }
8516   if (index >= 9) {
8517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 9.)", 0);
8518     return 0;
8519   }
8520   {
8521     try {
8522       const float* temp = ((Dali::Matrix3 const *)pMatrix)->AsFloat();
8523       jresult = temp[index];
8524     } CALL_CATCH_EXCEPTION(0);
8525   }
8526   return jresult;
8527 }
8528
8529 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_ValueOfIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn) {
8530   float jresult ;
8531   Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ;
8532
8533   pMatrix = (Dali::Matrix3 *)nuiMatrix;
8534   if (!pMatrix) {
8535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8536     return 0;
8537   }
8538   if (indexRow >= 3) {
8539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 3.)", 0);
8540     return 0;
8541   }
8542   if (indexColumn >= 3) {
8543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 3.)", 0);
8544     return 0;
8545   }
8546   {
8547     try {
8548       const float* temp = ((Dali::Matrix3 const *)pMatrix)->AsFloat();
8549       jresult = temp[indexColumn * 3 + indexRow];
8550     } CALL_CATCH_EXCEPTION(0);
8551   }
8552   return jresult;
8553 }
8554
8555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetValueAtIndex__SWIG_0(void * nuiMatrix, unsigned int index, float value) {
8556   Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ;
8557
8558   pMatrix = (Dali::Matrix3 *)nuiMatrix;
8559   if (!pMatrix) {
8560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8561     return;
8562   }
8563   if (index >= 9) {
8564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 9.)", 0);
8565     return;
8566   }
8567   {
8568     try {
8569       float* temp = ((Dali::Matrix3 *)pMatrix)->AsFloat();
8570       temp[index] = value;
8571     } CALL_CATCH_EXCEPTION();
8572   }
8573 }
8574
8575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetValueAtIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn, float value) {
8576   Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ;
8577
8578   pMatrix = (Dali::Matrix3 *)nuiMatrix;
8579   if (!pMatrix) {
8580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8581     return;
8582   }
8583   if (indexRow >= 3) {
8584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 3.)", 0);
8585     return;
8586   }
8587   if (indexColumn >= 3) {
8588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 3.)", 0);
8589     return;
8590   }
8591   {
8592     try {
8593       float* temp = ((Dali::Matrix3 *)pMatrix)->AsFloat();
8594       temp[indexColumn * 3 + indexRow] = value;
8595     } CALL_CATCH_EXCEPTION();
8596   }
8597 }
8598
8599
8600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
8601   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8602
8603   arg1 = (Dali::Matrix3 *)jarg1;
8604   {
8605     try {
8606       delete arg1;
8607     } CALL_CATCH_EXCEPTION();
8608   }
8609
8610 }
8611
8612
8613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
8614   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8615
8616   arg1 = (Dali::Matrix3 *)jarg1;
8617   {
8618     try {
8619       (arg1)->SetIdentity();
8620     } CALL_CATCH_EXCEPTION();
8621   }
8622
8623 }
8624
8625
8626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
8627   void * jresult ;
8628   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8629   float *result = 0 ;
8630
8631   arg1 = (Dali::Matrix3 *)jarg1;
8632   {
8633     try {
8634       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
8635     } CALL_CATCH_EXCEPTION(0);
8636   }
8637
8638   jresult = (void *)result;
8639   return jresult;
8640 }
8641
8642
8643 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
8644   bool jresult ;
8645   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8646   bool result;
8647
8648   arg1 = (Dali::Matrix3 *)jarg1;
8649   {
8650     try {
8651       result = (bool)(arg1)->Invert();
8652     } CALL_CATCH_EXCEPTION(0);
8653   }
8654
8655   jresult = result;
8656   return jresult;
8657 }
8658
8659
8660 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
8661   bool jresult ;
8662   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8663   bool result;
8664
8665   arg1 = (Dali::Matrix3 *)jarg1;
8666   {
8667     try {
8668       result = (bool)(arg1)->Transpose();
8669     } CALL_CATCH_EXCEPTION(0);
8670   }
8671
8672   jresult = result;
8673   return jresult;
8674 }
8675
8676
8677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
8678   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8679   float arg2 ;
8680
8681   arg1 = (Dali::Matrix3 *)jarg1;
8682   arg2 = (float)jarg2;
8683   {
8684     try {
8685       (arg1)->Scale(arg2);
8686     } CALL_CATCH_EXCEPTION();
8687   }
8688
8689 }
8690
8691
8692 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
8693   float jresult ;
8694   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8695   float result;
8696
8697   arg1 = (Dali::Matrix3 *)jarg1;
8698   {
8699     try {
8700       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
8701     } CALL_CATCH_EXCEPTION(0);
8702   }
8703
8704   jresult = result;
8705   return jresult;
8706 }
8707
8708
8709 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
8710   bool jresult ;
8711   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8712   bool result;
8713
8714   arg1 = (Dali::Matrix3 *)jarg1;
8715   {
8716     try {
8717       result = (bool)(arg1)->ScaledInverseTranspose();
8718     } CALL_CATCH_EXCEPTION(0);
8719   }
8720
8721   jresult = result;
8722   return jresult;
8723 }
8724
8725
8726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
8727   Dali::Matrix3 *arg1 = 0 ;
8728   Dali::Matrix3 *arg2 = 0 ;
8729   Dali::Matrix3 *arg3 = 0 ;
8730
8731   arg1 = (Dali::Matrix3 *)jarg1;
8732   if (!arg1) {
8733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
8734     return ;
8735   }
8736   arg2 = (Dali::Matrix3 *)jarg2;
8737   if (!arg2) {
8738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8739     return ;
8740   }
8741   arg3 = (Dali::Matrix3 *)jarg3;
8742   if (!arg3) {
8743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8744     return ;
8745   }
8746   {
8747     try {
8748       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
8749     } CALL_CATCH_EXCEPTION();
8750   }
8751
8752 }
8753
8754
8755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Multiply__SWIG_1(void * jarg1, void * jarg2) {
8756   void * jresult ;
8757   Dali::Matrix3 *arg1 = 0 ;
8758   Dali::Vector3 *arg2 = 0 ;
8759   Dali::Vector3 result;
8760
8761   arg1 = (Dali::Matrix3 *)jarg1;
8762   if (!arg1) {
8763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8764     return 0;
8765   }
8766   arg2 = (Dali::Vector3 *)jarg2;
8767   if (!arg2) {
8768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8769     return 0;
8770   }
8771   {
8772     try {
8773       result = ((Dali::Matrix3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
8774     } CALL_CATCH_EXCEPTION(0);
8775   }
8776
8777   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
8778   return jresult;
8779 }
8780
8781
8782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Multiply__SWIG_2(void * nuiMatrix3Lhs, void * nuiMatrix3Rhs) {
8783   void * jresult ;
8784   Dali::Matrix3 *lhsPtr = 0 ;
8785   Dali::Matrix3 *rhsPtr = 0 ;
8786   Dali::Matrix3 result;
8787
8788   lhsPtr = (Dali::Matrix3 *)nuiMatrix3Lhs;
8789   if (!lhsPtr) {
8790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix3 const & type is null", 0);
8791     return 0;
8792   }
8793   rhsPtr = (Dali::Matrix3 *)nuiMatrix3Rhs;
8794   if (!rhsPtr) {
8795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix3 const & type is null", 0);
8796     return 0;
8797   }
8798   {
8799     try {
8800       result = ((Dali::Matrix3 const *)lhsPtr)->operator *((Dali::Matrix3 const &)*rhsPtr);
8801     } CALL_CATCH_EXCEPTION(0);
8802   }
8803
8804   jresult = new Dali::Matrix3((const Dali::Matrix3 &)result);
8805   return jresult;
8806 }
8807
8808
8809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Multiply__SWIG_3(void * nuiMatrix3Lhs, void * nuiMatrix3Rhs) {
8810   // Faster mulitply operation without memcpy
8811
8812   Dali::Matrix3 *jresult = 0;
8813   Dali::Matrix3 *lhsPtr  = 0;
8814   Dali::Matrix3 *rhsPtr  = 0;
8815
8816   lhsPtr = (Dali::Matrix3 *)nuiMatrix3Lhs;
8817   if (!lhsPtr) {
8818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix3 const & type is null", 0);
8819     return 0;
8820   }
8821   rhsPtr = (Dali::Matrix3 *)nuiMatrix3Rhs;
8822   if (!rhsPtr) {
8823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix3 const & type is null", 0);
8824     return 0;
8825   }
8826   {
8827     try {
8828       jresult = new Dali::Matrix3();
8829       Dali::Matrix3::Multiply((Dali::Matrix3 &)*jresult,(Dali::Matrix3 const &)*rhsPtr,(Dali::Matrix3 const &)*lhsPtr);
8830     } CALL_CATCH_EXCEPTION(0);
8831   }
8832
8833   return jresult;
8834 }
8835
8836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_MultiplyAssign(void * nuiMatrix, void * nuiMatrixRhs) {
8837   void * jresult = 0;
8838   Dali::Matrix3 *lhsPtr = (Dali::Matrix3 *) 0 ;
8839   Dali::Matrix3 *rhsPtr = (Dali::Matrix3 *) 0 ;
8840   Dali::Matrix3 *retPtr = (Dali::Matrix3 *) 0 ;
8841
8842   lhsPtr = (Dali::Matrix3 *)nuiMatrix;
8843   if (!lhsPtr) {
8844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix3 const & type is null", 0);
8845     return 0;
8846   }
8847   rhsPtr = (Dali::Matrix3 *)nuiMatrixRhs;
8848   if (!rhsPtr) {
8849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix3 const & type is null", 0);
8850     return 0;
8851   }
8852   {
8853     try {
8854       retPtr = (Dali::Matrix3 *) &(lhsPtr)->operator *=((Dali::Matrix3 const &)*rhsPtr);
8855     } CALL_CATCH_EXCEPTION(0);
8856   }
8857
8858   jresult = (void *)retPtr;
8859   return jresult;
8860 }
8861
8862
8863 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
8864   float jresult ;
8865   float arg1 ;
8866   float arg2 ;
8867   float result;
8868
8869   arg1 = (float)jarg1;
8870   arg2 = (float)jarg2;
8871   {
8872     try {
8873       result = (float)Dali::Random::Range(arg1,arg2);
8874     } CALL_CATCH_EXCEPTION(0);
8875   }
8876
8877   jresult = result;
8878   return jresult;
8879 }
8880
8881
8882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
8883   void * jresult ;
8884   Dali::Vector4 result;
8885
8886   {
8887     try {
8888       result = Dali::Random::Axis();
8889     } CALL_CATCH_EXCEPTION(0);
8890   }
8891
8892   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8893   return jresult;
8894 }
8895
8896
8897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
8898   void * jresult ;
8899   Dali::AngleAxis *result = 0 ;
8900
8901   {
8902     try {
8903       result = (Dali::AngleAxis *)new Dali::AngleAxis();
8904     } CALL_CATCH_EXCEPTION(0);
8905   }
8906
8907   jresult = (void *)result;
8908   return jresult;
8909 }
8910
8911
8912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
8913   void * jresult ;
8914   Dali::Radian arg1 ;
8915   Dali::Vector3 *arg2 = 0 ;
8916   Dali::Radian *argp1 ;
8917   Dali::AngleAxis *result = 0 ;
8918
8919   argp1 = (Dali::Radian *)jarg1;
8920   if (!argp1) {
8921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8922     return 0;
8923   }
8924   arg1 = *argp1;
8925   arg2 = (Dali::Vector3 *)jarg2;
8926   if (!arg2) {
8927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8928     return 0;
8929   }
8930   {
8931     try {
8932       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
8933     } CALL_CATCH_EXCEPTION(0);
8934   }
8935
8936   jresult = (void *)result;
8937   return jresult;
8938 }
8939
8940
8941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
8942   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
8943   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
8944
8945   arg1 = (Dali::AngleAxis *)jarg1;
8946   arg2 = (Dali::Radian *)jarg2;
8947   if (arg1) (arg1)->angle = *arg2;
8948 }
8949
8950
8951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
8952   void * jresult ;
8953   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
8954   Dali::Radian *result = 0 ;
8955
8956   arg1 = (Dali::AngleAxis *)jarg1;
8957   result = (Dali::Radian *)& ((arg1)->angle);
8958   jresult = (void *)result;
8959   return jresult;
8960 }
8961
8962
8963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
8964   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
8965   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
8966
8967   arg1 = (Dali::AngleAxis *)jarg1;
8968   arg2 = (Dali::Vector3 *)jarg2;
8969   if (arg1) (arg1)->axis = *arg2;
8970 }
8971
8972
8973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
8974   void * jresult ;
8975   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
8976   Dali::Vector3 *result = 0 ;
8977
8978   arg1 = (Dali::AngleAxis *)jarg1;
8979   result = (Dali::Vector3 *)& ((arg1)->axis);
8980   jresult = (void *)result;
8981   return jresult;
8982 }
8983
8984
8985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
8986   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
8987
8988   arg1 = (Dali::AngleAxis *)jarg1;
8989   {
8990     try {
8991       delete arg1;
8992     } CALL_CATCH_EXCEPTION();
8993   }
8994
8995 }
8996
8997
8998 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
8999   bool jresult ;
9000   Dali::AngleAxis *arg1 = 0 ;
9001   Dali::AngleAxis *arg2 = 0 ;
9002   bool result;
9003
9004   arg1 = (Dali::AngleAxis *)jarg1;
9005   if (!arg1) {
9006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
9007     return 0;
9008   }
9009   arg2 = (Dali::AngleAxis *)jarg2;
9010   if (!arg2) {
9011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
9012     return 0;
9013   }
9014   {
9015     try {
9016       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
9017     } CALL_CATCH_EXCEPTION(0);
9018   }
9019
9020   jresult = result;
9021   return jresult;
9022 }
9023
9024
9025 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
9026   unsigned int jresult ;
9027   unsigned int arg1 ;
9028   unsigned int result;
9029
9030   arg1 = (unsigned int)jarg1;
9031   {
9032     try {
9033       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
9034     } CALL_CATCH_EXCEPTION(0);
9035   }
9036
9037   jresult = result;
9038   return jresult;
9039 }
9040
9041
9042 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
9043   bool jresult ;
9044   unsigned int arg1 ;
9045   bool result;
9046
9047   arg1 = (unsigned int)jarg1;
9048   {
9049     try {
9050       result = (bool)Dali::IsPowerOfTwo(arg1);
9051     } CALL_CATCH_EXCEPTION(0);
9052   }
9053
9054   jresult = result;
9055   return jresult;
9056 }
9057
9058
9059 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
9060   float jresult ;
9061   float arg1 ;
9062   float arg2 ;
9063   float result;
9064
9065   arg1 = (float)jarg1;
9066   arg2 = (float)jarg2;
9067   {
9068     try {
9069       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
9070     } CALL_CATCH_EXCEPTION(0);
9071   }
9072
9073   jresult = result;
9074   return jresult;
9075 }
9076
9077
9078 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
9079   bool jresult ;
9080   float arg1 ;
9081   bool result;
9082
9083   arg1 = (float)jarg1;
9084   {
9085     try {
9086       result = (bool)Dali::EqualsZero(arg1);
9087     } CALL_CATCH_EXCEPTION(0);
9088   }
9089
9090   jresult = result;
9091   return jresult;
9092 }
9093
9094
9095 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
9096   bool jresult ;
9097   float arg1 ;
9098   float arg2 ;
9099   bool result;
9100
9101   arg1 = (float)jarg1;
9102   arg2 = (float)jarg2;
9103   {
9104     try {
9105       result = (bool)Dali::Equals(arg1,arg2);
9106     } CALL_CATCH_EXCEPTION(0);
9107   }
9108
9109   jresult = result;
9110   return jresult;
9111 }
9112
9113
9114 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
9115   bool jresult ;
9116   float arg1 ;
9117   float arg2 ;
9118   float arg3 ;
9119   bool result;
9120
9121   arg1 = (float)jarg1;
9122   arg2 = (float)jarg2;
9123   arg3 = (float)jarg3;
9124   {
9125     try {
9126       result = (bool)Dali::Equals(arg1,arg2,arg3);
9127     } CALL_CATCH_EXCEPTION(0);
9128   }
9129
9130   jresult = result;
9131   return jresult;
9132 }
9133
9134
9135 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
9136   float jresult ;
9137   float arg1 ;
9138   int arg2 ;
9139   float result;
9140
9141   arg1 = (float)jarg1;
9142   arg2 = (int)jarg2;
9143   {
9144     try {
9145       result = (float)Dali::Round(arg1,arg2);
9146     } CALL_CATCH_EXCEPTION(0);
9147   }
9148
9149   jresult = result;
9150   return jresult;
9151 }
9152
9153
9154 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
9155   float jresult ;
9156   float arg1 ;
9157   float arg2 ;
9158   float arg3 ;
9159   float result;
9160
9161   arg1 = (float)jarg1;
9162   arg2 = (float)jarg2;
9163   arg3 = (float)jarg3;
9164   {
9165     try {
9166       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
9167     } CALL_CATCH_EXCEPTION(0);
9168   }
9169
9170   jresult = result;
9171   return jresult;
9172 }
9173
9174
9175 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
9176   float jresult ;
9177   float arg1 ;
9178   float arg2 ;
9179   float arg3 ;
9180   float arg4 ;
9181   float result;
9182
9183   arg1 = (float)jarg1;
9184   arg2 = (float)jarg2;
9185   arg3 = (float)jarg3;
9186   arg4 = (float)jarg4;
9187   {
9188     try {
9189       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
9190     } CALL_CATCH_EXCEPTION(0);
9191   }
9192
9193   jresult = result;
9194   return jresult;
9195 }
9196
9197
9198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
9199   int jresult ;
9200   int result;
9201
9202   result = (int)(int)Dali::Property::INVALID_INDEX;
9203   jresult = result;
9204   return jresult;
9205 }
9206
9207
9208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
9209   int jresult ;
9210   int result;
9211
9212   result = (int)(int)Dali::Property::INVALID_KEY;
9213   jresult = result;
9214   return jresult;
9215 }
9216
9217
9218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
9219   int jresult ;
9220   int result;
9221
9222   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
9223   jresult = result;
9224   return jresult;
9225 }
9226
9227
9228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
9229   void * jresult ;
9230   Dali::Handle *arg1 = 0 ;
9231   Dali::Property::Index arg2 ;
9232   Dali::Property *result = 0 ;
9233
9234   arg1 = (Dali::Handle *)jarg1;
9235   if (!arg1) {
9236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9237     return 0;
9238   }
9239   arg2 = (Dali::Property::Index)jarg2;
9240   {
9241     try {
9242       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
9243     } CALL_CATCH_EXCEPTION(0);
9244   }
9245
9246   jresult = (void *)result;
9247   return jresult;
9248 }
9249
9250
9251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
9252   void * jresult ;
9253   Dali::Handle *arg1 = 0 ;
9254   Dali::Property::Index arg2 ;
9255   int arg3 ;
9256   Dali::Property *result = 0 ;
9257
9258   arg1 = (Dali::Handle *)jarg1;
9259   if (!arg1) {
9260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9261     return 0;
9262   }
9263   arg2 = (Dali::Property::Index)jarg2;
9264   arg3 = (int)jarg3;
9265   {
9266     try {
9267       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
9268     } CALL_CATCH_EXCEPTION(0);
9269   }
9270
9271   jresult = (void *)result;
9272   return jresult;
9273 }
9274
9275
9276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
9277   void * jresult ;
9278   Dali::Handle *arg1 = 0 ;
9279   std::string *arg2 = 0 ;
9280   Dali::Property *result = 0 ;
9281
9282   arg1 = (Dali::Handle *)jarg1;
9283   if (!arg1) {
9284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9285     return 0;
9286   }
9287   if (!jarg2) {
9288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9289     return 0;
9290   }
9291   std::string arg2_str(jarg2);
9292   arg2 = &arg2_str;
9293   {
9294     try {
9295       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
9296     } CALL_CATCH_EXCEPTION(0);
9297   }
9298
9299   jresult = (void *)result;
9300
9301   //argout typemap for const std::string&
9302
9303   return jresult;
9304 }
9305
9306
9307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
9308   void * jresult ;
9309   Dali::Handle *arg1 = 0 ;
9310   std::string *arg2 = 0 ;
9311   int arg3 ;
9312   Dali::Property *result = 0 ;
9313
9314   arg1 = (Dali::Handle *)jarg1;
9315   if (!arg1) {
9316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9317     return 0;
9318   }
9319   if (!jarg2) {
9320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9321     return 0;
9322   }
9323   std::string arg2_str(jarg2);
9324   arg2 = &arg2_str;
9325   arg3 = (int)jarg3;
9326   {
9327     try {
9328       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
9329     } CALL_CATCH_EXCEPTION(0);
9330   }
9331
9332   jresult = (void *)result;
9333
9334   //argout typemap for const std::string&
9335
9336   return jresult;
9337 }
9338
9339
9340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
9341   Dali::Property *arg1 = (Dali::Property *) 0 ;
9342
9343   arg1 = (Dali::Property *)jarg1;
9344   {
9345     try {
9346       delete arg1;
9347     } CALL_CATCH_EXCEPTION();
9348   }
9349
9350 }
9351
9352
9353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
9354   Dali::Property *arg1 = (Dali::Property *) 0 ;
9355   Dali::Handle *arg2 = 0 ;
9356
9357   arg1 = (Dali::Property *)jarg1;
9358   arg2 = (Dali::Handle *)jarg2;
9359   if (!arg2) {
9360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9361     return ;
9362   }
9363   if (arg1) (arg1)->object = *arg2;
9364 }
9365
9366
9367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
9368   void * jresult ;
9369   Dali::Property *arg1 = (Dali::Property *) 0 ;
9370   Dali::Handle *result = 0 ;
9371
9372   arg1 = (Dali::Property *)jarg1;
9373   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
9374   jresult = (void *)result;
9375   return jresult;
9376 }
9377
9378
9379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
9380   Dali::Property *arg1 = (Dali::Property *) 0 ;
9381   Dali::Property::Index arg2 ;
9382
9383   arg1 = (Dali::Property *)jarg1;
9384   arg2 = (Dali::Property::Index)jarg2;
9385   if (arg1) (arg1)->propertyIndex = arg2;
9386 }
9387
9388
9389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
9390   int jresult ;
9391   Dali::Property *arg1 = (Dali::Property *) 0 ;
9392   Dali::Property::Index result;
9393
9394   arg1 = (Dali::Property *)jarg1;
9395   result = (Dali::Property::Index) ((arg1)->propertyIndex);
9396   jresult = result;
9397   return jresult;
9398 }
9399
9400
9401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
9402   Dali::Property *arg1 = (Dali::Property *) 0 ;
9403   int arg2 ;
9404
9405   arg1 = (Dali::Property *)jarg1;
9406   arg2 = (int)jarg2;
9407   if (arg1) (arg1)->componentIndex = arg2;
9408 }
9409
9410
9411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
9412   int jresult ;
9413   Dali::Property *arg1 = (Dali::Property *) 0 ;
9414   int result;
9415
9416   arg1 = (Dali::Property *)jarg1;
9417   result = (int) ((arg1)->componentIndex);
9418   jresult = result;
9419   return jresult;
9420 }
9421
9422
9423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
9424   void * jresult ;
9425   Dali::Property::Array *result = 0 ;
9426
9427   {
9428     try {
9429       result = (Dali::Property::Array *)new Dali::Property::Array();
9430     } CALL_CATCH_EXCEPTION(0);
9431   }
9432
9433   jresult = (void *)result;
9434   return jresult;
9435 }
9436
9437
9438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
9439   void * jresult ;
9440   Dali::Property::Array *arg1 = 0 ;
9441   Dali::Property::Array *result = 0 ;
9442
9443   arg1 = (Dali::Property::Array *)jarg1;
9444   if (!arg1) {
9445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
9446     return 0;
9447   }
9448   {
9449     try {
9450       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
9451     } CALL_CATCH_EXCEPTION(0);
9452   }
9453
9454   jresult = (void *)result;
9455   return jresult;
9456 }
9457
9458
9459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
9460   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9461
9462   arg1 = (Dali::Property::Array *)jarg1;
9463   {
9464     try {
9465       delete arg1;
9466     } CALL_CATCH_EXCEPTION();
9467   }
9468
9469 }
9470
9471
9472 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
9473   unsigned long jresult ;
9474   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9475   Dali::Property::Array::SizeType result;
9476
9477   arg1 = (Dali::Property::Array *)jarg1;
9478   {
9479     try {
9480       result = ((Dali::Property::Array const *)arg1)->Size();
9481     } CALL_CATCH_EXCEPTION(0);
9482   }
9483
9484   jresult = (unsigned long)result;
9485   return jresult;
9486 }
9487
9488
9489 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
9490   unsigned long jresult ;
9491   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9492   Dali::Property::Array::SizeType result;
9493
9494   arg1 = (Dali::Property::Array *)jarg1;
9495   {
9496     try {
9497       result = ((Dali::Property::Array const *)arg1)->Count();
9498     } CALL_CATCH_EXCEPTION(0);
9499   }
9500
9501   jresult = (unsigned long)result;
9502   return jresult;
9503 }
9504
9505
9506 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
9507   bool jresult ;
9508   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9509   bool result;
9510
9511   arg1 = (Dali::Property::Array *)jarg1;
9512   {
9513     try {
9514       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
9515     } CALL_CATCH_EXCEPTION(0);
9516   }
9517
9518   jresult = result;
9519   return jresult;
9520 }
9521
9522
9523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
9524   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9525
9526   arg1 = (Dali::Property::Array *)jarg1;
9527   {
9528     try {
9529       (arg1)->Clear();
9530     } CALL_CATCH_EXCEPTION();
9531   }
9532
9533 }
9534
9535
9536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
9537   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9538   Dali::Property::Array::SizeType arg2 ;
9539
9540   arg1 = (Dali::Property::Array *)jarg1;
9541   arg2 = (Dali::Property::Array::SizeType)jarg2;
9542   {
9543     try {
9544       (arg1)->Reserve(arg2);
9545     } CALL_CATCH_EXCEPTION();
9546   }
9547
9548 }
9549
9550
9551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
9552   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9553   Dali::Property::Array::SizeType arg2 ;
9554
9555   arg1 = (Dali::Property::Array *)jarg1;
9556   arg2 = (Dali::Property::Array::SizeType)jarg2;
9557   {
9558     try {
9559       (arg1)->Resize(arg2);
9560     } CALL_CATCH_EXCEPTION();
9561   }
9562
9563 }
9564
9565
9566 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
9567   unsigned long jresult ;
9568   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9569   Dali::Property::Array::SizeType result;
9570
9571   arg1 = (Dali::Property::Array *)jarg1;
9572   {
9573     try {
9574       result = (arg1)->Capacity();
9575     } CALL_CATCH_EXCEPTION(0);
9576   }
9577
9578   jresult = (unsigned long)result;
9579   return jresult;
9580 }
9581
9582
9583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
9584   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9585   Dali::Property::Value *arg2 = 0 ;
9586
9587   arg1 = (Dali::Property::Array *)jarg1;
9588   arg2 = (Dali::Property::Value *)jarg2;
9589   if (!arg2) {
9590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
9591     return ;
9592   }
9593   {
9594     try {
9595       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
9596     } CALL_CATCH_EXCEPTION();
9597   }
9598
9599 }
9600
9601
9602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
9603   void * jresult ;
9604   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9605   Dali::Property::Value *arg2 = 0 ;
9606   Dali::Property::Array *result = 0 ;
9607
9608   arg1 = (Dali::Property::Array *)jarg1;
9609   arg2 = (Dali::Property::Value *)jarg2;
9610   if (!arg2) {
9611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
9612     return 0;
9613   }
9614   {
9615     try {
9616       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
9617     } CALL_CATCH_EXCEPTION(0);
9618   }
9619
9620   jresult = (void *)result;
9621   return jresult;
9622 }
9623
9624
9625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
9626   void * jresult ;
9627   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9628   Dali::Property::Array::SizeType arg2 ;
9629   Dali::Property::Value *result = 0 ;
9630
9631   arg1 = (Dali::Property::Array *)jarg1;
9632   arg2 = (Dali::Property::Array::SizeType)jarg2;
9633   {
9634     try {
9635       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
9636     } CALL_CATCH_EXCEPTION(0);
9637   }
9638
9639   jresult = (void *)result;
9640   return jresult;
9641 }
9642
9643
9644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
9645   void * jresult ;
9646   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9647   Dali::Property::Array::SizeType arg2 ;
9648   Dali::Property::Value *result = 0 ;
9649
9650   arg1 = (Dali::Property::Array *)jarg1;
9651   arg2 = (Dali::Property::Array::SizeType)jarg2;
9652   {
9653     try {
9654       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
9655     } CALL_CATCH_EXCEPTION(0);
9656   }
9657
9658   jresult = (void *)result;
9659   return jresult;
9660 }
9661
9662
9663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
9664   void * jresult ;
9665   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9666   Dali::Property::Array *arg2 = 0 ;
9667   Dali::Property::Array *result = 0 ;
9668
9669   arg1 = (Dali::Property::Array *)jarg1;
9670   arg2 = (Dali::Property::Array *)jarg2;
9671   if (!arg2) {
9672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
9673     return 0;
9674   }
9675   {
9676     try {
9677       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
9678     } CALL_CATCH_EXCEPTION(0);
9679   }
9680
9681   jresult = (void *)result;
9682   return jresult;
9683 }
9684
9685
9686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
9687   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9688   enum Dali::Property::Key::Type arg2 ;
9689
9690   arg1 = (Dali::Property::Key *)jarg1;
9691   arg2 = (enum Dali::Property::Key::Type)jarg2;
9692   if (arg1) (arg1)->type = arg2;
9693 }
9694
9695
9696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
9697   int jresult ;
9698   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9699   enum Dali::Property::Key::Type result;
9700
9701   arg1 = (Dali::Property::Key *)jarg1;
9702   result = (enum Dali::Property::Key::Type) ((arg1)->type);
9703   jresult = (int)result;
9704   return jresult;
9705 }
9706
9707
9708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
9709   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9710   Dali::Property::Index arg2 ;
9711
9712   arg1 = (Dali::Property::Key *)jarg1;
9713   arg2 = (Dali::Property::Index)jarg2;
9714   if (arg1) (arg1)->indexKey = arg2;
9715 }
9716
9717
9718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
9719   int jresult ;
9720   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9721   Dali::Property::Index result;
9722
9723   arg1 = (Dali::Property::Key *)jarg1;
9724   result = (Dali::Property::Index) ((arg1)->indexKey);
9725   jresult = result;
9726   return jresult;
9727 }
9728
9729
9730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
9731   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9732   std::string *arg2 = 0 ;
9733
9734   arg1 = (Dali::Property::Key *)jarg1;
9735   if (!jarg2) {
9736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9737     return ;
9738   }
9739   std::string arg2_str(jarg2);
9740   arg2 = &arg2_str;
9741   if (arg1) (arg1)->stringKey = *arg2;
9742
9743   //argout typemap for const std::string&
9744
9745 }
9746
9747
9748 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
9749   char * jresult ;
9750   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9751   std::string *result = 0 ;
9752
9753   arg1 = (Dali::Property::Key *)jarg1;
9754   result = (std::string *) & ((arg1)->stringKey);
9755   jresult = SWIG_csharp_string_callback(result->c_str());
9756   return jresult;
9757 }
9758
9759
9760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
9761   void * jresult ;
9762   std::string *arg1 = 0 ;
9763   Dali::Property::Key *result = 0 ;
9764
9765   if (!jarg1) {
9766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9767     return 0;
9768   }
9769   std::string arg1_str(jarg1);
9770   arg1 = &arg1_str;
9771   {
9772     try {
9773       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
9774     } CALL_CATCH_EXCEPTION(0);
9775   }
9776
9777   jresult = (void *)result;
9778
9779   //argout typemap for const std::string&
9780
9781   return jresult;
9782 }
9783
9784
9785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
9786   void * jresult ;
9787   Dali::Property::Index arg1 ;
9788   Dali::Property::Key *result = 0 ;
9789
9790   arg1 = (Dali::Property::Index)jarg1;
9791   {
9792     try {
9793       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
9794     } CALL_CATCH_EXCEPTION(0);
9795   }
9796
9797   jresult = (void *)result;
9798   return jresult;
9799 }
9800
9801
9802 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
9803   bool jresult ;
9804   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9805   std::string *arg2 = 0 ;
9806   bool result;
9807
9808   arg1 = (Dali::Property::Key *)jarg1;
9809   if (!jarg2) {
9810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9811     return 0;
9812   }
9813   std::string arg2_str(jarg2);
9814   arg2 = &arg2_str;
9815   {
9816     try {
9817       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
9818     } CALL_CATCH_EXCEPTION(0);
9819   }
9820
9821   jresult = result;
9822
9823   //argout typemap for const std::string&
9824
9825   return jresult;
9826 }
9827
9828
9829 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
9830   bool jresult ;
9831   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9832   Dali::Property::Index arg2 ;
9833   bool result;
9834
9835   arg1 = (Dali::Property::Key *)jarg1;
9836   arg2 = (Dali::Property::Index)jarg2;
9837   {
9838     try {
9839       result = (bool)(arg1)->operator ==(arg2);
9840     } CALL_CATCH_EXCEPTION(0);
9841   }
9842
9843   jresult = result;
9844   return jresult;
9845 }
9846
9847
9848 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
9849   bool jresult ;
9850   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9851   Dali::Property::Key *arg2 = 0 ;
9852   bool result;
9853
9854   arg1 = (Dali::Property::Key *)jarg1;
9855   arg2 = (Dali::Property::Key *)jarg2;
9856   if (!arg2) {
9857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
9858     return 0;
9859   }
9860   {
9861     try {
9862       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
9863     } CALL_CATCH_EXCEPTION(0);
9864   }
9865
9866   jresult = result;
9867   return jresult;
9868 }
9869
9870
9871 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
9872   bool jresult ;
9873   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9874   std::string *arg2 = 0 ;
9875   bool result;
9876
9877   arg1 = (Dali::Property::Key *)jarg1;
9878   if (!jarg2) {
9879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9880     return 0;
9881   }
9882   std::string arg2_str(jarg2);
9883   arg2 = &arg2_str;
9884   {
9885     try {
9886       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
9887     } CALL_CATCH_EXCEPTION(0);
9888   }
9889
9890   jresult = result;
9891
9892   //argout typemap for const std::string&
9893
9894   return jresult;
9895 }
9896
9897
9898 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
9899   bool jresult ;
9900   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9901   Dali::Property::Index arg2 ;
9902   bool result;
9903
9904   arg1 = (Dali::Property::Key *)jarg1;
9905   arg2 = (Dali::Property::Index)jarg2;
9906   {
9907     try {
9908       result = (bool)(arg1)->operator !=(arg2);
9909     } CALL_CATCH_EXCEPTION(0);
9910   }
9911
9912   jresult = result;
9913   return jresult;
9914 }
9915
9916
9917 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
9918   bool jresult ;
9919   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9920   Dali::Property::Key *arg2 = 0 ;
9921   bool result;
9922
9923   arg1 = (Dali::Property::Key *)jarg1;
9924   arg2 = (Dali::Property::Key *)jarg2;
9925   if (!arg2) {
9926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
9927     return 0;
9928   }
9929   {
9930     try {
9931       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
9932     } CALL_CATCH_EXCEPTION(0);
9933   }
9934
9935   jresult = result;
9936   return jresult;
9937 }
9938
9939
9940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
9941   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9942
9943   arg1 = (Dali::Property::Key *)jarg1;
9944   {
9945     try {
9946       delete arg1;
9947     } CALL_CATCH_EXCEPTION();
9948   }
9949
9950 }
9951
9952
9953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
9954   void * jresult ;
9955   Dali::Property::Map *result = 0 ;
9956
9957   {
9958     try {
9959       result = (Dali::Property::Map *)new Dali::Property::Map();
9960     } CALL_CATCH_EXCEPTION(0);
9961   }
9962
9963   jresult = (void *)result;
9964   return jresult;
9965 }
9966
9967
9968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
9969   void * jresult ;
9970   Dali::Property::Map *arg1 = 0 ;
9971   Dali::Property::Map *result = 0 ;
9972
9973   arg1 = (Dali::Property::Map *)jarg1;
9974   if (!arg1) {
9975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
9976     return 0;
9977   }
9978   {
9979     try {
9980       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
9981     } CALL_CATCH_EXCEPTION(0);
9982   }
9983
9984   jresult = (void *)result;
9985   return jresult;
9986 }
9987
9988
9989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
9990   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
9991
9992   arg1 = (Dali::Property::Map *)jarg1;
9993   {
9994     try {
9995       delete arg1;
9996     } CALL_CATCH_EXCEPTION();
9997   }
9998
9999 }
10000
10001
10002 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
10003   unsigned long jresult ;
10004   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10005   Dali::Property::Map::SizeType result;
10006
10007   arg1 = (Dali::Property::Map *)jarg1;
10008   {
10009     try {
10010       result = ((Dali::Property::Map const *)arg1)->Count();
10011     } CALL_CATCH_EXCEPTION(0);
10012   }
10013
10014   jresult = (unsigned long)result;
10015   return jresult;
10016 }
10017
10018
10019 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
10020   bool jresult ;
10021   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10022   bool result;
10023
10024   arg1 = (Dali::Property::Map *)jarg1;
10025   {
10026     try {
10027       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
10028     } CALL_CATCH_EXCEPTION(0);
10029   }
10030
10031   jresult = result;
10032   return jresult;
10033 }
10034
10035
10036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
10037   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10038   char *arg2 = (char *) 0 ;
10039   Dali::Property::Value *arg3 = 0 ;
10040
10041   arg1 = (Dali::Property::Map *)jarg1;
10042   arg2 = (char *)jarg2;
10043   arg3 = (Dali::Property::Value *)jarg3;
10044   if (!arg3) {
10045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10046     return ;
10047   }
10048   {
10049     try {
10050       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
10051     } CALL_CATCH_EXCEPTION();
10052   }
10053
10054 }
10055
10056
10057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Int__SWIG_0(void * jarg1, const char * jarg2, int jarg3) {
10058   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10059
10060   arg1 = (Dali::Property::Map *)jarg1;
10061   {
10062     try {
10063       (arg1)->Insert(jarg2,(Dali::Property::Value const &)(jarg3));
10064     } CALL_CATCH_EXCEPTION();
10065   }
10066
10067 }
10068
10069
10070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Bool__SWIG_0(void * jarg1, const char * jarg2, bool jarg3) {
10071   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10072
10073   arg1 = (Dali::Property::Map *)jarg1;
10074   {
10075     try {
10076       (arg1)->Insert(jarg2,(Dali::Property::Value const &)(jarg3));
10077     } CALL_CATCH_EXCEPTION();
10078   }
10079
10080 }
10081
10082
10083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Float__SWIG_0(void * jarg1, const char * jarg2, float jarg3) {
10084   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10085
10086   arg1 = (Dali::Property::Map *)jarg1;
10087   {
10088     try {
10089       (arg1)->Insert(jarg2,(Dali::Property::Value const &)(jarg3));
10090     } CALL_CATCH_EXCEPTION();
10091   }
10092
10093 }
10094
10095
10096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_String__SWIG_0(void * jarg1, const char * jarg2, const char * jarg3) {
10097   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10098
10099   arg1 = (Dali::Property::Map *)jarg1;
10100   {
10101     try {
10102       (arg1)->Insert(jarg2,(Dali::Property::Value const &)(jarg3));
10103     } CALL_CATCH_EXCEPTION();
10104   }
10105
10106 }
10107
10108
10109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Vector2__SWIG_0(void * jarg1, const char * jarg2, float jarg3, float jarg4) {
10110   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10111
10112   arg1 = (Dali::Property::Map *)jarg1;
10113   {
10114     try {
10115       (arg1)->Insert(jarg2,(Dali::Property::Value const &)(Dali::Vector2(jarg3, jarg4)));
10116     } CALL_CATCH_EXCEPTION();
10117   }
10118
10119 }
10120
10121
10122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Vector3__SWIG_0(void * jarg1, const char * jarg2, float jarg3, float jarg4, float jarg5) {
10123   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10124
10125   arg1 = (Dali::Property::Map *)jarg1;
10126   {
10127     try {
10128       (arg1)->Insert(jarg2,(Dali::Property::Value const &)(Dali::Vector3(jarg3, jarg4, jarg5)));
10129     } CALL_CATCH_EXCEPTION();
10130   }
10131
10132 }
10133
10134
10135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Vector4__SWIG_0(void * jarg1, const char * jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
10136   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10137
10138   arg1 = (Dali::Property::Map *)jarg1;
10139   {
10140     try {
10141       (arg1)->Insert(jarg2,(Dali::Property::Value const &)(Dali::Vector4(jarg3, jarg4, jarg5, jarg6)));
10142     } CALL_CATCH_EXCEPTION();
10143   }
10144
10145 }
10146
10147
10148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
10149   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10150   Dali::Property::Index arg2 ;
10151   Dali::Property::Value *arg3 = 0 ;
10152
10153   arg1 = (Dali::Property::Map *)jarg1;
10154   arg2 = (Dali::Property::Index)jarg2;
10155   arg3 = (Dali::Property::Value *)jarg3;
10156   if (!arg3) {
10157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10158     return ;
10159   }
10160   {
10161     try {
10162       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
10163     } CALL_CATCH_EXCEPTION();
10164   }
10165
10166 }
10167
10168
10169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Int__SWIG_2(void * jarg1, int jarg2, int jarg3) {
10170   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10171   Dali::Property::Index arg2 ;
10172
10173   arg1 = (Dali::Property::Map *)jarg1;
10174   arg2 = (Dali::Property::Index)jarg2;
10175   {
10176     try {
10177       (arg1)->Insert(arg2,(Dali::Property::Value const &)(jarg3));
10178     } CALL_CATCH_EXCEPTION();
10179   }
10180
10181 }
10182
10183
10184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Bool__SWIG_2(void * jarg1, int jarg2, bool jarg3) {
10185   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10186   Dali::Property::Index arg2 ;
10187
10188   arg1 = (Dali::Property::Map *)jarg1;
10189   arg2 = (Dali::Property::Index)jarg2;
10190   {
10191     try {
10192       (arg1)->Insert(arg2,(Dali::Property::Value const &)(jarg3));
10193     } CALL_CATCH_EXCEPTION();
10194   }
10195
10196 }
10197
10198
10199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Float__SWIG_2(void * jarg1, int jarg2, float jarg3) {
10200   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10201   Dali::Property::Index arg2 ;
10202
10203   arg1 = (Dali::Property::Map *)jarg1;
10204   arg2 = (Dali::Property::Index)jarg2;
10205   {
10206     try {
10207       (arg1)->Insert(arg2,(Dali::Property::Value const &)(jarg3));
10208     } CALL_CATCH_EXCEPTION();
10209   }
10210
10211 }
10212
10213
10214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_String__SWIG_2(void * jarg1, int jarg2, char * jarg3) {
10215   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10216   Dali::Property::Index arg2 ;
10217
10218   arg1 = (Dali::Property::Map *)jarg1;
10219   arg2 = (Dali::Property::Index)jarg2;
10220   {
10221     try {
10222       (arg1)->Insert(arg2,(Dali::Property::Value const &)(jarg3));
10223     } CALL_CATCH_EXCEPTION();
10224   }
10225
10226 }
10227
10228
10229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Vector2__SWIG_2(void * jarg1, int jarg2, float jarg3, float jarg4) {
10230   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10231   Dali::Property::Index arg2 ;
10232
10233   arg1 = (Dali::Property::Map *)jarg1;
10234   arg2 = (Dali::Property::Index)jarg2;
10235   {
10236     try {
10237       (arg1)->Insert(arg2,(Dali::Property::Value const &)(Dali::Vector2(jarg3, jarg4)));
10238     } CALL_CATCH_EXCEPTION();
10239   }
10240
10241 }
10242
10243
10244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Vector3__SWIG_2(void * jarg1, int jarg2, float jarg3, float jarg4, float jarg5) {
10245   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10246   Dali::Property::Index arg2 ;
10247
10248   arg1 = (Dali::Property::Map *)jarg1;
10249   arg2 = (Dali::Property::Index)jarg2;
10250   {
10251     try {
10252       (arg1)->Insert(arg2,(Dali::Property::Value const &)(Dali::Vector3(jarg3, jarg4, jarg5)));
10253     } CALL_CATCH_EXCEPTION();
10254   }
10255
10256 }
10257
10258
10259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Vector4__SWIG_2(void * jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
10260   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10261   Dali::Property::Index arg2 ;
10262
10263   arg1 = (Dali::Property::Map *)jarg1;
10264   arg2 = (Dali::Property::Index)jarg2;
10265   {
10266     try {
10267       (arg1)->Insert(arg2,(Dali::Property::Value const &)(Dali::Vector4(jarg3, jarg4, jarg5, jarg6)));
10268     } CALL_CATCH_EXCEPTION();
10269   }
10270
10271 }
10272
10273
10274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
10275   void * jresult ;
10276   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10277   char *arg2 = (char *) 0 ;
10278   Dali::Property::Value *arg3 = 0 ;
10279   Dali::Property::Map *result = 0 ;
10280
10281   arg1 = (Dali::Property::Map *)jarg1;
10282   arg2 = (char *)jarg2;
10283   arg3 = (Dali::Property::Value *)jarg3;
10284   if (!arg3) {
10285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10286     return 0;
10287   }
10288   {
10289     try {
10290       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
10291     } CALL_CATCH_EXCEPTION(0);
10292   }
10293
10294   jresult = (void *)result;
10295   return jresult;
10296 }
10297
10298
10299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
10300   void * jresult ;
10301   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10302   Dali::Property::Index arg2 ;
10303   Dali::Property::Value *arg3 = 0 ;
10304   Dali::Property::Map *result = 0 ;
10305
10306   arg1 = (Dali::Property::Map *)jarg1;
10307   arg2 = (Dali::Property::Index)jarg2;
10308   arg3 = (Dali::Property::Value *)jarg3;
10309   if (!arg3) {
10310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10311     return 0;
10312   }
10313   {
10314     try {
10315       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
10316     } CALL_CATCH_EXCEPTION(0);
10317   }
10318
10319   jresult = (void *)result;
10320   return jresult;
10321 }
10322
10323
10324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
10325   void * jresult ;
10326   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10327   Dali::Property::Map::SizeType arg2 ;
10328   Dali::Property::Value *result = 0 ;
10329
10330   arg1 = (Dali::Property::Map *)jarg1;
10331   arg2 = (Dali::Property::Map::SizeType)jarg2;
10332   {
10333     try {
10334       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
10335     } CALL_CATCH_EXCEPTION(0);
10336   }
10337
10338   jresult = (void *)result;
10339   return jresult;
10340 }
10341
10342
10343 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
10344   char * jresult ;
10345   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10346   Dali::Property::Map::SizeType arg2 ;
10347   std::string *result = 0 ;
10348
10349   arg1 = (Dali::Property::Map *)jarg1;
10350   arg2 = (Dali::Property::Map::SizeType)jarg2;
10351   {
10352     try {
10353       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
10354     } CALL_CATCH_EXCEPTION(0);
10355   }
10356
10357   jresult = SWIG_csharp_string_callback(result->c_str());
10358   return jresult;
10359 }
10360
10361
10362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
10363   void * jresult ;
10364   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10365   Dali::Property::Map::SizeType arg2 ;
10366   SwigValueWrapper< Dali::Property::Key > result;
10367
10368   arg1 = (Dali::Property::Map *)jarg1;
10369   arg2 = (Dali::Property::Map::SizeType)jarg2;
10370   {
10371     try {
10372       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
10373     } CALL_CATCH_EXCEPTION(0);
10374   }
10375
10376   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
10377   return jresult;
10378 }
10379
10380
10381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
10382   void * jresult ;
10383   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10384   Dali::Property::Map::SizeType arg2 ;
10385   StringValuePair *result = 0 ;
10386
10387   arg1 = (Dali::Property::Map *)jarg1;
10388   arg2 = (Dali::Property::Map::SizeType)jarg2;
10389   {
10390     try {
10391       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
10392     } CALL_CATCH_EXCEPTION(0);
10393   }
10394
10395   jresult = (void *)result;
10396   return jresult;
10397 }
10398
10399
10400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
10401   void * jresult ;
10402   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10403   char *arg2 = (char *) 0 ;
10404   Dali::Property::Value *result = 0 ;
10405
10406   arg1 = (Dali::Property::Map *)jarg1;
10407   arg2 = (char *)jarg2;
10408   {
10409     try {
10410       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
10411     } CALL_CATCH_EXCEPTION(0);
10412   }
10413
10414   jresult = (void *)result;
10415   return jresult;
10416 }
10417
10418
10419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
10420   void * jresult ;
10421   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10422   Dali::Property::Index arg2 ;
10423   Dali::Property::Value *result = 0 ;
10424
10425   arg1 = (Dali::Property::Map *)jarg1;
10426   arg2 = (Dali::Property::Index)jarg2;
10427   {
10428     try {
10429       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
10430     } CALL_CATCH_EXCEPTION(0);
10431   }
10432
10433   jresult = (void *)result;
10434   return jresult;
10435 }
10436
10437
10438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
10439   void * jresult ;
10440   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10441   Dali::Property::Index arg2 ;
10442   std::string *arg3 = 0 ;
10443   Dali::Property::Value *result = 0 ;
10444
10445   arg1 = (Dali::Property::Map *)jarg1;
10446   arg2 = (Dali::Property::Index)jarg2;
10447   if (!jarg3) {
10448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10449     return 0;
10450   }
10451   std::string arg3_str(jarg3);
10452   arg3 = &arg3_str;
10453   {
10454     try {
10455       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
10456     } CALL_CATCH_EXCEPTION(0);
10457   }
10458
10459   jresult = (void *)result;
10460
10461   //argout typemap for const std::string&
10462
10463   return jresult;
10464 }
10465
10466
10467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
10468   void * jresult ;
10469   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10470   std::string *arg2 = 0 ;
10471   Dali::Property::Type arg3 ;
10472   Dali::Property::Value *result = 0 ;
10473
10474   arg1 = (Dali::Property::Map *)jarg1;
10475   if (!jarg2) {
10476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10477     return 0;
10478   }
10479   std::string arg2_str(jarg2);
10480   arg2 = &arg2_str;
10481   arg3 = (Dali::Property::Type)jarg3;
10482   {
10483     try {
10484       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
10485     } CALL_CATCH_EXCEPTION(0);
10486   }
10487
10488   jresult = (void *)result;
10489
10490   //argout typemap for const std::string&
10491
10492   return jresult;
10493 }
10494
10495
10496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
10497   void * jresult ;
10498   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10499   Dali::Property::Index arg2 ;
10500   Dali::Property::Type arg3 ;
10501   Dali::Property::Value *result = 0 ;
10502
10503   arg1 = (Dali::Property::Map *)jarg1;
10504   arg2 = (Dali::Property::Index)jarg2;
10505   arg3 = (Dali::Property::Type)jarg3;
10506   {
10507     try {
10508       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
10509     } CALL_CATCH_EXCEPTION(0);
10510   }
10511
10512   jresult = (void *)result;
10513   return jresult;
10514 }
10515
10516
10517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
10518   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10519
10520   arg1 = (Dali::Property::Map *)jarg1;
10521   {
10522     try {
10523       (arg1)->Clear();
10524     } CALL_CATCH_EXCEPTION();
10525   }
10526
10527 }
10528
10529
10530 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Map_Remove__SWIG_0(void * map, int key) {
10531   Dali::Property::Map *propertyMap = (Dali::Property::Map *)map;
10532   Dali::Property::Index intKey = (Dali::Property::Index)key;
10533   bool isRemoved = false;
10534   {
10535     try {
10536       isRemoved = propertyMap->Remove(intKey);
10537     } CALL_CATCH_EXCEPTION(0);
10538   }
10539   return isRemoved;
10540 }
10541
10542
10543 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Map_Remove__SWIG_1(void * map, char * key) {
10544   Dali::Property::Map *propertyMap = (Dali::Property::Map *)map;
10545   std::string strKey(key);
10546   bool isRemoved = false;
10547   {
10548     try {
10549       isRemoved = propertyMap->Remove(strKey);
10550     } CALL_CATCH_EXCEPTION(0);
10551   }
10552   return isRemoved;
10553 }
10554
10555
10556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
10557   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10558   Dali::Property::Map *arg2 = 0 ;
10559
10560   arg1 = (Dali::Property::Map *)jarg1;
10561   arg2 = (Dali::Property::Map *)jarg2;
10562   if (!arg2) {
10563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
10564     return ;
10565   }
10566   {
10567     try {
10568       (arg1)->Merge((Dali::Property::Map const &)*arg2);
10569     } CALL_CATCH_EXCEPTION();
10570   }
10571
10572 }
10573
10574
10575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
10576   void * jresult ;
10577   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10578   std::string *arg2 = 0 ;
10579   Dali::Property::Value *result = 0 ;
10580
10581   arg1 = (Dali::Property::Map *)jarg1;
10582   if (!jarg2) {
10583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10584     return 0;
10585   }
10586   std::string arg2_str(jarg2);
10587   arg2 = &arg2_str;
10588   {
10589     try {
10590       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
10591     } CALL_CATCH_EXCEPTION(0);
10592   }
10593
10594   jresult = (void *)result;
10595
10596   //argout typemap for const std::string&
10597
10598   return jresult;
10599 }
10600
10601
10602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
10603   void * jresult ;
10604   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10605   Dali::Property::Index arg2 ;
10606   Dali::Property::Value *result = 0 ;
10607
10608   arg1 = (Dali::Property::Map *)jarg1;
10609   arg2 = (Dali::Property::Index)jarg2;
10610   {
10611     try {
10612       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
10613     } CALL_CATCH_EXCEPTION(0);
10614   }
10615
10616   jresult = (void *)result;
10617   return jresult;
10618 }
10619
10620
10621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
10622   void * jresult ;
10623   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10624   Dali::Property::Map *arg2 = 0 ;
10625   Dali::Property::Map *result = 0 ;
10626
10627   arg1 = (Dali::Property::Map *)jarg1;
10628   arg2 = (Dali::Property::Map *)jarg2;
10629   if (!arg2) {
10630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
10631     return 0;
10632   }
10633   {
10634     try {
10635       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
10636     } CALL_CATCH_EXCEPTION(0);
10637   }
10638
10639   jresult = (void *)result;
10640   return jresult;
10641 }
10642
10643
10644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) {
10645
10646   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10647
10648   if (!jarg2) {
10649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10650     return;
10651   }
10652   std::string arg2_str(jarg2);
10653   std::string* arg2 = &arg2_str;
10654
10655   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
10656
10657   {
10658     try {
10659       arg1->operator[]((std::string const &)*arg2) = *arg3;
10660     } CALL_CATCH_EXCEPTION();
10661   }
10662 }
10663
10664
10665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey_IntValue(void* jarg1, const char* jarg2, int jarg3) {
10666
10667   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10668
10669   if (!jarg2) {
10670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10671     return;
10672   }
10673
10674   {
10675     try {
10676       arg1->operator[](std::string_view(jarg2)) = (Dali::Property::Value const &)((int32_t)jarg3);
10677     } CALL_CATCH_EXCEPTION();
10678   }
10679 }
10680
10681
10682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey_BoolValue(void* jarg1, const char* jarg2, bool jarg3) {
10683
10684   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10685
10686   if (!jarg2) {
10687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10688     return;
10689   }
10690
10691   {
10692     try {
10693       arg1->operator[](std::string_view(jarg2)) = (Dali::Property::Value const &)(jarg3);
10694     } CALL_CATCH_EXCEPTION();
10695   }
10696 }
10697
10698
10699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey_FloatValue(void* jarg1, const char* jarg2, float jarg3) {
10700
10701   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10702
10703   if (!jarg2) {
10704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10705     return;
10706   }
10707
10708   {
10709     try {
10710       arg1->operator[](std::string_view(jarg2)) = (Dali::Property::Value const &)(jarg3);
10711     } CALL_CATCH_EXCEPTION();
10712   }
10713 }
10714
10715
10716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey_StringValue(void* jarg1, const char* jarg2, const char* jarg3) {
10717
10718   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10719
10720   if (!jarg2) {
10721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10722     return;
10723   }
10724
10725   {
10726     try {
10727       arg1->operator[](std::string_view(jarg2)) = (Dali::Property::Value const &)(jarg3);
10728     } CALL_CATCH_EXCEPTION();
10729   }
10730 }
10731
10732
10733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey_Vector2(void* jarg1, const char* jarg2, float jarg3, float jarg4) {
10734
10735   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10736
10737   if (!jarg2) {
10738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10739     return;
10740   }
10741
10742   {
10743     try {
10744       arg1->operator[](std::string_view(jarg2)) = (Dali::Property::Value const &)(Dali::Vector2(jarg3, jarg4));
10745     } CALL_CATCH_EXCEPTION();
10746   }
10747 }
10748
10749
10750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey_Vector4(void* jarg1, const char* jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
10751
10752   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10753
10754   if (!jarg2) {
10755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10756     return;
10757   }
10758
10759   {
10760     try {
10761       arg1->operator[](std::string_view(jarg2)) = (Dali::Property::Value const &)(Dali::Vector4(jarg3, jarg4, jarg5, jarg6));
10762     } CALL_CATCH_EXCEPTION();
10763   }
10764 }
10765
10766
10767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey_Rect(void* jarg1, char* jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
10768
10769   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10770
10771   if (!jarg2) {
10772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10773     return;
10774   }
10775
10776   {
10777     try {
10778       arg1->operator[](std::string_view(jarg2)) = (Dali::Property::Value const &)(Dali::Rect< int >(jarg3, jarg4, jarg5, jarg6));
10779     } CALL_CATCH_EXCEPTION();
10780   }
10781 }
10782
10783
10784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
10785
10786   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10787   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
10788   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
10789
10790   {
10791     try {
10792       arg1->operator[](arg2) = *arg3;
10793     } CALL_CATCH_EXCEPTION();
10794   }
10795 }
10796
10797
10798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey_IntValue(void* jarg1, int jarg2, int jarg3) {
10799
10800   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10801
10802   {
10803     try {
10804       arg1->operator[]((Dali::Property::Index)jarg2) = (Dali::Property::Value const &)((int32_t)jarg3);
10805     } CALL_CATCH_EXCEPTION();
10806   }
10807 }
10808
10809
10810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey_BoolValue(void* jarg1, int jarg2, bool jarg3) {
10811
10812   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10813
10814   {
10815     try {
10816       arg1->operator[]((Dali::Property::Index)jarg2) = (Dali::Property::Value const &)(jarg3);
10817     } CALL_CATCH_EXCEPTION();
10818   }
10819 }
10820
10821
10822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey_FloatValue(void* jarg1, int jarg2, float jarg3) {
10823
10824   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10825
10826   {
10827     try {
10828       arg1->operator[]((Dali::Property::Index)jarg2) = (Dali::Property::Value const &)(jarg3);
10829     } CALL_CATCH_EXCEPTION();
10830   }
10831 }
10832
10833
10834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey_StringValue(void* jarg1, int jarg2, const char* jarg3) {
10835
10836   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10837
10838   {
10839     try {
10840       arg1->operator[]((Dali::Property::Index)jarg2) = (Dali::Property::Value const &)(jarg3);
10841     } CALL_CATCH_EXCEPTION();
10842   }
10843 }
10844
10845
10846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey_Vector2(void* jarg1, int jarg2, float jarg3, float jarg4) {
10847
10848   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10849
10850   {
10851     try {
10852       arg1->operator[]((Dali::Property::Index)jarg2) = (Dali::Property::Value const &)(Dali::Vector2(jarg3, jarg4));
10853     } CALL_CATCH_EXCEPTION();
10854   }
10855 }
10856
10857
10858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey_Vector4(void* jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
10859
10860   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10861
10862   {
10863     try {
10864       arg1->operator[]((Dali::Property::Index)jarg2) = (Dali::Property::Value const &)(Dali::Vector4(jarg3, jarg4, jarg5, jarg6));
10865     } CALL_CATCH_EXCEPTION();
10866   }
10867 }
10868
10869
10870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey_Rect(void* jarg1, int jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
10871
10872   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10873
10874   {
10875     try {
10876       arg1->operator[]((Dali::Property::Index)jarg2) = (Dali::Property::Value const &)(Dali::Rect< int >(jarg3, jarg4, jarg5, jarg6));
10877     } CALL_CATCH_EXCEPTION();
10878   }
10879 }
10880
10881
10882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
10883   void * jresult ;
10884   Dali::Property::Value *result = 0 ;
10885
10886   {
10887     try {
10888       result = (Dali::Property::Value *)new Dali::Property::Value();
10889     } CALL_CATCH_EXCEPTION(0);
10890   }
10891
10892   jresult = (void *)result;
10893   return jresult;
10894 }
10895
10896
10897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(bool jarg1) {
10898   void * jresult ;
10899   bool arg1 ;
10900   Dali::Property::Value *result = 0 ;
10901
10902   arg1 = jarg1 ? true : false;
10903   {
10904     try {
10905       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
10906     } CALL_CATCH_EXCEPTION(0);
10907   }
10908
10909   jresult = (void *)result;
10910   return jresult;
10911 }
10912
10913
10914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
10915   void * jresult ;
10916   int arg1 ;
10917   Dali::Property::Value *result = 0 ;
10918
10919   arg1 = (int)jarg1;
10920   {
10921     try {
10922       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
10923     } CALL_CATCH_EXCEPTION(0);
10924   }
10925
10926   jresult = (void *)result;
10927   return jresult;
10928 }
10929
10930
10931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
10932   void * jresult ;
10933   float arg1 ;
10934   Dali::Property::Value *result = 0 ;
10935
10936   arg1 = (float)jarg1;
10937   {
10938     try {
10939       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
10940     } CALL_CATCH_EXCEPTION(0);
10941   }
10942
10943   jresult = (void *)result;
10944   return jresult;
10945 }
10946
10947
10948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
10949   void * jresult ;
10950   Dali::Vector2 *arg1 = 0 ;
10951   Dali::Property::Value *result = 0 ;
10952
10953   arg1 = (Dali::Vector2 *)jarg1;
10954   if (!arg1) {
10955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
10956     return 0;
10957   }
10958   {
10959     try {
10960       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
10961     } CALL_CATCH_EXCEPTION(0);
10962   }
10963
10964   jresult = (void *)result;
10965   return jresult;
10966 }
10967
10968
10969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
10970   void * jresult ;
10971   Dali::Vector3 *arg1 = 0 ;
10972   Dali::Property::Value *result = 0 ;
10973
10974   arg1 = (Dali::Vector3 *)jarg1;
10975   if (!arg1) {
10976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10977     return 0;
10978   }
10979   {
10980     try {
10981       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
10982     } CALL_CATCH_EXCEPTION(0);
10983   }
10984
10985   jresult = (void *)result;
10986   return jresult;
10987 }
10988
10989
10990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
10991   void * jresult ;
10992   Dali::Vector4 *arg1 = 0 ;
10993   Dali::Property::Value *result = 0 ;
10994
10995   arg1 = (Dali::Vector4 *)jarg1;
10996   if (!arg1) {
10997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
10998     return 0;
10999   }
11000   {
11001     try {
11002       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
11003     } CALL_CATCH_EXCEPTION(0);
11004   }
11005
11006   jresult = (void *)result;
11007   return jresult;
11008 }
11009
11010
11011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
11012   void * jresult ;
11013   Dali::Matrix3 *arg1 = 0 ;
11014   Dali::Property::Value *result = 0 ;
11015
11016   arg1 = (Dali::Matrix3 *)jarg1;
11017   if (!arg1) {
11018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11019     return 0;
11020   }
11021   {
11022     try {
11023       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
11024     } CALL_CATCH_EXCEPTION(0);
11025   }
11026
11027   jresult = (void *)result;
11028   return jresult;
11029 }
11030
11031
11032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
11033   void * jresult ;
11034   Dali::Matrix *arg1 = 0 ;
11035   Dali::Property::Value *result = 0 ;
11036
11037   arg1 = (Dali::Matrix *)jarg1;
11038   if (!arg1) {
11039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11040     return 0;
11041   }
11042   {
11043     try {
11044       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
11045     } CALL_CATCH_EXCEPTION(0);
11046   }
11047
11048   jresult = (void *)result;
11049   return jresult;
11050 }
11051
11052
11053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
11054   void * jresult ;
11055   Dali::Rect< int > *arg1 = 0 ;
11056   Dali::Property::Value *result = 0 ;
11057
11058   arg1 = (Dali::Rect< int > *)jarg1;
11059   if (!arg1) {
11060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
11061     return 0;
11062   }
11063   {
11064     try {
11065       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
11066     } CALL_CATCH_EXCEPTION(0);
11067   }
11068
11069   jresult = (void *)result;
11070   return jresult;
11071 }
11072
11073
11074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
11075   void * jresult ;
11076   Dali::AngleAxis *arg1 = 0 ;
11077   Dali::Property::Value *result = 0 ;
11078
11079   arg1 = (Dali::AngleAxis *)jarg1;
11080   if (!arg1) {
11081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
11082     return 0;
11083   }
11084   {
11085     try {
11086       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
11087     } CALL_CATCH_EXCEPTION(0);
11088   }
11089
11090   jresult = (void *)result;
11091   return jresult;
11092 }
11093
11094
11095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
11096   void * jresult ;
11097   Dali::Quaternion *arg1 = 0 ;
11098   Dali::Property::Value *result = 0 ;
11099
11100   arg1 = (Dali::Quaternion *)jarg1;
11101   if (!arg1) {
11102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11103     return 0;
11104   }
11105   {
11106     try {
11107       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
11108     } CALL_CATCH_EXCEPTION(0);
11109   }
11110
11111   jresult = (void *)result;
11112   return jresult;
11113 }
11114
11115
11116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
11117   void * jresult ;
11118   std::string *arg1 = 0 ;
11119   Dali::Property::Value *result = 0 ;
11120
11121   if (!jarg1) {
11122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11123     return 0;
11124   }
11125   std::string arg1_str(jarg1);
11126   arg1 = &arg1_str;
11127   {
11128     try {
11129       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
11130     } CALL_CATCH_EXCEPTION(0);
11131   }
11132
11133   jresult = (void *)result;
11134
11135   //argout typemap for const std::string&
11136
11137   return jresult;
11138 }
11139
11140
11141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
11142   void * jresult ;
11143   Dali::Property::Array *arg1 = 0 ;
11144   Dali::Property::Value *result = 0 ;
11145
11146   arg1 = (Dali::Property::Array *)jarg1;
11147   if (!arg1) {
11148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
11149     return 0;
11150   }
11151   {
11152     try {
11153       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
11154     } CALL_CATCH_EXCEPTION(0);
11155   }
11156
11157   jresult = (void *)result;
11158   return jresult;
11159 }
11160
11161
11162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
11163   void * jresult ;
11164   Dali::Property::Map *arg1 = 0 ;
11165   Dali::Property::Value *result = 0 ;
11166
11167   arg1 = (Dali::Property::Map *)jarg1;
11168   if (!arg1) {
11169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
11170     return 0;
11171   }
11172   {
11173     try {
11174       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
11175     } CALL_CATCH_EXCEPTION(0);
11176   }
11177
11178   jresult = (void *)result;
11179   return jresult;
11180 }
11181
11182
11183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
11184   void * jresult ;
11185   Extents *arg1 = 0 ;
11186   Dali::Property::Value *result = 0 ;
11187
11188   arg1 = (Extents *)jarg1;
11189   if (!arg1) {
11190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
11191     return 0;
11192   }
11193   {
11194     try {
11195       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
11196     } CALL_CATCH_EXCEPTION(0);
11197   }
11198
11199   jresult = (void*) result;
11200   return jresult;
11201 }
11202
11203
11204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
11205   void * jresult ;
11206   Dali::Property::Type arg1 ;
11207   Dali::Property::Value *result = 0 ;
11208
11209   arg1 = (Dali::Property::Type)jarg1;
11210   {
11211     try {
11212       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
11213     } CALL_CATCH_EXCEPTION(0);
11214   }
11215
11216   jresult = (void *)result;
11217   return jresult;
11218 }
11219
11220
11221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
11222   void * jresult ;
11223   Dali::Property::Value *arg1 = 0 ;
11224   Dali::Property::Value *result = 0 ;
11225
11226   arg1 = (Dali::Property::Value *)jarg1;
11227   if (!arg1) {
11228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
11229     return 0;
11230   }
11231   {
11232     try {
11233       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
11234     } CALL_CATCH_EXCEPTION(0);
11235   }
11236
11237   jresult = (void *)result;
11238   return jresult;
11239 }
11240
11241
11242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
11243   void * jresult ;
11244   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11245   Dali::Property::Value *arg2 = 0 ;
11246   Dali::Property::Value *result = 0 ;
11247
11248   arg1 = (Dali::Property::Value *)jarg1;
11249   arg2 = (Dali::Property::Value *)jarg2;
11250   if (!arg2) {
11251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
11252     return 0;
11253   }
11254   {
11255     try {
11256       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
11257     } CALL_CATCH_EXCEPTION(0);
11258   }
11259
11260   jresult = (void *)result;
11261   return jresult;
11262 }
11263
11264
11265 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_EqualTo(void * jarg1, void * jarg2) {
11266   bool jresult;
11267   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11268   Dali::Property::Value *arg2 = 0 ;
11269   bool result;
11270
11271   arg1 = (Dali::Property::Value *)jarg1;
11272   arg2 = (Dali::Property::Value *)jarg2;
11273   if (!arg2) {
11274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
11275     return 0;
11276   }
11277   {
11278     try {
11279       result = (bool)((Dali::Property::Value const *)arg1)->operator ==((Dali::Property::Value const &)*arg2);
11280     } CALL_CATCH_EXCEPTION(0);
11281   }
11282
11283   jresult = result;
11284   return jresult;
11285 }
11286
11287 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_NotEqualTo(void * jarg1, void * jarg2) {
11288   bool jresult;
11289   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11290   Dali::Property::Value *arg2 = 0 ;
11291   bool result;
11292
11293   arg1 = (Dali::Property::Value *)jarg1;
11294   arg2 = (Dali::Property::Value *)jarg2;
11295   if (!arg2) {
11296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
11297     return 0;
11298   }
11299   {
11300     try {
11301       result = (bool)((Dali::Property::Value const *)arg1)->operator !=((Dali::Property::Value const &)*arg2);
11302     } CALL_CATCH_EXCEPTION(0);
11303   }
11304
11305   jresult = result;
11306   return jresult;
11307 }
11308
11309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
11310   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11311
11312   arg1 = (Dali::Property::Value *)jarg1;
11313   {
11314     try {
11315       delete arg1;
11316     } CALL_CATCH_EXCEPTION();
11317   }
11318
11319 }
11320
11321
11322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
11323   int jresult ;
11324   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11325   Dali::Property::Type result;
11326
11327   arg1 = (Dali::Property::Value *)jarg1;
11328   {
11329     try {
11330       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
11331     } CALL_CATCH_EXCEPTION(0);
11332   }
11333
11334   jresult = (int)result;
11335   return jresult;
11336 }
11337
11338
11339 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, bool * jarg2) {
11340   bool jresult ;
11341   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11342   bool *arg2 = 0 ;
11343   bool result;
11344
11345   arg1 = (Dali::Property::Value *)jarg1;
11346   arg2 = (bool *)jarg2;
11347   {
11348     try {
11349       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11350     } CALL_CATCH_EXCEPTION(0);
11351   }
11352
11353   jresult = result;
11354   return jresult;
11355 }
11356
11357
11358 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
11359   bool jresult ;
11360   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11361   float *arg2 = 0 ;
11362   bool result;
11363
11364   arg1 = (Dali::Property::Value *)jarg1;
11365   arg2 = (float *)jarg2;
11366   {
11367     try {
11368       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11369     } CALL_CATCH_EXCEPTION(0);
11370   }
11371
11372   jresult = result;
11373   return jresult;
11374 }
11375
11376
11377 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
11378   bool jresult ;
11379   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11380   int *arg2 = 0 ;
11381   bool result;
11382
11383   arg1 = (Dali::Property::Value *)jarg1;
11384   arg2 = (int *)jarg2;
11385   {
11386     try {
11387       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11388     } CALL_CATCH_EXCEPTION(0);
11389   }
11390
11391   jresult = result;
11392   return jresult;
11393 }
11394
11395
11396 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
11397   bool jresult ;
11398   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11399   Dali::Rect< int > *arg2 = 0 ;
11400   bool result;
11401
11402   arg1 = (Dali::Property::Value *)jarg1;
11403   arg2 = (Dali::Rect< int > *)jarg2;
11404   if (!arg2) {
11405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
11406     return 0;
11407   }
11408   {
11409     try {
11410       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11411     } CALL_CATCH_EXCEPTION(0);
11412   }
11413
11414   jresult = result;
11415   return jresult;
11416 }
11417
11418
11419 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
11420   bool jresult ;
11421   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11422   Dali::Vector2 *arg2 = 0 ;
11423   bool result;
11424
11425   arg1 = (Dali::Property::Value *)jarg1;
11426   arg2 = (Dali::Vector2 *)jarg2;
11427   if (!arg2) {
11428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
11429     return 0;
11430   }
11431   {
11432     try {
11433       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11434     } CALL_CATCH_EXCEPTION(0);
11435   }
11436
11437   jresult = result;
11438   return jresult;
11439 }
11440
11441
11442 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
11443   bool jresult ;
11444   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11445   Dali::Vector3 *arg2 = 0 ;
11446   bool result;
11447
11448   arg1 = (Dali::Property::Value *)jarg1;
11449   arg2 = (Dali::Vector3 *)jarg2;
11450   if (!arg2) {
11451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11452     return 0;
11453   }
11454   {
11455     try {
11456       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11457     } CALL_CATCH_EXCEPTION(0);
11458   }
11459
11460   jresult = result;
11461   return jresult;
11462 }
11463
11464
11465 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
11466   bool jresult ;
11467   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11468   Dali::Vector4 *arg2 = 0 ;
11469   bool result;
11470
11471   arg1 = (Dali::Property::Value *)jarg1;
11472   arg2 = (Dali::Vector4 *)jarg2;
11473   if (!arg2) {
11474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
11475     return 0;
11476   }
11477   {
11478     try {
11479       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11480     } CALL_CATCH_EXCEPTION(0);
11481   }
11482
11483   jresult = result;
11484   return jresult;
11485 }
11486
11487
11488 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
11489   bool jresult ;
11490   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11491   Dali::Matrix3 *arg2 = 0 ;
11492   bool result;
11493
11494   arg1 = (Dali::Property::Value *)jarg1;
11495   arg2 = (Dali::Matrix3 *)jarg2;
11496   if (!arg2) {
11497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
11498     return 0;
11499   }
11500   {
11501     try {
11502       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11503     } CALL_CATCH_EXCEPTION(0);
11504   }
11505
11506   jresult = result;
11507   return jresult;
11508 }
11509
11510
11511 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
11512   bool jresult ;
11513   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11514   Dali::Matrix *arg2 = 0 ;
11515   bool result;
11516
11517   arg1 = (Dali::Property::Value *)jarg1;
11518   arg2 = (Dali::Matrix *)jarg2;
11519   if (!arg2) {
11520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11521     return 0;
11522   }
11523   {
11524     try {
11525       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11526     } CALL_CATCH_EXCEPTION(0);
11527   }
11528
11529   jresult = result;
11530   return jresult;
11531 }
11532
11533
11534 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
11535   bool jresult ;
11536   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11537   Dali::AngleAxis *arg2 = 0 ;
11538   bool result;
11539
11540   arg1 = (Dali::Property::Value *)jarg1;
11541   arg2 = (Dali::AngleAxis *)jarg2;
11542   if (!arg2) {
11543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
11544     return 0;
11545   }
11546   {
11547     try {
11548       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11549     } CALL_CATCH_EXCEPTION(0);
11550   }
11551
11552   jresult = result;
11553   return jresult;
11554 }
11555
11556
11557 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
11558   bool jresult ;
11559   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11560   Dali::Quaternion *arg2 = 0 ;
11561   bool result;
11562
11563   arg1 = (Dali::Property::Value *)jarg1;
11564   arg2 = (Dali::Quaternion *)jarg2;
11565   if (!arg2) {
11566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11567     return 0;
11568   }
11569   {
11570     try {
11571       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11572     } CALL_CATCH_EXCEPTION(0);
11573   }
11574
11575   jresult = result;
11576   return jresult;
11577 }
11578
11579
11580 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
11581   bool jresult ;
11582   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11583   std::string *arg2 = 0 ;
11584   bool result;
11585
11586   arg1 = (Dali::Property::Value *)jarg1;
11587
11588   //typemap in
11589   std::string temp;
11590   arg2 = &temp;
11591
11592   {
11593     try {
11594       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11595     } CALL_CATCH_EXCEPTION(0);
11596   }
11597
11598   jresult = result;
11599
11600   //Typemap argout in c++ file.
11601   //This will convert c++ string to c# string
11602   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
11603
11604   return jresult;
11605 }
11606
11607
11608 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
11609   bool jresult ;
11610   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11611   Dali::Property::Array *arg2 = 0 ;
11612   bool result;
11613
11614   arg1 = (Dali::Property::Value *)jarg1;
11615   arg2 = (Dali::Property::Array *)jarg2;
11616   if (!arg2) {
11617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
11618     return 0;
11619   }
11620   {
11621     try {
11622       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11623     } CALL_CATCH_EXCEPTION(0);
11624   }
11625
11626   jresult = result;
11627   return jresult;
11628 }
11629
11630
11631 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
11632   bool jresult ;
11633   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11634   Dali::Property::Map *arg2 = 0 ;
11635   bool result;
11636
11637   arg1 = (Dali::Property::Value *)jarg1;
11638   arg2 = (Dali::Property::Map *)jarg2;
11639   if (!arg2) {
11640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
11641     return 0;
11642   }
11643   {
11644     try {
11645       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11646     } CALL_CATCH_EXCEPTION(0);
11647   }
11648
11649   jresult = result;
11650   return jresult;
11651 }
11652
11653
11654 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
11655   bool jresult ;
11656   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11657   Extents *arg2 = 0 ;
11658   bool result;
11659
11660   arg1 = (Dali::Property::Value *)jarg1;
11661   arg2 = (Extents *)jarg2;
11662   if (!arg2) {
11663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
11664     return 0;
11665   }
11666   {
11667     try {
11668       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11669     } CALL_CATCH_EXCEPTION(0);
11670   }
11671   jresult = result;
11672   return jresult;
11673 }
11674
11675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
11676   void * jresult ;
11677   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11678   Dali::Property::Array *result = 0 ;
11679
11680   arg1 = (Dali::Property::Value *)jarg1;
11681   {
11682     try {
11683       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
11684     } CALL_CATCH_EXCEPTION(0);
11685   }
11686
11687   jresult = (void *)result;
11688   return jresult;
11689 }
11690
11691
11692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
11693   void * jresult ;
11694   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11695   Dali::Property::Map *result = 0 ;
11696
11697   arg1 = (Dali::Property::Value *)jarg1;
11698   {
11699     try {
11700       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
11701     } CALL_CATCH_EXCEPTION(0);
11702   }
11703
11704   jresult = (void *)result;
11705   return jresult;
11706 }
11707
11708
11709 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
11710   char * jresult ;
11711   Dali::Property::Type arg1 ;
11712   char *result = 0 ;
11713
11714   arg1 = (Dali::Property::Type)jarg1;
11715   {
11716     try {
11717       result = (char *)Dali::PropertyTypes::GetName(arg1);
11718     } CALL_CATCH_EXCEPTION(0);
11719   }
11720
11721   jresult = SWIG_csharp_string_callback((const char *)result);
11722   return jresult;
11723 }
11724
11725
11726 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
11727   bool jresult ;
11728   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11729   std::string *arg2 = 0 ;
11730   Dali::Property::Map *arg3 = 0 ;
11731   bool result;
11732
11733   arg1 = (Dali::BaseObject *)jarg1;
11734   if (!jarg2) {
11735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11736     return 0;
11737   }
11738   std::string arg2_str(jarg2);
11739   arg2 = &arg2_str;
11740   arg3 = (Dali::Property::Map *)jarg3;
11741   if (!arg3) {
11742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
11743     return 0;
11744   }
11745   {
11746     try {
11747       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
11748     } CALL_CATCH_EXCEPTION(0);
11749   }
11750
11751   jresult = result;
11752
11753   //argout typemap for const std::string&
11754
11755   return jresult;
11756 }
11757
11758
11759 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
11760   char * jresult ;
11761   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11762   std::string *result = 0 ;
11763
11764   arg1 = (Dali::BaseObject *)jarg1;
11765   {
11766     try {
11767       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
11768     } CALL_CATCH_EXCEPTION(0);
11769   }
11770
11771   jresult = SWIG_csharp_string_callback(result->c_str());
11772   return jresult;
11773 }
11774
11775
11776 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
11777   bool jresult ;
11778   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11779   Dali::TypeInfo *arg2 = 0 ;
11780   bool result;
11781
11782   arg1 = (Dali::BaseObject *)jarg1;
11783   arg2 = (Dali::TypeInfo *)jarg2;
11784   if (!arg2) {
11785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
11786     return 0;
11787   }
11788   {
11789     try {
11790       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
11791     } CALL_CATCH_EXCEPTION(0);
11792   }
11793
11794   jresult = result;
11795   return jresult;
11796 }
11797
11798
11799 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
11800   bool jresult ;
11801   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11802   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
11803   std::string *arg3 = 0 ;
11804   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
11805   bool result;
11806
11807   arg1 = (Dali::BaseObject *)jarg1;
11808   arg2 = (ConnectionTrackerInterface *)jarg2;
11809   if (!jarg3) {
11810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11811     return 0;
11812   }
11813   std::string arg3_str(jarg3);
11814   arg3 = &arg3_str;
11815   arg4 = (FunctorDelegate *)jarg4;
11816   {
11817     try {
11818       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
11819     } CALL_CATCH_EXCEPTION(0);
11820   }
11821
11822   jresult = result;
11823
11824   //argout typemap for const std::string&
11825
11826   return jresult;
11827 }
11828
11829
11830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
11831   void * jresult ;
11832   Dali::BaseHandle *arg1 = 0 ;
11833   Dali::BaseObject *result = 0 ;
11834
11835   arg1 = (Dali::BaseHandle *)jarg1;
11836   if (!arg1) {
11837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11838     return 0;
11839   }
11840   {
11841     try {
11842       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
11843     } CALL_CATCH_EXCEPTION(0);
11844   }
11845
11846   jresult = (void *)result;
11847   return jresult;
11848 }
11849
11850
11851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
11852   void * jresult ;
11853   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11854   Dali::BaseHandle *result = 0 ;
11855
11856   arg1 = (Dali::BaseObject *)jarg1;
11857   {
11858     try {
11859       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
11860     } CALL_CATCH_EXCEPTION(0);
11861   }
11862
11863   jresult = (void *)result;
11864   return jresult;
11865 }
11866
11867
11868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
11869   void * jresult ;
11870   Dali::BaseHandle *result = 0 ;
11871
11872   {
11873     try {
11874       result = (Dali::BaseHandle *)new Dali::BaseHandle();
11875     } CALL_CATCH_EXCEPTION(0);
11876   }
11877
11878   jresult = (void *)result;
11879   return jresult;
11880 }
11881
11882
11883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
11884   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11885
11886   arg1 = (Dali::BaseHandle *)jarg1;
11887   {
11888     try {
11889       delete arg1;
11890     } CALL_CATCH_EXCEPTION();
11891   }
11892
11893 }
11894
11895
11896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
11897   void * jresult ;
11898   Dali::BaseHandle *arg1 = 0 ;
11899   Dali::BaseHandle *result = 0 ;
11900
11901   arg1 = (Dali::BaseHandle *)jarg1;
11902   if (!arg1) {
11903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11904     return 0;
11905   }
11906   {
11907     try {
11908       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
11909     } CALL_CATCH_EXCEPTION(0);
11910   }
11911
11912   jresult = (void *)result;
11913   return jresult;
11914 }
11915
11916
11917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
11918   void * jresult ;
11919   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11920   Dali::BaseHandle *arg2 = 0 ;
11921   Dali::BaseHandle *result = 0 ;
11922
11923   arg1 = (Dali::BaseHandle *)jarg1;
11924   arg2 = (Dali::BaseHandle *)jarg2;
11925   if (!arg2) {
11926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11927     return 0;
11928   }
11929   {
11930     try {
11931       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
11932     } CALL_CATCH_EXCEPTION(0);
11933   }
11934
11935   jresult = (void *)result;
11936   return jresult;
11937 }
11938
11939
11940 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
11941   bool jresult ;
11942   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11943   std::string *arg2 = 0 ;
11944   Dali::Property::Map *arg3 = 0 ;
11945   bool result;
11946
11947   arg1 = (Dali::BaseHandle *)jarg1;
11948   if (!jarg2) {
11949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11950     return 0;
11951   }
11952   std::string arg2_str(jarg2);
11953   arg2 = &arg2_str;
11954   arg3 = (Dali::Property::Map *)jarg3;
11955   if (!arg3) {
11956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
11957     return 0;
11958   }
11959   {
11960     try {
11961       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
11962     } CALL_CATCH_EXCEPTION(0);
11963   }
11964
11965   jresult = result;
11966
11967   //argout typemap for const std::string&
11968
11969   return jresult;
11970 }
11971
11972
11973 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
11974   char * jresult ;
11975   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11976   std::string *result = 0 ;
11977
11978   arg1 = (Dali::BaseHandle *)jarg1;
11979   {
11980     try {
11981       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
11982     } CALL_CATCH_EXCEPTION(0);
11983   }
11984
11985   jresult = SWIG_csharp_string_callback(result->c_str());
11986   return jresult;
11987 }
11988
11989
11990 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
11991   bool jresult ;
11992   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11993   Dali::TypeInfo *arg2 = 0 ;
11994   bool result;
11995
11996   arg1 = (Dali::BaseHandle *)jarg1;
11997   arg2 = (Dali::TypeInfo *)jarg2;
11998   if (!arg2) {
11999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
12000     return 0;
12001   }
12002   {
12003     try {
12004       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
12005     } CALL_CATCH_EXCEPTION(0);
12006   }
12007
12008   jresult = result;
12009   return jresult;
12010 }
12011
12012
12013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
12014   void * jresult ;
12015   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12016   Dali::BaseObject *result = 0 ;
12017
12018   arg1 = (Dali::BaseHandle *)jarg1;
12019   {
12020     try {
12021       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
12022     } CALL_CATCH_EXCEPTION(0);
12023   }
12024
12025   jresult = (void *)result;
12026   return jresult;
12027 }
12028
12029
12030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
12031   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12032
12033   arg1 = (Dali::BaseHandle *)jarg1;
12034   {
12035     try {
12036       (arg1)->Reset();
12037     } CALL_CATCH_EXCEPTION();
12038   }
12039
12040 }
12041
12042
12043 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
12044   bool jresult ;
12045   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12046   Dali::BaseHandle *arg2 = 0 ;
12047   bool result;
12048
12049   arg1 = (Dali::BaseHandle *)jarg1;
12050   arg2 = (Dali::BaseHandle *)jarg2;
12051   if (!arg2) {
12052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
12053     return 0;
12054   }
12055   {
12056     try {
12057       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
12058     } CALL_CATCH_EXCEPTION(0);
12059   }
12060
12061   jresult = result;
12062   return jresult;
12063 }
12064
12065
12066 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
12067   bool jresult ;
12068   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12069   Dali::BaseHandle *arg2 = 0 ;
12070   bool result;
12071
12072   arg1 = (Dali::BaseHandle *)jarg1;
12073   arg2 = (Dali::BaseHandle *)jarg2;
12074   if (!arg2) {
12075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
12076     return 0;
12077   }
12078   {
12079     try {
12080       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
12081     } CALL_CATCH_EXCEPTION(0);
12082   }
12083
12084   jresult = result;
12085   return jresult;
12086 }
12087
12088
12089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
12090   void * jresult ;
12091   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12092   Dali::RefObject *result = 0 ;
12093
12094   arg1 = (Dali::BaseHandle *)jarg1;
12095   {
12096     try {
12097       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
12098     } CALL_CATCH_EXCEPTION(0);
12099   }
12100
12101   jresult = (void *)result;
12102   return jresult;
12103 }
12104
12105
12106 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
12107   bool jresult ;
12108   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12109   bool result;
12110
12111   arg1 = (Dali::BaseHandle *)jarg1;
12112   {
12113     try {
12114       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
12115     } CALL_CATCH_EXCEPTION(0);
12116   }
12117
12118   jresult = result;
12119   return jresult;
12120 }
12121
12122
12123 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
12124   bool jresult ;
12125   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12126   Dali::BaseHandle *arg2 = 0 ;
12127   bool result;
12128
12129   arg1 = (Dali::BaseHandle *)jarg1;
12130   arg2 = (Dali::BaseHandle *)jarg2;
12131   if (!arg2) {
12132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
12133     return 0;
12134   }
12135   {
12136     try {
12137       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
12138     } CALL_CATCH_EXCEPTION(0);
12139   }
12140
12141   jresult = result;
12142   return jresult;
12143 }
12144
12145
12146 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
12147   bool jresult ;
12148   Dali::BaseHandle *arg1 = 0 ;
12149   Dali::BaseHandle *arg2 = 0 ;
12150   bool result;
12151
12152   arg1 = (Dali::BaseHandle *)jarg1;
12153   if (!arg1) {
12154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
12155     return 0;
12156   }
12157   arg2 = (Dali::BaseHandle *)jarg2;
12158   if (!arg2) {
12159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
12160     return 0;
12161   }
12162   {
12163     try {
12164       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
12165     } CALL_CATCH_EXCEPTION(0);
12166   }
12167
12168   jresult = result;
12169   return jresult;
12170 }
12171
12172
12173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
12174   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
12175
12176   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
12177   {
12178     try {
12179       delete arg1;
12180     } CALL_CATCH_EXCEPTION();
12181   }
12182
12183 }
12184
12185
12186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
12187   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
12188   SlotObserver *arg2 = (SlotObserver *) 0 ;
12189   CallbackBase *arg3 = (CallbackBase *) 0 ;
12190
12191   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
12192   arg2 = (SlotObserver *)jarg2;
12193   arg3 = (CallbackBase *)jarg3;
12194   {
12195     try {
12196       (arg1)->SignalConnected(arg2,arg3);
12197     } CALL_CATCH_EXCEPTION();
12198   }
12199
12200 }
12201
12202
12203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
12204   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
12205
12206   arg1 = (Dali::SignalObserver *)jarg1;
12207   {
12208     try {
12209       delete arg1;
12210     } CALL_CATCH_EXCEPTION();
12211   }
12212
12213 }
12214
12215
12216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
12217   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
12218   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
12219   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
12220
12221   arg1 = (Dali::SignalObserver *)jarg1;
12222   arg2 = (Dali::SlotObserver *)jarg2;
12223   arg3 = (Dali::CallbackBase *)jarg3;
12224   {
12225     try {
12226       (arg1)->SignalDisconnected(arg2,arg3);
12227     } CALL_CATCH_EXCEPTION();
12228   }
12229
12230 }
12231
12232
12233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
12234   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
12235
12236   arg1 = (Dali::SlotObserver *)jarg1;
12237   {
12238     try {
12239       delete arg1;
12240     } CALL_CATCH_EXCEPTION();
12241   }
12242
12243 }
12244
12245
12246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
12247   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
12248   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
12249
12250   arg1 = (Dali::SlotObserver *)jarg1;
12251   arg2 = (Dali::CallbackBase *)jarg2;
12252   {
12253     try {
12254       (arg1)->SlotDisconnected(arg2);
12255     } CALL_CATCH_EXCEPTION();
12256   }
12257
12258 }
12259
12260
12261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
12262   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
12263
12264   arg1 = (Dali::ConnectionTracker *)jarg1;
12265   {
12266     try {
12267       delete arg1;
12268     } CALL_CATCH_EXCEPTION();
12269   }
12270
12271 }
12272
12273
12274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
12275   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
12276
12277   arg1 = (Dali::ConnectionTracker *)jarg1;
12278   {
12279     try {
12280       (arg1)->DisconnectAll();
12281     } CALL_CATCH_EXCEPTION();
12282   }
12283
12284 }
12285
12286
12287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
12288   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
12289   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
12290   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
12291
12292   arg1 = (Dali::ConnectionTracker *)jarg1;
12293   arg2 = (Dali::SlotObserver *)jarg2;
12294   arg3 = (Dali::CallbackBase *)jarg3;
12295   {
12296     try {
12297       (arg1)->SignalConnected(arg2,arg3);
12298     } CALL_CATCH_EXCEPTION();
12299   }
12300
12301 }
12302
12303
12304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
12305   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
12306   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
12307   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
12308
12309   arg1 = (Dali::ConnectionTracker *)jarg1;
12310   arg2 = (Dali::SlotObserver *)jarg2;
12311   arg3 = (Dali::CallbackBase *)jarg3;
12312   {
12313     try {
12314       (arg1)->SignalDisconnected(arg2,arg3);
12315     } CALL_CATCH_EXCEPTION();
12316   }
12317
12318 }
12319
12320
12321 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
12322   unsigned long jresult ;
12323   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
12324   std::size_t result;
12325
12326   arg1 = (Dali::ConnectionTracker *)jarg1;
12327   {
12328     try {
12329       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
12330     } CALL_CATCH_EXCEPTION(0);
12331   }
12332
12333   jresult = (unsigned long)result;
12334   return jresult;
12335 }
12336
12337
12338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
12339   void * jresult ;
12340   Dali::ObjectRegistry *result = 0 ;
12341
12342   {
12343     try {
12344       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
12345     } CALL_CATCH_EXCEPTION(0);
12346   }
12347
12348   jresult = (void *)result;
12349   return jresult;
12350 }
12351
12352
12353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
12354   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
12355
12356   arg1 = (Dali::ObjectRegistry *)jarg1;
12357   {
12358     try {
12359       delete arg1;
12360     } CALL_CATCH_EXCEPTION();
12361   }
12362
12363 }
12364
12365
12366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
12367   void * jresult ;
12368   Dali::ObjectRegistry *arg1 = 0 ;
12369   Dali::ObjectRegistry *result = 0 ;
12370
12371   arg1 = (Dali::ObjectRegistry *)jarg1;
12372   if (!arg1) {
12373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
12374     return 0;
12375   }
12376   {
12377     try {
12378       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
12379     } CALL_CATCH_EXCEPTION(0);
12380   }
12381
12382   jresult = (void *)result;
12383   return jresult;
12384 }
12385
12386
12387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
12388   void * jresult ;
12389   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
12390   Dali::ObjectRegistry *arg2 = 0 ;
12391   Dali::ObjectRegistry *result = 0 ;
12392
12393   arg1 = (Dali::ObjectRegistry *)jarg1;
12394   arg2 = (Dali::ObjectRegistry *)jarg2;
12395   if (!arg2) {
12396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
12397     return 0;
12398   }
12399   {
12400     try {
12401       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
12402     } CALL_CATCH_EXCEPTION(0);
12403   }
12404
12405   jresult = (void *)result;
12406   return jresult;
12407 }
12408
12409
12410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
12411   void * jresult ;
12412   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
12413   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
12414
12415   arg1 = (Dali::ObjectRegistry *)jarg1;
12416   {
12417     try {
12418       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
12419     } CALL_CATCH_EXCEPTION(0);
12420   }
12421
12422   jresult = (void *)result;
12423   return jresult;
12424 }
12425
12426
12427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
12428   void * jresult ;
12429   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
12430   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
12431
12432   arg1 = (Dali::ObjectRegistry *)jarg1;
12433   {
12434     try {
12435       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
12436     } CALL_CATCH_EXCEPTION(0);
12437   }
12438
12439   jresult = (void *)result;
12440   return jresult;
12441 }
12442
12443
12444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
12445   void * jresult ;
12446   Dali::PropertyCondition *result = 0 ;
12447
12448   {
12449     try {
12450       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
12451     } CALL_CATCH_EXCEPTION(0);
12452   }
12453
12454   jresult = (void *)result;
12455   return jresult;
12456 }
12457
12458
12459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
12460   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
12461
12462   arg1 = (Dali::PropertyCondition *)jarg1;
12463   {
12464     try {
12465       delete arg1;
12466     } CALL_CATCH_EXCEPTION();
12467   }
12468
12469 }
12470
12471
12472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
12473   void * jresult ;
12474   Dali::PropertyCondition *arg1 = 0 ;
12475   Dali::PropertyCondition *result = 0 ;
12476
12477   arg1 = (Dali::PropertyCondition *)jarg1;
12478   if (!arg1) {
12479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
12480     return 0;
12481   }
12482   {
12483     try {
12484       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
12485     } CALL_CATCH_EXCEPTION(0);
12486   }
12487
12488   jresult = (void *)result;
12489   return jresult;
12490 }
12491
12492
12493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
12494   void * jresult ;
12495   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
12496   Dali::PropertyCondition *arg2 = 0 ;
12497   Dali::PropertyCondition *result = 0 ;
12498
12499   arg1 = (Dali::PropertyCondition *)jarg1;
12500   arg2 = (Dali::PropertyCondition *)jarg2;
12501   if (!arg2) {
12502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
12503     return 0;
12504   }
12505   {
12506     try {
12507       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
12508     } CALL_CATCH_EXCEPTION(0);
12509   }
12510
12511   jresult = (void *)result;
12512   return jresult;
12513 }
12514
12515
12516 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
12517   unsigned long jresult ;
12518   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
12519   std::size_t result;
12520
12521   arg1 = (Dali::PropertyCondition *)jarg1;
12522   {
12523     try {
12524       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
12525     } CALL_CATCH_EXCEPTION(0);
12526   }
12527   jresult = (unsigned long)result;
12528   return jresult;
12529 }
12530
12531
12532 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
12533   float jresult ;
12534   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
12535   std::size_t arg2 ;
12536   float result;
12537
12538   arg1 = (Dali::PropertyCondition *)jarg1;
12539   arg2 = (std::size_t)jarg2;
12540   {
12541     try {
12542       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
12543     } CALL_CATCH_EXCEPTION(0);
12544   }
12545   jresult = result;
12546   return jresult;
12547 }
12548
12549
12550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
12551   void * jresult ;
12552   float arg1 ;
12553   Dali::PropertyCondition result;
12554
12555   arg1 = (float)jarg1;
12556   {
12557     try {
12558       result = Dali::LessThanCondition(arg1);
12559     } CALL_CATCH_EXCEPTION(0);
12560   }
12561
12562   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12563   return jresult;
12564 }
12565
12566
12567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
12568   void * jresult ;
12569   float arg1 ;
12570   Dali::PropertyCondition result;
12571
12572   arg1 = (float)jarg1;
12573   {
12574     try {
12575       result = Dali::GreaterThanCondition(arg1);
12576     } CALL_CATCH_EXCEPTION(0);
12577   }
12578
12579   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12580   return jresult;
12581 }
12582
12583
12584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
12585   void * jresult ;
12586   float arg1 ;
12587   float arg2 ;
12588   Dali::PropertyCondition result;
12589
12590   arg1 = (float)jarg1;
12591   arg2 = (float)jarg2;
12592   {
12593     try {
12594       result = Dali::InsideCondition(arg1,arg2);
12595     } CALL_CATCH_EXCEPTION(0);
12596   }
12597
12598   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12599   return jresult;
12600 }
12601
12602
12603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
12604   void * jresult ;
12605   float arg1 ;
12606   float arg2 ;
12607   Dali::PropertyCondition result;
12608
12609   arg1 = (float)jarg1;
12610   arg2 = (float)jarg2;
12611   {
12612     try {
12613       result = Dali::OutsideCondition(arg1,arg2);
12614     } CALL_CATCH_EXCEPTION(0);
12615   }
12616
12617   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12618   return jresult;
12619 }
12620
12621
12622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
12623   void * jresult ;
12624   float arg1 ;
12625   float arg2 ;
12626   Dali::PropertyCondition result;
12627
12628   arg1 = (float)jarg1;
12629   arg2 = (float)jarg2;
12630   {
12631     try {
12632       result = Dali::StepCondition(arg1,arg2);
12633     } CALL_CATCH_EXCEPTION(0);
12634   }
12635
12636   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12637   return jresult;
12638 }
12639
12640
12641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
12642   void * jresult ;
12643   float arg1 ;
12644   Dali::PropertyCondition result;
12645
12646   arg1 = (float)jarg1;
12647   {
12648     try {
12649       result = Dali::StepCondition(arg1);
12650     } CALL_CATCH_EXCEPTION(0);
12651   }
12652
12653   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12654   return jresult;
12655 }
12656
12657
12658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
12659   void * jresult ;
12660   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
12661   Dali::PropertyCondition result;
12662
12663   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
12664   if (!arg1) {
12665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
12666     return 0;
12667   }
12668   {
12669     try {
12670       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
12671     } CALL_CATCH_EXCEPTION(0);
12672   }
12673
12674   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12675   return jresult;
12676 }
12677
12678
12679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
12680   void * jresult ;
12681   Dali::PropertyNotification *result = 0 ;
12682
12683   {
12684     try {
12685       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
12686     } CALL_CATCH_EXCEPTION(0);
12687   }
12688
12689   jresult = (void *)result;
12690   return jresult;
12691 }
12692
12693
12694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
12695   void * jresult ;
12696   Dali::BaseHandle arg1 ;
12697   Dali::BaseHandle *argp1 ;
12698   Dali::PropertyNotification result;
12699
12700   argp1 = (Dali::BaseHandle *)jarg1;
12701   if (!argp1) {
12702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
12703     return 0;
12704   }
12705   arg1 = *argp1;
12706   {
12707     try {
12708       result = Dali::PropertyNotification::DownCast(arg1);
12709     } CALL_CATCH_EXCEPTION(0);
12710   }
12711
12712   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
12713   return jresult;
12714 }
12715
12716
12717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
12718   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12719
12720   arg1 = (Dali::PropertyNotification *)jarg1;
12721   {
12722     try {
12723       delete arg1;
12724     } CALL_CATCH_EXCEPTION();
12725   }
12726
12727 }
12728
12729
12730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
12731   void * jresult ;
12732   Dali::PropertyNotification *arg1 = 0 ;
12733   Dali::PropertyNotification *result = 0 ;
12734
12735   arg1 = (Dali::PropertyNotification *)jarg1;
12736   if (!arg1) {
12737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
12738     return 0;
12739   }
12740   {
12741     try {
12742       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
12743     } CALL_CATCH_EXCEPTION(0);
12744   }
12745
12746   jresult = (void *)result;
12747   return jresult;
12748 }
12749
12750
12751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
12752   void * jresult ;
12753   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12754   Dali::PropertyNotification *arg2 = 0 ;
12755   Dali::PropertyNotification *result = 0 ;
12756
12757   arg1 = (Dali::PropertyNotification *)jarg1;
12758   arg2 = (Dali::PropertyNotification *)jarg2;
12759   if (!arg2) {
12760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
12761     return 0;
12762   }
12763   {
12764     try {
12765       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
12766     } CALL_CATCH_EXCEPTION(0);
12767   }
12768
12769   jresult = (void *)result;
12770   return jresult;
12771 }
12772
12773
12774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
12775   void * jresult ;
12776   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12777   Dali::PropertyCondition result;
12778
12779   arg1 = (Dali::PropertyNotification *)jarg1;
12780   {
12781     try {
12782       result = (arg1)->GetCondition();
12783     } CALL_CATCH_EXCEPTION(0);
12784   }
12785
12786   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12787   return jresult;
12788 }
12789
12790
12791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
12792   void * jresult ;
12793   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12794   Dali::Handle result;
12795
12796   arg1 = (Dali::PropertyNotification *)jarg1;
12797   {
12798     try {
12799       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
12800     } CALL_CATCH_EXCEPTION(0);
12801   }
12802
12803   jresult = new Dali::Handle((const Dali::Handle &)result);
12804   return jresult;
12805 }
12806
12807
12808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
12809   int jresult ;
12810   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12811   Dali::Property::Index result;
12812
12813   arg1 = (Dali::PropertyNotification *)jarg1;
12814   {
12815     try {
12816       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
12817     } CALL_CATCH_EXCEPTION(0);
12818   }
12819
12820   jresult = result;
12821   return jresult;
12822 }
12823
12824
12825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
12826   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12827   Dali::PropertyNotification::NotifyMode arg2 ;
12828
12829   arg1 = (Dali::PropertyNotification *)jarg1;
12830   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
12831   {
12832     try {
12833       (arg1)->SetNotifyMode(arg2);
12834     } CALL_CATCH_EXCEPTION();
12835   }
12836
12837 }
12838
12839
12840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
12841   int jresult ;
12842   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12843   Dali::PropertyNotification::NotifyMode result;
12844
12845   arg1 = (Dali::PropertyNotification *)jarg1;
12846   {
12847     try {
12848       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
12849     } CALL_CATCH_EXCEPTION(0);
12850   }
12851
12852   jresult = (int)result;
12853   return jresult;
12854 }
12855
12856
12857 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
12858   bool jresult ;
12859   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12860   bool result;
12861
12862   arg1 = (Dali::PropertyNotification *)jarg1;
12863   {
12864     try {
12865       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
12866     } CALL_CATCH_EXCEPTION(0);
12867   }
12868
12869   jresult = result;
12870   return jresult;
12871 }
12872
12873
12874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
12875   void * jresult ;
12876   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12877   Dali::PropertyNotifySignalType *result = 0 ;
12878
12879   arg1 = (Dali::PropertyNotification *)jarg1;
12880   {
12881     try {
12882       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
12883     } CALL_CATCH_EXCEPTION(0);
12884   }
12885
12886   jresult = (void *)result;
12887   return jresult;
12888 }
12889
12890
12891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
12892   void * jresult ;
12893   Dali::Handle *result = 0 ;
12894
12895   {
12896     try {
12897       result = (Dali::Handle *)new Dali::Handle();
12898     } CALL_CATCH_EXCEPTION(0);
12899   }
12900
12901   jresult = (void *)result;
12902   return jresult;
12903 }
12904
12905
12906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
12907   void * jresult ;
12908   Dali::Handle result;
12909
12910   {
12911     try {
12912       result = Dali::Handle::New();
12913     } CALL_CATCH_EXCEPTION(0);
12914   }
12915
12916   jresult = new Dali::Handle((const Dali::Handle &)result);
12917   return jresult;
12918 }
12919
12920
12921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
12922   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12923
12924   arg1 = (Dali::Handle *)jarg1;
12925   {
12926     try {
12927       delete arg1;
12928     } CALL_CATCH_EXCEPTION();
12929   }
12930
12931 }
12932
12933
12934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
12935   void * jresult ;
12936   Dali::Handle *arg1 = 0 ;
12937   Dali::Handle *result = 0 ;
12938
12939   arg1 = (Dali::Handle *)jarg1;
12940   if (!arg1) {
12941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
12942     return 0;
12943   }
12944   {
12945     try {
12946       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
12947     } CALL_CATCH_EXCEPTION(0);
12948   }
12949
12950   jresult = (void *)result;
12951   return jresult;
12952 }
12953
12954
12955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
12956   void * jresult ;
12957   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12958   Dali::Handle *arg2 = 0 ;
12959   Dali::Handle *result = 0 ;
12960
12961   arg1 = (Dali::Handle *)jarg1;
12962   arg2 = (Dali::Handle *)jarg2;
12963   if (!arg2) {
12964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
12965     return 0;
12966   }
12967   {
12968     try {
12969       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
12970     } CALL_CATCH_EXCEPTION(0);
12971   }
12972
12973   jresult = (void *)result;
12974   return jresult;
12975 }
12976
12977
12978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
12979   void * jresult ;
12980   Dali::BaseHandle arg1 ;
12981   Dali::BaseHandle *argp1 ;
12982   Dali::Handle result;
12983
12984   argp1 = (Dali::BaseHandle *)jarg1;
12985   if (!argp1) {
12986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
12987     return 0;
12988   }
12989   arg1 = *argp1;
12990   {
12991     try {
12992       result = Dali::Handle::DownCast(arg1);
12993     } CALL_CATCH_EXCEPTION(0);
12994   }
12995
12996   jresult = new Dali::Handle((const Dali::Handle &)result);
12997   return jresult;
12998 }
12999
13000
13001 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
13002   bool jresult ;
13003   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13004   Dali::Handle::Capability arg2 ;
13005   bool result;
13006
13007   arg1 = (Dali::Handle *)jarg1;
13008   arg2 = (Dali::Handle::Capability)jarg2;
13009   {
13010     try {
13011       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
13012     } CALL_CATCH_EXCEPTION(0);
13013   }
13014
13015   jresult = result;
13016   return jresult;
13017 }
13018
13019
13020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
13021   unsigned int jresult ;
13022   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13023   unsigned int result;
13024
13025   arg1 = (Dali::Handle *)jarg1;
13026   {
13027     try {
13028       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
13029     } CALL_CATCH_EXCEPTION(0);
13030   }
13031
13032   jresult = result;
13033   return jresult;
13034 }
13035
13036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_LookAt(void* csActor, void* csTarget, void* csUp, void* csLocalForward, void* csLocalUp)
13037 {
13038   Dali::Actor   actor;
13039   Dali::Vector3 target;
13040   Dali::Vector3 up           = Vector3::YAXIS;
13041   Dali::Vector3 localForward = Vector3::ZAXIS;
13042   Dali::Vector3 localUp      = Vector3::YAXIS;
13043
13044   if(!csActor)
13045   {
13046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
13047     return;
13048   }
13049
13050   if(!csTarget)
13051   {
13052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null target Dali::Vector3", 0);
13053     return;
13054   }
13055
13056   actor  = *(Dali::Actor*)csActor;
13057   target = *(Dali::Vector3*)csTarget;
13058
13059   // Use default value if csUp is null
13060   if(csUp)
13061   {
13062     up = *(Dali::Vector3*)csUp;
13063   }
13064
13065   // Use default value if csLocalForward is null
13066   if(csLocalForward)
13067   {
13068     localForward = *(Dali::Vector3*)csLocalForward;
13069   }
13070
13071   // Use default value if csLocalForward is null
13072   if(csLocalUp)
13073   {
13074     localUp = *(Dali::Vector3*)csLocalUp;
13075   }
13076
13077   {
13078     try
13079     {
13080       Dali::DevelActor::LookAt(actor, target, up, localForward, localUp);
13081     }
13082     CALL_CATCH_EXCEPTION();
13083   }
13084 }
13085
13086 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
13087   char * jresult ;
13088   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13089   Dali::Property::Index arg2 ;
13090   std::string result;
13091
13092   arg1 = (Dali::Handle *)jarg1;
13093   arg2 = (Dali::Property::Index)jarg2;
13094   {
13095     try {
13096       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
13097     } CALL_CATCH_EXCEPTION(0);
13098   }
13099
13100   jresult = SWIG_csharp_string_callback((&result)->c_str());
13101   return jresult;
13102 }
13103
13104
13105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
13106   int jresult ;
13107   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13108   std::string *arg2 = 0 ;
13109   Dali::Property::Index result;
13110
13111   arg1 = (Dali::Handle *)jarg1;
13112   if (!jarg2) {
13113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13114     return 0;
13115   }
13116   std::string arg2_str(jarg2);
13117   arg2 = &arg2_str;
13118   {
13119     try {
13120       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
13121     } CALL_CATCH_EXCEPTION(0);
13122   }
13123
13124   jresult = result;
13125
13126   //argout typemap for const std::string&
13127
13128   return jresult;
13129 }
13130
13131
13132 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
13133   bool jresult ;
13134   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13135   Dali::Property::Index arg2 ;
13136   bool result;
13137
13138   arg1 = (Dali::Handle *)jarg1;
13139   arg2 = (Dali::Property::Index)jarg2;
13140   {
13141     try {
13142       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
13143     } CALL_CATCH_EXCEPTION(0);
13144   }
13145
13146   jresult = result;
13147   return jresult;
13148 }
13149
13150
13151 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
13152   bool jresult ;
13153   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13154   Dali::Property::Index arg2 ;
13155   bool result;
13156
13157   arg1 = (Dali::Handle *)jarg1;
13158   arg2 = (Dali::Property::Index)jarg2;
13159   {
13160     try {
13161       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
13162     } CALL_CATCH_EXCEPTION(0);
13163   }
13164
13165   jresult = result;
13166   return jresult;
13167 }
13168
13169
13170 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
13171   bool jresult ;
13172   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13173   Dali::Property::Index arg2 ;
13174   bool result;
13175
13176   arg1 = (Dali::Handle *)jarg1;
13177   arg2 = (Dali::Property::Index)jarg2;
13178   {
13179     try {
13180       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
13181     } CALL_CATCH_EXCEPTION(0);
13182   }
13183
13184   jresult = result;
13185   return jresult;
13186 }
13187
13188
13189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
13190   int jresult ;
13191   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13192   Dali::Property::Index arg2 ;
13193   Dali::Property::Type result;
13194
13195   arg1 = (Dali::Handle *)jarg1;
13196   arg2 = (Dali::Property::Index)jarg2;
13197   {
13198     try {
13199       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
13200     } CALL_CATCH_EXCEPTION(0);
13201   }
13202
13203   jresult = (int)result;
13204   return jresult;
13205 }
13206
13207
13208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
13209   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13210   Dali::Property::Index arg2 ;
13211   Dali::Property::Value *arg3 = 0 ;
13212
13213   arg1 = (Dali::Handle *)jarg1;
13214   arg2 = (Dali::Property::Index)jarg2;
13215   arg3 = (Dali::Property::Value *)jarg3;
13216   if (!arg3) {
13217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13218     return ;
13219   }
13220   {
13221     try {
13222       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
13223     } CALL_CATCH_EXCEPTION();
13224   }
13225
13226 }
13227
13228
13229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
13230   int jresult ;
13231   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13232   std::string *arg2 = 0 ;
13233   Dali::Property::Value *arg3 = 0 ;
13234   Dali::Property::Index result;
13235
13236   arg1 = (Dali::Handle *)jarg1;
13237   if (!jarg2) {
13238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13239     return 0;
13240   }
13241   std::string arg2_str(jarg2);
13242   arg2 = &arg2_str;
13243   arg3 = (Dali::Property::Value *)jarg3;
13244   if (!arg3) {
13245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13246     return 0;
13247   }
13248   {
13249     try {
13250       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
13251     } CALL_CATCH_EXCEPTION(0);
13252   }
13253
13254   jresult = result;
13255
13256   //argout typemap for const std::string&
13257
13258   return jresult;
13259 }
13260
13261
13262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
13263   int jresult ;
13264   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13265   std::string *arg2 = 0 ;
13266   Dali::Property::Value *arg3 = 0 ;
13267   Dali::Property::AccessMode arg4 ;
13268   Dali::Property::Index result;
13269
13270   arg1 = (Dali::Handle *)jarg1;
13271   if (!jarg2) {
13272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13273     return 0;
13274   }
13275   std::string arg2_str(jarg2);
13276   arg2 = &arg2_str;
13277   arg3 = (Dali::Property::Value *)jarg3;
13278   if (!arg3) {
13279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13280     return 0;
13281   }
13282   arg4 = (Dali::Property::AccessMode)jarg4;
13283   {
13284     try {
13285       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
13286     } CALL_CATCH_EXCEPTION(0);
13287   }
13288
13289   jresult = result;
13290
13291   //argout typemap for const std::string&
13292
13293   return jresult;
13294 }
13295
13296
13297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
13298   void * jresult ;
13299   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13300   Dali::Property::Index arg2 ;
13301   Dali::Property::Value result;
13302
13303   arg1 = (Dali::Handle *)jarg1;
13304   arg2 = (Dali::Property::Index)jarg2;
13305   {
13306     try {
13307       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
13308     } CALL_CATCH_EXCEPTION(0);
13309   }
13310
13311   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
13312   return jresult;
13313 }
13314
13315
13316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetCurrentProperty(void * jarg1, int jarg2) {
13317   void * jresult ;
13318   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13319   Dali::Property::Index arg2 ;
13320   Dali::Property::Value result;
13321
13322   arg1 = (Dali::Handle *)jarg1;
13323   arg2 = (Dali::Property::Index)jarg2;
13324   {
13325     try {
13326       result = ((Dali::Handle const *)arg1)->GetCurrentProperty(arg2);
13327     } CALL_CATCH_EXCEPTION(0);
13328   }
13329
13330   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
13331   return jresult;
13332 }
13333
13334
13335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
13336   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13337   Dali::Property::IndexContainer *arg2 = 0 ;
13338
13339   arg1 = (Dali::Handle *)jarg1;
13340   arg2 = (Dali::Property::IndexContainer *)jarg2;
13341   if (!arg2) {
13342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
13343     return ;
13344   }
13345   {
13346     try {
13347       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
13348     } CALL_CATCH_EXCEPTION();
13349   }
13350
13351 }
13352
13353
13354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
13355   void * jresult ;
13356   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13357   Dali::Property::Index arg2 ;
13358   Dali::PropertyCondition *arg3 = 0 ;
13359   Dali::PropertyNotification result;
13360
13361   arg1 = (Dali::Handle *)jarg1;
13362   arg2 = (Dali::Property::Index)jarg2;
13363   arg3 = (Dali::PropertyCondition *)jarg3;
13364   if (!arg3) {
13365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
13366     return 0;
13367   }
13368   {
13369     try {
13370       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
13371     } CALL_CATCH_EXCEPTION(0);
13372   }
13373
13374   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
13375   return jresult;
13376 }
13377
13378
13379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
13380   void * jresult ;
13381   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13382   Dali::Property::Index arg2 ;
13383   int arg3 ;
13384   Dali::PropertyCondition *arg4 = 0 ;
13385   Dali::PropertyNotification result;
13386
13387   arg1 = (Dali::Handle *)jarg1;
13388   arg2 = (Dali::Property::Index)jarg2;
13389   arg3 = (int)jarg3;
13390   arg4 = (Dali::PropertyCondition *)jarg4;
13391   if (!arg4) {
13392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
13393     return 0;
13394   }
13395   {
13396     try {
13397       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
13398     } CALL_CATCH_EXCEPTION(0);
13399   }
13400
13401   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
13402   return jresult;
13403 }
13404
13405
13406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
13407   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13408   Dali::PropertyNotification arg2 ;
13409   Dali::PropertyNotification *argp2 ;
13410
13411   arg1 = (Dali::Handle *)jarg1;
13412   argp2 = (Dali::PropertyNotification *)jarg2;
13413   if (!argp2) {
13414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
13415     return ;
13416   }
13417   arg2 = *argp2;
13418   {
13419     try {
13420       (arg1)->RemovePropertyNotification(arg2);
13421     } CALL_CATCH_EXCEPTION();
13422   }
13423
13424 }
13425
13426
13427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
13428   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13429
13430   arg1 = (Dali::Handle *)jarg1;
13431   {
13432     try {
13433       (arg1)->RemovePropertyNotifications();
13434     } CALL_CATCH_EXCEPTION();
13435   }
13436
13437 }
13438
13439
13440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
13441   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13442
13443   arg1 = (Dali::Handle *)jarg1;
13444   {
13445     try {
13446       (arg1)->RemoveConstraints();
13447     } CALL_CATCH_EXCEPTION();
13448   }
13449
13450 }
13451
13452
13453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
13454   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13455   unsigned int arg2 ;
13456
13457   arg1 = (Dali::Handle *)jarg1;
13458   arg2 = (unsigned int)jarg2;
13459   {
13460     try {
13461       (arg1)->RemoveConstraints(arg2);
13462     } CALL_CATCH_EXCEPTION();
13463   }
13464
13465 }
13466
13467
13468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
13469   int jresult ;
13470   Dali::Property::Index result;
13471
13472   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
13473   jresult = result;
13474   return jresult;
13475 }
13476
13477
13478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
13479   void * jresult ;
13480   Dali::Handle result;
13481
13482   {
13483     try {
13484       result = Dali::WeightObject::New();
13485     } CALL_CATCH_EXCEPTION(0);
13486   }
13487
13488   jresult = new Dali::Handle((const Dali::Handle &)result);
13489   return jresult;
13490 }
13491
13492
13493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
13494   void * jresult ;
13495   Dali::TypeInfo *result = 0 ;
13496
13497   {
13498     try {
13499       result = (Dali::TypeInfo *)new Dali::TypeInfo();
13500     } CALL_CATCH_EXCEPTION(0);
13501   }
13502
13503   jresult = (void *)result;
13504   return jresult;
13505 }
13506
13507
13508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
13509   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13510
13511   arg1 = (Dali::TypeInfo *)jarg1;
13512   {
13513     try {
13514       delete arg1;
13515     } CALL_CATCH_EXCEPTION();
13516   }
13517
13518 }
13519
13520
13521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
13522   void * jresult ;
13523   Dali::TypeInfo *arg1 = 0 ;
13524   Dali::TypeInfo *result = 0 ;
13525
13526   arg1 = (Dali::TypeInfo *)jarg1;
13527   if (!arg1) {
13528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
13529     return 0;
13530   }
13531   {
13532     try {
13533       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
13534     } CALL_CATCH_EXCEPTION(0);
13535   }
13536
13537   jresult = (void *)result;
13538   return jresult;
13539 }
13540
13541
13542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
13543   void * jresult ;
13544   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13545   Dali::TypeInfo *arg2 = 0 ;
13546   Dali::TypeInfo *result = 0 ;
13547
13548   arg1 = (Dali::TypeInfo *)jarg1;
13549   arg2 = (Dali::TypeInfo *)jarg2;
13550   if (!arg2) {
13551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
13552     return 0;
13553   }
13554   {
13555     try {
13556       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
13557     } CALL_CATCH_EXCEPTION(0);
13558   }
13559
13560   jresult = (void *)result;
13561   return jresult;
13562 }
13563
13564
13565 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
13566   char * jresult ;
13567   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13568   std::string *result = 0 ;
13569
13570   arg1 = (Dali::TypeInfo *)jarg1;
13571   {
13572     try {
13573       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
13574     } CALL_CATCH_EXCEPTION(0);
13575   }
13576
13577   jresult = SWIG_csharp_string_callback(result->c_str());
13578   return jresult;
13579 }
13580
13581
13582 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
13583   char * jresult ;
13584   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13585   std::string *result = 0 ;
13586
13587   arg1 = (Dali::TypeInfo *)jarg1;
13588   {
13589     try {
13590       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
13591     } CALL_CATCH_EXCEPTION(0);
13592   }
13593
13594   jresult = SWIG_csharp_string_callback(result->c_str());
13595   return jresult;
13596 }
13597
13598
13599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
13600   void * jresult ;
13601   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13602   Dali::BaseHandle result;
13603
13604   arg1 = (Dali::TypeInfo *)jarg1;
13605   {
13606     try {
13607       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
13608     } CALL_CATCH_EXCEPTION(0);
13609   }
13610
13611   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
13612   return jresult;
13613 }
13614
13615
13616 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
13617   unsigned long jresult ;
13618   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13619   size_t result;
13620
13621   arg1 = (Dali::TypeInfo *)jarg1;
13622   {
13623     try {
13624       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
13625     } CALL_CATCH_EXCEPTION(0);
13626   }
13627
13628   jresult = (unsigned long)result;
13629   return jresult;
13630 }
13631
13632
13633 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
13634   char * jresult ;
13635   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13636   size_t arg2 ;
13637   std::string result;
13638
13639   arg1 = (Dali::TypeInfo *)jarg1;
13640   arg2 = (size_t)jarg2;
13641   {
13642     try {
13643       result = (arg1)->GetActionName(arg2);
13644     } CALL_CATCH_EXCEPTION(0);
13645   }
13646
13647   jresult = SWIG_csharp_string_callback((&result)->c_str());
13648   return jresult;
13649 }
13650
13651
13652 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
13653   unsigned long jresult ;
13654   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13655   size_t result;
13656
13657   arg1 = (Dali::TypeInfo *)jarg1;
13658   {
13659     try {
13660       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
13661     } CALL_CATCH_EXCEPTION(0);
13662   }
13663
13664   jresult = (unsigned long)result;
13665   return jresult;
13666 }
13667
13668
13669 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
13670   char * jresult ;
13671   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13672   size_t arg2 ;
13673   std::string result;
13674
13675   arg1 = (Dali::TypeInfo *)jarg1;
13676   arg2 = (size_t)jarg2;
13677   {
13678     try {
13679       result = (arg1)->GetSignalName(arg2);
13680     } CALL_CATCH_EXCEPTION(0);
13681   }
13682
13683   jresult = SWIG_csharp_string_callback((&result)->c_str());
13684   return jresult;
13685 }
13686
13687
13688 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
13689   unsigned long jresult ;
13690   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13691   size_t result;
13692
13693   arg1 = (Dali::TypeInfo *)jarg1;
13694   {
13695     try {
13696       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
13697     } CALL_CATCH_EXCEPTION(0);
13698   }
13699
13700   jresult = (unsigned long)result;
13701   return jresult;
13702 }
13703
13704
13705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
13706   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13707   Dali::Property::IndexContainer *arg2 = 0 ;
13708
13709   arg1 = (Dali::TypeInfo *)jarg1;
13710   arg2 = (Dali::Property::IndexContainer *)jarg2;
13711   if (!arg2) {
13712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
13713     return ;
13714   }
13715   {
13716     try {
13717       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
13718     } CALL_CATCH_EXCEPTION();
13719   }
13720
13721 }
13722
13723
13724 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
13725   char * jresult ;
13726   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13727   Dali::Property::Index arg2 ;
13728   std::string_view result;
13729
13730   arg1 = (Dali::TypeInfo *)jarg1;
13731   arg2 = (Dali::Property::Index)jarg2;
13732   {
13733     try {
13734       result = ((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
13735     } CALL_CATCH_EXCEPTION(0);
13736   }
13737
13738   jresult = SWIG_csharp_string_callback(result.data());
13739   return jresult;
13740 }
13741
13742
13743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
13744   void * jresult ;
13745   Dali::TypeRegistry result;
13746
13747   {
13748     try {
13749       result = Dali::TypeRegistry::Get();
13750     } CALL_CATCH_EXCEPTION(0);
13751   }
13752
13753   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
13754   return jresult;
13755 }
13756
13757
13758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
13759   void * jresult ;
13760   Dali::TypeRegistry *result = 0 ;
13761
13762   {
13763     try {
13764       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
13765     } CALL_CATCH_EXCEPTION(0);
13766   }
13767
13768   jresult = (void *)result;
13769   return jresult;
13770 }
13771
13772
13773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
13774   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13775
13776   arg1 = (Dali::TypeRegistry *)jarg1;
13777   {
13778     try {
13779       delete arg1;
13780     } CALL_CATCH_EXCEPTION();
13781   }
13782
13783 }
13784
13785
13786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
13787   void * jresult ;
13788   Dali::TypeRegistry *arg1 = 0 ;
13789   Dali::TypeRegistry *result = 0 ;
13790
13791   arg1 = (Dali::TypeRegistry *)jarg1;
13792   if (!arg1) {
13793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
13794     return 0;
13795   }
13796   {
13797     try {
13798       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
13799     } CALL_CATCH_EXCEPTION(0);
13800   }
13801
13802   jresult = (void *)result;
13803   return jresult;
13804 }
13805
13806
13807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
13808   void * jresult ;
13809   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13810   Dali::TypeRegistry *arg2 = 0 ;
13811   Dali::TypeRegistry *result = 0 ;
13812
13813   arg1 = (Dali::TypeRegistry *)jarg1;
13814   arg2 = (Dali::TypeRegistry *)jarg2;
13815   if (!arg2) {
13816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
13817     return 0;
13818   }
13819   {
13820     try {
13821       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
13822     } CALL_CATCH_EXCEPTION(0);
13823   }
13824
13825   jresult = (void *)result;
13826   return jresult;
13827 }
13828
13829
13830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
13831   void * jresult ;
13832   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13833   std::string *arg2 = 0 ;
13834   Dali::TypeInfo result;
13835
13836   arg1 = (Dali::TypeRegistry *)jarg1;
13837   if (!jarg2) {
13838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13839     return 0;
13840   }
13841   std::string arg2_str(jarg2);
13842   arg2 = &arg2_str;
13843   {
13844     try {
13845       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
13846     } CALL_CATCH_EXCEPTION(0);
13847   }
13848
13849   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
13850
13851   //argout typemap for const std::string&
13852
13853   return jresult;
13854 }
13855
13856
13857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
13858   void * jresult ;
13859   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13860   std::type_info *arg2 = 0 ;
13861   Dali::TypeInfo result;
13862
13863   arg1 = (Dali::TypeRegistry *)jarg1;
13864   arg2 = (std::type_info *)jarg2;
13865   if (!arg2) {
13866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13867     return 0;
13868   }
13869   {
13870     try {
13871       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
13872     } CALL_CATCH_EXCEPTION(0);
13873   }
13874
13875   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
13876   return jresult;
13877 }
13878
13879
13880 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
13881   unsigned long jresult ;
13882   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13883   size_t result;
13884
13885   arg1 = (Dali::TypeRegistry *)jarg1;
13886   {
13887     try {
13888       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
13889     } CALL_CATCH_EXCEPTION(0);
13890   }
13891
13892   jresult = (unsigned long)result;
13893   return jresult;
13894 }
13895
13896
13897 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
13898   char * jresult ;
13899   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13900   size_t arg2 ;
13901   std::string result;
13902
13903   arg1 = (Dali::TypeRegistry *)jarg1;
13904   arg2 = (size_t)jarg2;
13905   {
13906     try {
13907       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
13908     } CALL_CATCH_EXCEPTION(0);
13909   }
13910
13911   jresult = SWIG_csharp_string_callback((&result)->c_str());
13912   return jresult;
13913 }
13914
13915
13916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
13917   void * jresult ;
13918   std::type_info *arg1 = 0 ;
13919   std::type_info *arg2 = 0 ;
13920   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
13921   Dali::TypeRegistration *result = 0 ;
13922
13923   arg1 = (std::type_info *)jarg1;
13924   if (!arg1) {
13925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13926     return 0;
13927   }
13928   arg2 = (std::type_info *)jarg2;
13929   if (!arg2) {
13930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13931     return 0;
13932   }
13933   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
13934   {
13935     try {
13936       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
13937     } CALL_CATCH_EXCEPTION(0);
13938   }
13939
13940   jresult = (void *)result;
13941   return jresult;
13942 }
13943
13944
13945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, bool jarg4) {
13946   void * jresult ;
13947   std::type_info *arg1 = 0 ;
13948   std::type_info *arg2 = 0 ;
13949   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
13950   bool arg4 ;
13951   Dali::TypeRegistration *result = 0 ;
13952
13953   arg1 = (std::type_info *)jarg1;
13954   if (!arg1) {
13955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13956     return 0;
13957   }
13958   arg2 = (std::type_info *)jarg2;
13959   if (!arg2) {
13960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13961     return 0;
13962   }
13963   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
13964   arg4 = jarg4 ? true : false;
13965   {
13966     try {
13967       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
13968     } CALL_CATCH_EXCEPTION(0);
13969   }
13970
13971   jresult = (void *)result;
13972   return jresult;
13973 }
13974
13975
13976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
13977   void * jresult ;
13978   std::string *arg1 = 0 ;
13979   std::type_info *arg2 = 0 ;
13980   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
13981   Dali::TypeRegistration *result = 0 ;
13982
13983   if (!jarg1) {
13984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13985     return 0;
13986   }
13987   std::string arg1_str(jarg1);
13988   arg1 = &arg1_str;
13989   arg2 = (std::type_info *)jarg2;
13990   if (!arg2) {
13991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13992     return 0;
13993   }
13994   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
13995   {
13996     try {
13997       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
13998     } CALL_CATCH_EXCEPTION(0);
13999   }
14000
14001   jresult = (void *)result;
14002
14003   //argout typemap for const std::string&
14004
14005   return jresult;
14006 }
14007
14008
14009 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
14010   char * jresult ;
14011   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
14012   std::string result;
14013
14014   arg1 = (Dali::TypeRegistration *)jarg1;
14015   {
14016     try {
14017       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
14018     } CALL_CATCH_EXCEPTION(0);
14019   }
14020
14021   jresult = SWIG_csharp_string_callback((&result)->c_str());
14022   return jresult;
14023 }
14024
14025
14026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
14027   std::string *arg1 = 0 ;
14028   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
14029
14030   if (!jarg1) {
14031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14032     return ;
14033   }
14034   std::string arg1_str(jarg1);
14035   arg1 = &arg1_str;
14036   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
14037   {
14038     try {
14039       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
14040     } CALL_CATCH_EXCEPTION();
14041   }
14042
14043
14044   //argout typemap for const std::string&
14045
14046 }
14047
14048
14049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
14050   std::string *arg1 = 0 ;
14051   std::string *arg2 = 0 ;
14052   int arg3 ;
14053   Dali::Property::Type arg4 ;
14054   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
14055   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
14056
14057   if (!jarg1) {
14058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14059     return ;
14060   }
14061   std::string arg1_str(jarg1);
14062   arg1 = &arg1_str;
14063   if (!jarg2) {
14064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14065     return ;
14066   }
14067   std::string arg2_str(jarg2);
14068   arg2 = &arg2_str;
14069   arg3 = (int)jarg3;
14070   arg4 = (Dali::Property::Type)jarg4;
14071   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
14072   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
14073   {
14074     try {
14075       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
14076     } CALL_CATCH_EXCEPTION();
14077   }
14078
14079
14080   //argout typemap for const std::string&
14081
14082
14083   //argout typemap for const std::string&
14084
14085 }
14086
14087
14088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
14089   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
14090
14091   arg1 = (Dali::TypeRegistration *)jarg1;
14092   {
14093     try {
14094       delete arg1;
14095     } CALL_CATCH_EXCEPTION();
14096   }
14097
14098 }
14099
14100
14101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
14102   void * jresult ;
14103   Dali::TypeRegistration *arg1 = 0 ;
14104   std::string *arg2 = 0 ;
14105   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
14106   Dali::SignalConnectorType *result = 0 ;
14107
14108   arg1 = (Dali::TypeRegistration *)jarg1;
14109   if (!arg1) {
14110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14111     return 0;
14112   }
14113   if (!jarg2) {
14114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14115     return 0;
14116   }
14117   std::string arg2_str(jarg2);
14118   arg2 = &arg2_str;
14119   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
14120   {
14121     try {
14122       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
14123     } CALL_CATCH_EXCEPTION(0);
14124   }
14125
14126   jresult = (void *)result;
14127
14128   //argout typemap for const std::string&
14129
14130   return jresult;
14131 }
14132
14133
14134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
14135   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
14136
14137   arg1 = (Dali::SignalConnectorType *)jarg1;
14138   {
14139     try {
14140       delete arg1;
14141     } CALL_CATCH_EXCEPTION();
14142   }
14143
14144 }
14145
14146
14147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
14148   void * jresult ;
14149   Dali::TypeRegistration *arg1 = 0 ;
14150   std::string *arg2 = 0 ;
14151   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
14152   Dali::TypeAction *result = 0 ;
14153
14154   arg1 = (Dali::TypeRegistration *)jarg1;
14155   if (!arg1) {
14156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14157     return 0;
14158   }
14159   if (!jarg2) {
14160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14161     return 0;
14162   }
14163   std::string arg2_str(jarg2);
14164   arg2 = &arg2_str;
14165   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
14166   {
14167     try {
14168       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
14169     } CALL_CATCH_EXCEPTION(0);
14170   }
14171
14172   jresult = (void *)result;
14173
14174   //argout typemap for const std::string&
14175
14176   return jresult;
14177 }
14178
14179
14180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
14181   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
14182
14183   arg1 = (Dali::TypeAction *)jarg1;
14184   {
14185     try {
14186       delete arg1;
14187     } CALL_CATCH_EXCEPTION();
14188   }
14189
14190 }
14191
14192
14193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
14194   void * jresult ;
14195   Dali::TypeRegistration *arg1 = 0 ;
14196   std::string *arg2 = 0 ;
14197   Dali::Property::Index arg3 ;
14198   Dali::Property::Type arg4 ;
14199   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
14200   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
14201   Dali::PropertyRegistration *result = 0 ;
14202
14203   arg1 = (Dali::TypeRegistration *)jarg1;
14204   if (!arg1) {
14205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14206     return 0;
14207   }
14208   if (!jarg2) {
14209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14210     return 0;
14211   }
14212   std::string arg2_str(jarg2);
14213   arg2 = &arg2_str;
14214   arg3 = (Dali::Property::Index)jarg3;
14215   arg4 = (Dali::Property::Type)jarg4;
14216   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
14217   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
14218   {
14219     try {
14220       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
14221     } CALL_CATCH_EXCEPTION(0);
14222   }
14223
14224   jresult = (void *)result;
14225
14226   //argout typemap for const std::string&
14227
14228   return jresult;
14229 }
14230
14231
14232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
14233   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
14234
14235   arg1 = (Dali::PropertyRegistration *)jarg1;
14236   {
14237     try {
14238       delete arg1;
14239     } CALL_CATCH_EXCEPTION();
14240   }
14241
14242 }
14243
14244
14245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
14246   void * jresult ;
14247   Dali::TypeRegistration *arg1 = 0 ;
14248   std::string *arg2 = 0 ;
14249   Dali::Property::Index arg3 ;
14250   Dali::Property::Type arg4 ;
14251   Dali::AnimatablePropertyRegistration *result = 0 ;
14252
14253   arg1 = (Dali::TypeRegistration *)jarg1;
14254   if (!arg1) {
14255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14256     return 0;
14257   }
14258   if (!jarg2) {
14259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14260     return 0;
14261   }
14262   std::string arg2_str(jarg2);
14263   arg2 = &arg2_str;
14264   arg3 = (Dali::Property::Index)jarg3;
14265   arg4 = (Dali::Property::Type)jarg4;
14266   {
14267     try {
14268       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
14269     } CALL_CATCH_EXCEPTION(0);
14270   }
14271
14272   jresult = (void *)result;
14273
14274   //argout typemap for const std::string&
14275
14276   return jresult;
14277 }
14278
14279
14280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
14281   void * jresult ;
14282   Dali::TypeRegistration *arg1 = 0 ;
14283   std::string *arg2 = 0 ;
14284   Dali::Property::Index arg3 ;
14285   Dali::Property::Value *arg4 = 0 ;
14286   Dali::AnimatablePropertyRegistration *result = 0 ;
14287
14288   arg1 = (Dali::TypeRegistration *)jarg1;
14289   if (!arg1) {
14290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14291     return 0;
14292   }
14293   if (!jarg2) {
14294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14295     return 0;
14296   }
14297   std::string arg2_str(jarg2);
14298   arg2 = &arg2_str;
14299   arg3 = (Dali::Property::Index)jarg3;
14300   arg4 = (Dali::Property::Value *)jarg4;
14301   if (!arg4) {
14302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14303     return 0;
14304   }
14305   {
14306     try {
14307       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
14308     } CALL_CATCH_EXCEPTION(0);
14309   }
14310
14311   jresult = (void *)result;
14312
14313   //argout typemap for const std::string&
14314
14315   return jresult;
14316 }
14317
14318
14319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
14320   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
14321
14322   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
14323   {
14324     try {
14325       delete arg1;
14326     } CALL_CATCH_EXCEPTION();
14327   }
14328
14329 }
14330
14331
14332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
14333   void * jresult ;
14334   Dali::TypeRegistration *arg1 = 0 ;
14335   std::string *arg2 = 0 ;
14336   Dali::Property::Index arg3 ;
14337   Dali::Property::Index arg4 ;
14338   unsigned int arg5 ;
14339   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
14340
14341   arg1 = (Dali::TypeRegistration *)jarg1;
14342   if (!arg1) {
14343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14344     return 0;
14345   }
14346   if (!jarg2) {
14347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14348     return 0;
14349   }
14350   std::string arg2_str(jarg2);
14351   arg2 = &arg2_str;
14352   arg3 = (Dali::Property::Index)jarg3;
14353   arg4 = (Dali::Property::Index)jarg4;
14354   arg5 = (unsigned int)jarg5;
14355   {
14356     try {
14357       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
14358     } CALL_CATCH_EXCEPTION(0);
14359   }
14360
14361   jresult = (void *)result;
14362
14363   //argout typemap for const std::string&
14364
14365   return jresult;
14366 }
14367
14368
14369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
14370   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
14371
14372   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
14373   {
14374     try {
14375       delete arg1;
14376     } CALL_CATCH_EXCEPTION();
14377   }
14378
14379 }
14380
14381
14382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
14383   void * jresult ;
14384   Dali::TypeRegistration *arg1 = 0 ;
14385   std::string *arg2 = 0 ;
14386   Dali::Property::Index arg3 ;
14387   Dali::Property::Type arg4 ;
14388   Dali::ChildPropertyRegistration *result = 0 ;
14389
14390   arg1 = (Dali::TypeRegistration *)jarg1;
14391   if (!arg1) {
14392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14393     return 0;
14394   }
14395   if (!jarg2) {
14396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14397     return 0;
14398   }
14399   std::string arg2_str(jarg2);
14400   arg2 = &arg2_str;
14401   arg3 = (Dali::Property::Index)jarg3;
14402   arg4 = (Dali::Property::Type)jarg4;
14403   {
14404     try {
14405       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
14406     } CALL_CATCH_EXCEPTION(0);
14407   }
14408
14409   jresult = (void *)result;
14410
14411   //argout typemap for const std::string&
14412
14413   return jresult;
14414 }
14415
14416
14417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
14418   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
14419
14420   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
14421   {
14422     try {
14423       delete arg1;
14424     } CALL_CATCH_EXCEPTION();
14425   }
14426
14427 }
14428
14429
14430 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
14431   bool jresult ;
14432   std::string *arg1 = 0 ;
14433   std::type_info *arg2 = 0 ;
14434   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
14435   bool result;
14436
14437   if (!jarg1) {
14438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14439     return 0;
14440   }
14441   std::string arg1_str(jarg1);
14442   arg1 = &arg1_str;
14443   arg2 = (std::type_info *)jarg2;
14444   if (!arg2) {
14445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
14446     return 0;
14447   }
14448   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
14449   {
14450     try {
14451       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
14452     } CALL_CATCH_EXCEPTION(0);
14453   }
14454
14455   jresult = result;
14456
14457   //argout typemap for const std::string&
14458
14459   return jresult;
14460 }
14461
14462
14463 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
14464   bool jresult ;
14465   std::string *arg1 = 0 ;
14466   std::string *arg2 = 0 ;
14467   Dali::Property::Index arg3 ;
14468   Dali::Property::Type arg4 ;
14469   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
14470   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
14471   bool result;
14472
14473   if (!jarg1) {
14474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14475     return 0;
14476   }
14477   std::string arg1_str(jarg1);
14478   arg1 = &arg1_str;
14479   if (!jarg2) {
14480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14481     return 0;
14482   }
14483   std::string arg2_str(jarg2);
14484   arg2 = &arg2_str;
14485   arg3 = (Dali::Property::Index)jarg3;
14486   arg4 = (Dali::Property::Type)jarg4;
14487   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
14488   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
14489   {
14490     try {
14491       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
14492     } CALL_CATCH_EXCEPTION(0);
14493   }
14494
14495   jresult = result;
14496
14497   //argout typemap for const std::string&
14498
14499
14500   //argout typemap for const std::string&
14501
14502   return jresult;
14503 }
14504
14505
14506 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
14507   float jresult ;
14508   float result;
14509
14510   result = (float)(float)Dali::ParentOrigin::TOP;
14511   jresult = result;
14512   return jresult;
14513 }
14514
14515
14516 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
14517   float jresult ;
14518   float result;
14519
14520   result = (float)(float)Dali::ParentOrigin::BOTTOM;
14521   jresult = result;
14522   return jresult;
14523 }
14524
14525
14526 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
14527   float jresult ;
14528   float result;
14529
14530   result = (float)(float)Dali::ParentOrigin::LEFT;
14531   jresult = result;
14532   return jresult;
14533 }
14534
14535
14536 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
14537   float jresult ;
14538   float result;
14539
14540   result = (float)(float)Dali::ParentOrigin::RIGHT;
14541   jresult = result;
14542   return jresult;
14543 }
14544
14545
14546 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
14547   float jresult ;
14548   float result;
14549
14550   result = (float)(float)Dali::ParentOrigin::MIDDLE;
14551   jresult = result;
14552   return jresult;
14553 }
14554
14555
14556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
14557   void * jresult ;
14558   Dali::Vector3 *result = 0 ;
14559
14560   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
14561   jresult = (void *)result;
14562   return jresult;
14563 }
14564
14565
14566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
14567   void * jresult ;
14568   Dali::Vector3 *result = 0 ;
14569
14570   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
14571   jresult = (void *)result;
14572   return jresult;
14573 }
14574
14575
14576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
14577   void * jresult ;
14578   Dali::Vector3 *result = 0 ;
14579
14580   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
14581   jresult = (void *)result;
14582   return jresult;
14583 }
14584
14585
14586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
14587   void * jresult ;
14588   Dali::Vector3 *result = 0 ;
14589
14590   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
14591   jresult = (void *)result;
14592   return jresult;
14593 }
14594
14595
14596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
14597   void * jresult ;
14598   Dali::Vector3 *result = 0 ;
14599
14600   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
14601   jresult = (void *)result;
14602   return jresult;
14603 }
14604
14605
14606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
14607   void * jresult ;
14608   Dali::Vector3 *result = 0 ;
14609
14610   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
14611   jresult = (void *)result;
14612   return jresult;
14613 }
14614
14615
14616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
14617   void * jresult ;
14618   Dali::Vector3 *result = 0 ;
14619
14620   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
14621   jresult = (void *)result;
14622   return jresult;
14623 }
14624
14625
14626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
14627   void * jresult ;
14628   Dali::Vector3 *result = 0 ;
14629
14630   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
14631   jresult = (void *)result;
14632   return jresult;
14633 }
14634
14635
14636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
14637   void * jresult ;
14638   Dali::Vector3 *result = 0 ;
14639
14640   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
14641   jresult = (void *)result;
14642   return jresult;
14643 }
14644
14645
14646 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
14647   float jresult ;
14648   float result;
14649
14650   result = (float)(float)Dali::AnchorPoint::TOP;
14651   jresult = result;
14652   return jresult;
14653 }
14654
14655
14656 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
14657   float jresult ;
14658   float result;
14659
14660   result = (float)(float)Dali::AnchorPoint::BOTTOM;
14661   jresult = result;
14662   return jresult;
14663 }
14664
14665
14666 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
14667   float jresult ;
14668   float result;
14669
14670   result = (float)(float)Dali::AnchorPoint::LEFT;
14671   jresult = result;
14672   return jresult;
14673 }
14674
14675
14676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
14677   float jresult ;
14678   float result;
14679
14680   result = (float)(float)Dali::AnchorPoint::RIGHT;
14681   jresult = result;
14682   return jresult;
14683 }
14684
14685
14686 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
14687   float jresult ;
14688   float result;
14689
14690   result = (float)(float)Dali::AnchorPoint::MIDDLE;
14691   jresult = result;
14692   return jresult;
14693 }
14694
14695
14696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
14697   void * jresult ;
14698   Dali::Vector3 *result = 0 ;
14699
14700   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
14701   jresult = (void *)result;
14702   return jresult;
14703 }
14704
14705
14706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
14707   void * jresult ;
14708   Dali::Vector3 *result = 0 ;
14709
14710   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
14711   jresult = (void *)result;
14712   return jresult;
14713 }
14714
14715
14716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
14717   void * jresult ;
14718   Dali::Vector3 *result = 0 ;
14719
14720   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
14721   jresult = (void *)result;
14722   return jresult;
14723 }
14724
14725
14726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
14727   void * jresult ;
14728   Dali::Vector3 *result = 0 ;
14729
14730   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
14731   jresult = (void *)result;
14732   return jresult;
14733 }
14734
14735
14736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
14737   void * jresult ;
14738   Dali::Vector3 *result = 0 ;
14739
14740   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
14741   jresult = (void *)result;
14742   return jresult;
14743 }
14744
14745
14746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
14747   void * jresult ;
14748   Dali::Vector3 *result = 0 ;
14749
14750   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
14751   jresult = (void *)result;
14752   return jresult;
14753 }
14754
14755
14756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
14757   void * jresult ;
14758   Dali::Vector3 *result = 0 ;
14759
14760   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
14761   jresult = (void *)result;
14762   return jresult;
14763 }
14764
14765
14766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
14767   void * jresult ;
14768   Dali::Vector3 *result = 0 ;
14769
14770   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
14771   jresult = (void *)result;
14772   return jresult;
14773 }
14774
14775
14776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
14777   void * jresult ;
14778   Dali::Vector3 *result = 0 ;
14779
14780   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
14781   jresult = (void *)result;
14782   return jresult;
14783 }
14784
14785
14786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ALICE_BLUE_get() {
14787   void * jresult;
14788   Dali::Vector4 *result = 0 ;
14789
14790   result = (Dali::Vector4 *)&Dali::Color::ALICE_BLUE;
14791   jresult = (void *)result;
14792   return jresult;
14793 }
14794
14795
14796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANTIQUE_WHITE_get() {
14797   void * jresult;
14798   Dali::Vector4 *result = 0 ;
14799
14800   result = (Dali::Vector4 *)&Dali::Color::ANTIQUE_WHITE;
14801   jresult = (void *)result;
14802   return jresult;
14803 }
14804
14805
14806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AQUA_get() {
14807   void * jresult;
14808   Dali::Vector4 *result = 0 ;
14809
14810   result = (Dali::Vector4 *)&Dali::Color::AQUA;
14811   jresult = (void *)result;
14812   return jresult;
14813 }
14814
14815
14816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AQUA_MARINE_get() {
14817   void * jresult;
14818   Dali::Vector4 *result = 0 ;
14819
14820   result = (Dali::Vector4 *)&Dali::Color::AQUA_MARINE;
14821   jresult = (void *)result;
14822   return jresult;
14823 }
14824
14825
14826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AZURE_get() {
14827   void * jresult;
14828   Dali::Vector4 *result = 0 ;
14829
14830   result = (Dali::Vector4 *)&Dali::Color::AZURE;
14831   jresult = (void *)result;
14832   return jresult;
14833 }
14834
14835
14836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BEIGE_get() {
14837   void * jresult;
14838   Dali::Vector4 *result = 0 ;
14839
14840   result = (Dali::Vector4 *)&Dali::Color::BEIGE;
14841   jresult = (void *)result;
14842   return jresult;
14843 }
14844
14845
14846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BISQUE_get() {
14847   void * jresult;
14848   Dali::Vector4 *result = 0 ;
14849
14850   result = (Dali::Vector4 *)&Dali::Color::BISQUE;
14851   jresult = (void *)result;
14852   return jresult;
14853 }
14854
14855
14856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
14857   void * jresult;
14858   Dali::Vector4 *result = 0 ;
14859
14860   result = (Dali::Vector4 *)&Dali::Color::BLACK;
14861   jresult = (void *)result;
14862   return jresult;
14863 }
14864
14865
14866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLANCHE_DALMOND_get() {
14867   void * jresult;
14868   Dali::Vector4 *result = 0 ;
14869
14870   result = (Dali::Vector4 *)&Dali::Color::BLANCHE_DALMOND;
14871   jresult = (void *)result;
14872   return jresult;
14873 }
14874
14875
14876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
14877   void * jresult;
14878   Dali::Vector4 *result = 0 ;
14879
14880   result = (Dali::Vector4 *)&Dali::Color::BLUE;
14881   jresult = (void *)result;
14882   return jresult;
14883 }
14884
14885
14886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_VIOLET_get() {
14887   void * jresult;
14888   Dali::Vector4 *result = 0 ;
14889
14890   result = (Dali::Vector4 *)&Dali::Color::BLUE_VIOLET;
14891   jresult = (void *)result;
14892   return jresult;
14893 }
14894
14895
14896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BROWN_get() {
14897   void * jresult;
14898   Dali::Vector4 *result = 0 ;
14899
14900   result = (Dali::Vector4 *)&Dali::Color::BROWN;
14901   jresult = (void *)result;
14902   return jresult;
14903 }
14904
14905
14906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BURLY_WOOD_get() {
14907   void * jresult;
14908   Dali::Vector4 *result = 0 ;
14909
14910   result = (Dali::Vector4 *)&Dali::Color::BURLY_WOOD;
14911   jresult = (void *)result;
14912   return jresult;
14913 }
14914
14915
14916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CADET_BLUE_get() {
14917   void * jresult;
14918   Dali::Vector4 *result = 0 ;
14919
14920   result = (Dali::Vector4 *)&Dali::Color::CADET_BLUE;
14921   jresult = (void *)result;
14922   return jresult;
14923 }
14924
14925
14926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CHARTREUSE_get() {
14927   void * jresult;
14928   Dali::Vector4 *result = 0 ;
14929
14930   result = (Dali::Vector4 *)&Dali::Color::CHARTREUSE;
14931   jresult = (void *)result;
14932   return jresult;
14933 }
14934
14935
14936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CHOCOLATE_get() {
14937   void * jresult;
14938   Dali::Vector4 *result = 0 ;
14939
14940   result = (Dali::Vector4 *)&Dali::Color::CHOCOLATE;
14941   jresult = (void *)result;
14942   return jresult;
14943 }
14944
14945
14946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CORAL_get() {
14947   void * jresult;
14948   Dali::Vector4 *result = 0 ;
14949
14950   result = (Dali::Vector4 *)&Dali::Color::CORAL;
14951   jresult = (void *)result;
14952   return jresult;
14953 }
14954
14955
14956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CORNFLOWER_BLUE_get() {
14957   void * jresult;
14958   Dali::Vector4 *result = 0 ;
14959
14960   result = (Dali::Vector4 *)&Dali::Color::CORNFLOWER_BLUE;
14961   jresult = (void *)result;
14962   return jresult;
14963 }
14964
14965
14966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CORNSILK_get() {
14967   void * jresult;
14968   Dali::Vector4 *result = 0 ;
14969
14970   result = (Dali::Vector4 *)&Dali::Color::CORNSILK;
14971   jresult = (void *)result;
14972   return jresult;
14973 }
14974
14975
14976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CRIMSON_get() {
14977   void * jresult;
14978   Dali::Vector4 *result = 0 ;
14979
14980   result = (Dali::Vector4 *)&Dali::Color::CRIMSON;
14981   jresult = (void *)result;
14982   return jresult;
14983 }
14984
14985
14986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
14987   void * jresult;
14988   Dali::Vector4 *result = 0 ;
14989
14990   result = (Dali::Vector4 *)&Dali::Color::CYAN;
14991   jresult = (void *)result;
14992   return jresult;
14993 }
14994
14995
14996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_BLUE_get() {
14997   void * jresult;
14998   Dali::Vector4 *result = 0 ;
14999
15000   result = (Dali::Vector4 *)&Dali::Color::DARK_BLUE;
15001   jresult = (void *)result;
15002   return jresult;
15003 }
15004
15005
15006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_CYAN_get() {
15007   void * jresult;
15008   Dali::Vector4 *result = 0 ;
15009
15010   result = (Dali::Vector4 *)&Dali::Color::DARK_CYAN;
15011   jresult = (void *)result;
15012   return jresult;
15013 }
15014
15015
15016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_GOLDENROD_get() {
15017   void * jresult;
15018   Dali::Vector4 *result = 0 ;
15019
15020   result = (Dali::Vector4 *)&Dali::Color::DARK_GOLDENROD;
15021   jresult = (void *)result;
15022   return jresult;
15023 }
15024
15025
15026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_GRAY_get() {
15027   void * jresult;
15028   Dali::Vector4 *result = 0 ;
15029
15030   result = (Dali::Vector4 *)&Dali::Color::DARK_GRAY;
15031   jresult = (void *)result;
15032   return jresult;
15033 }
15034
15035
15036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_GREEN_get() {
15037   void * jresult;
15038   Dali::Vector4 *result = 0 ;
15039
15040   result = (Dali::Vector4 *)&Dali::Color::DARK_GREEN;
15041   jresult = (void *)result;
15042   return jresult;
15043 }
15044
15045
15046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_GREY_get() {
15047   void * jresult;
15048   Dali::Vector4 *result = 0 ;
15049
15050   result = (Dali::Vector4 *)&Dali::Color::DARK_GREY;
15051   jresult = (void *)result;
15052   return jresult;
15053 }
15054
15055
15056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_KHAKI_get() {
15057   void * jresult;
15058   Dali::Vector4 *result = 0 ;
15059
15060   result = (Dali::Vector4 *)&Dali::Color::DARK_KHAKI;
15061   jresult = (void *)result;
15062   return jresult;
15063 }
15064
15065
15066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_MAGENTA_get() {
15067   void * jresult;
15068   Dali::Vector4 *result = 0 ;
15069
15070   result = (Dali::Vector4 *)&Dali::Color::DARK_MAGENTA;
15071   jresult = (void *)result;
15072   return jresult;
15073 }
15074
15075
15076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_OLIVE_GREEN_get() {
15077   void * jresult;
15078   Dali::Vector4 *result = 0 ;
15079
15080   result = (Dali::Vector4 *)&Dali::Color::DARK_OLIVE_GREEN;
15081   jresult = (void *)result;
15082   return jresult;
15083 }
15084
15085
15086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_ORANGE_get() {
15087   void * jresult;
15088   Dali::Vector4 *result = 0 ;
15089
15090   result = (Dali::Vector4 *)&Dali::Color::DARK_ORANGE;
15091   jresult = (void *)result;
15092   return jresult;
15093 }
15094
15095
15096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_ORCHID_get() {
15097   void * jresult;
15098   Dali::Vector4 *result = 0 ;
15099
15100   result = (Dali::Vector4 *)&Dali::Color::DARK_ORCHID;
15101   jresult = (void *)result;
15102   return jresult;
15103 }
15104
15105
15106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_RED_get() {
15107   void * jresult;
15108   Dali::Vector4 *result = 0 ;
15109
15110   result = (Dali::Vector4 *)&Dali::Color::DARK_RED;
15111   jresult = (void *)result;
15112   return jresult;
15113 }
15114
15115
15116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SALMON_get() {
15117   void * jresult;
15118   Dali::Vector4 *result = 0 ;
15119
15120   result = (Dali::Vector4 *)&Dali::Color::DARK_SALMON;
15121   jresult = (void *)result;
15122   return jresult;
15123 }
15124
15125
15126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SEA_GREEN_get() {
15127   void * jresult;
15128   Dali::Vector4 *result = 0 ;
15129
15130   result = (Dali::Vector4 *)&Dali::Color::DARK_SEA_GREEN;
15131   jresult = (void *)result;
15132   return jresult;
15133 }
15134
15135
15136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SLATE_BLUE_get() {
15137   void * jresult;
15138   Dali::Vector4 *result = 0 ;
15139
15140   result = (Dali::Vector4 *)&Dali::Color::DARK_SLATE_BLUE;
15141   jresult = (void *)result;
15142   return jresult;
15143 }
15144
15145
15146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SLATE_GRAY_get() {
15147   void * jresult;
15148   Dali::Vector4 *result = 0 ;
15149
15150   result = (Dali::Vector4 *)&Dali::Color::DARK_SLATE_GRAY;
15151   jresult = (void *)result;
15152   return jresult;
15153 }
15154
15155
15156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SLATE_GREY_get() {
15157   void * jresult;
15158   Dali::Vector4 *result = 0 ;
15159
15160   result = (Dali::Vector4 *)&Dali::Color::DARK_SLATE_GREY;
15161   jresult = (void *)result;
15162   return jresult;
15163 }
15164
15165
15166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_TURQUOISE_get() {
15167   void * jresult;
15168   Dali::Vector4 *result = 0 ;
15169
15170   result = (Dali::Vector4 *)&Dali::Color::DARK_TURQUOISE;
15171   jresult = (void *)result;
15172   return jresult;
15173 }
15174
15175
15176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_VIOLET_get() {
15177   void * jresult;
15178   Dali::Vector4 *result = 0 ;
15179
15180   result = (Dali::Vector4 *)&Dali::Color::DARK_VIOLET;
15181   jresult = (void *)result;
15182   return jresult;
15183 }
15184
15185
15186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DEEP_PINK_get() {
15187   void * jresult;
15188   Dali::Vector4 *result = 0 ;
15189
15190   result = (Dali::Vector4 *)&Dali::Color::DEEP_PINK;
15191   jresult = (void *)result;
15192   return jresult;
15193 }
15194
15195
15196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DEEP_SKY_BLUE_get() {
15197   void * jresult;
15198   Dali::Vector4 *result = 0 ;
15199
15200   result = (Dali::Vector4 *)&Dali::Color::DEEP_SKY_BLUE;
15201   jresult = (void *)result;
15202   return jresult;
15203 }
15204
15205
15206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DIM_GRAY_get() {
15207   void * jresult;
15208   Dali::Vector4 *result = 0 ;
15209
15210   result = (Dali::Vector4 *)&Dali::Color::DIM_GRAY;
15211   jresult = (void *)result;
15212   return jresult;
15213 }
15214
15215
15216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DIM_GREY_get() {
15217   void * jresult;
15218   Dali::Vector4 *result = 0 ;
15219
15220   result = (Dali::Vector4 *)&Dali::Color::DIM_GREY;
15221   jresult = (void *)result;
15222   return jresult;
15223 }
15224
15225
15226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DODGER_BLUE_get() {
15227   void * jresult;
15228   Dali::Vector4 *result = 0 ;
15229
15230   result = (Dali::Vector4 *)&Dali::Color::DODGER_BLUE;
15231   jresult = (void *)result;
15232   return jresult;
15233 }
15234
15235
15236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FIRE_BRICK_get() {
15237   void * jresult;
15238   Dali::Vector4 *result = 0 ;
15239
15240   result = (Dali::Vector4 *)&Dali::Color::FIRE_BRICK;
15241   jresult = (void *)result;
15242   return jresult;
15243 }
15244
15245
15246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FLORAL_WHITE_get() {
15247   void * jresult;
15248   Dali::Vector4 *result = 0 ;
15249
15250   result = (Dali::Vector4 *)&Dali::Color::FLORAL_WHITE;
15251   jresult = (void *)result;
15252   return jresult;
15253 }
15254
15255
15256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FOREST_GREEN_get() {
15257   void * jresult;
15258   Dali::Vector4 *result = 0 ;
15259
15260   result = (Dali::Vector4 *)&Dali::Color::FOREST_GREEN;
15261   jresult = (void *)result;
15262   return jresult;
15263 }
15264
15265
15266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FUCHSIA_get() {
15267   void * jresult;
15268   Dali::Vector4 *result = 0 ;
15269
15270   result = (Dali::Vector4 *)&Dali::Color::FUCHSIA;
15271   jresult = (void *)result;
15272   return jresult;
15273 }
15274
15275
15276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GAINSBORO_get() {
15277   void * jresult;
15278   Dali::Vector4 *result = 0 ;
15279
15280   result = (Dali::Vector4 *)&Dali::Color::GAINSBORO;
15281   jresult = (void *)result;
15282   return jresult;
15283 }
15284
15285
15286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GHOST_WHITE_get() {
15287   void * jresult;
15288   Dali::Vector4 *result = 0 ;
15289
15290   result = (Dali::Vector4 *)&Dali::Color::GHOST_WHITE;
15291   jresult = (void *)result;
15292   return jresult;
15293 }
15294
15295
15296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GOLD_get() {
15297   void * jresult;
15298   Dali::Vector4 *result = 0 ;
15299
15300   result = (Dali::Vector4 *)&Dali::Color::GOLD;
15301   jresult = (void *)result;
15302   return jresult;
15303 }
15304
15305
15306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GOLDEN_ROD_get() {
15307   void * jresult;
15308   Dali::Vector4 *result = 0 ;
15309
15310   result = (Dali::Vector4 *)&Dali::Color::GOLDEN_ROD;
15311   jresult = (void *)result;
15312   return jresult;
15313 }
15314
15315
15316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GRAY_get() {
15317   void * jresult;
15318   Dali::Vector4 *result = 0 ;
15319
15320   result = (Dali::Vector4 *)&Dali::Color::GRAY;
15321   jresult = (void *)result;
15322   return jresult;
15323 }
15324
15325
15326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
15327   void * jresult;
15328   Dali::Vector4 *result = 0 ;
15329
15330   result = (Dali::Vector4 *)&Dali::Color::GREEN;
15331   jresult = (void *)result;
15332   return jresult;
15333 }
15334
15335
15336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_YELLOW_get() {
15337   void * jresult;
15338   Dali::Vector4 *result = 0 ;
15339
15340   result = (Dali::Vector4 *)&Dali::Color::GREEN_YELLOW;
15341   jresult = (void *)result;
15342   return jresult;
15343 }
15344
15345
15346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREY_get() {
15347   void * jresult;
15348   Dali::Vector4 *result = 0 ;
15349
15350   result = (Dali::Vector4 *)&Dali::Color::GREY;
15351   jresult = (void *)result;
15352   return jresult;
15353 }
15354
15355
15356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_HONEYDEW_get() {
15357   void * jresult;
15358   Dali::Vector4 *result = 0 ;
15359
15360   result = (Dali::Vector4 *)&Dali::Color::HONEYDEW;
15361   jresult = (void *)result;
15362   return jresult;
15363 }
15364
15365
15366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_HOT_PINK_get() {
15367   void * jresult;
15368   Dali::Vector4 *result = 0 ;
15369
15370   result = (Dali::Vector4 *)&Dali::Color::HOT_PINK;
15371   jresult = (void *)result;
15372   return jresult;
15373 }
15374
15375
15376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_INDIANRED_get() {
15377   void * jresult;
15378   Dali::Vector4 *result = 0 ;
15379
15380   result = (Dali::Vector4 *)&Dali::Color::INDIANRED;
15381   jresult = (void *)result;
15382   return jresult;
15383 }
15384
15385
15386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_INDIGO_get() {
15387   void * jresult;
15388   Dali::Vector4 *result = 0 ;
15389
15390   result = (Dali::Vector4 *)&Dali::Color::INDIGO;
15391   jresult = (void *)result;
15392   return jresult;
15393 }
15394
15395
15396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_IVORY_get() {
15397   void * jresult;
15398   Dali::Vector4 *result = 0 ;
15399
15400   result = (Dali::Vector4 *)&Dali::Color::IVORY;
15401   jresult = (void *)result;
15402   return jresult;
15403 }
15404
15405
15406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KHAKI_get() {
15407   void * jresult;
15408   Dali::Vector4 *result = 0 ;
15409
15410   result = (Dali::Vector4 *)&Dali::Color::KHAKI;
15411   jresult = (void *)result;
15412   return jresult;
15413 }
15414
15415
15416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LAVENDER_get() {
15417   void * jresult;
15418   Dali::Vector4 *result = 0 ;
15419
15420   result = (Dali::Vector4 *)&Dali::Color::LAVENDER;
15421   jresult = (void *)result;
15422   return jresult;
15423 }
15424
15425
15426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LAVENDER_BLUSH_get() {
15427   void * jresult;
15428   Dali::Vector4 *result = 0 ;
15429
15430   result = (Dali::Vector4 *)&Dali::Color::LAVENDER_BLUSH;
15431   jresult = (void *)result;
15432   return jresult;
15433 }
15434
15435
15436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LAWN_GREEN_get() {
15437   void * jresult;
15438   Dali::Vector4 *result = 0 ;
15439
15440   result = (Dali::Vector4 *)&Dali::Color::LAWN_GREEN;
15441   jresult = (void *)result;
15442   return jresult;
15443 }
15444
15445
15446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LEMON_CHIFFON_get() {
15447   void * jresult;
15448   Dali::Vector4 *result = 0 ;
15449
15450   result = (Dali::Vector4 *)&Dali::Color::LEMON_CHIFFON;
15451   jresult = (void *)result;
15452   return jresult;
15453 }
15454
15455
15456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_BLUE_get() {
15457   void * jresult;
15458   Dali::Vector4 *result = 0 ;
15459
15460   result = (Dali::Vector4 *)&Dali::Color::LIGHT_BLUE;
15461   jresult = (void *)result;
15462   return jresult;
15463 }
15464
15465
15466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_CORAL_get() {
15467   void * jresult;
15468   Dali::Vector4 *result = 0 ;
15469
15470   result = (Dali::Vector4 *)&Dali::Color::LIGHT_CORAL;
15471   jresult = (void *)result;
15472   return jresult;
15473 }
15474
15475
15476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_CYAN_get() {
15477   void * jresult;
15478   Dali::Vector4 *result = 0 ;
15479
15480   result = (Dali::Vector4 *)&Dali::Color::LIGHT_CYAN;
15481   jresult = (void *)result;
15482   return jresult;
15483 }
15484
15485
15486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_GOLDEN_ROD_YELLOW_get() {
15487   void * jresult;
15488   Dali::Vector4 *result = 0 ;
15489
15490   result = (Dali::Vector4 *)&Dali::Color::LIGHT_GOLDEN_ROD_YELLOW;
15491   jresult = (void *)result;
15492   return jresult;
15493 }
15494
15495
15496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_GRAY_get() {
15497   void * jresult;
15498   Dali::Vector4 *result = 0 ;
15499
15500   result = (Dali::Vector4 *)&Dali::Color::LIGHT_GRAY;
15501   jresult = (void *)result;
15502   return jresult;
15503 }
15504
15505
15506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_GREEN_get() {
15507   void * jresult;
15508   Dali::Vector4 *result = 0 ;
15509
15510   result = (Dali::Vector4 *)&Dali::Color::LIGHT_GREEN;
15511   jresult = (void *)result;
15512   return jresult;
15513 }
15514
15515
15516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_GREY_get() {
15517   void * jresult;
15518   Dali::Vector4 *result = 0 ;
15519
15520   result = (Dali::Vector4 *)&Dali::Color::LIGHT_GREY;
15521   jresult = (void *)result;
15522   return jresult;
15523 }
15524
15525
15526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_PINK_get() {
15527   void * jresult;
15528   Dali::Vector4 *result = 0 ;
15529
15530   result = (Dali::Vector4 *)&Dali::Color::LIGHT_PINK;
15531   jresult = (void *)result;
15532   return jresult;
15533 }
15534
15535
15536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SALMON_get() {
15537   void * jresult;
15538   Dali::Vector4 *result = 0 ;
15539
15540   result = (Dali::Vector4 *)&Dali::Color::LIGHT_SALMON;
15541   jresult = (void *)result;
15542   return jresult;
15543 }
15544
15545
15546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SEA_GREEN_get() {
15547   void * jresult;
15548   Dali::Vector4 *result = 0 ;
15549
15550   result = (Dali::Vector4 *)&Dali::Color::LIGHT_SEA_GREEN;
15551   jresult = (void *)result;
15552   return jresult;
15553 }
15554
15555
15556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SKY_BLUE_get() {
15557   void * jresult;
15558   Dali::Vector4 *result = 0 ;
15559
15560   result = (Dali::Vector4 *)&Dali::Color::LIGHT_SKY_BLUE;
15561   jresult = (void *)result;
15562   return jresult;
15563 }
15564
15565
15566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SLATE_GRAY_get() {
15567   void * jresult;
15568   Dali::Vector4 *result = 0 ;
15569
15570   result = (Dali::Vector4 *)&Dali::Color::LIGHT_SLATE_GRAY;
15571   jresult = (void *)result;
15572   return jresult;
15573 }
15574
15575
15576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SLATE_GREY_get() {
15577   void * jresult;
15578   Dali::Vector4 *result = 0 ;
15579
15580   result = (Dali::Vector4 *)&Dali::Color::LIGHT_SLATE_GREY;
15581   jresult = (void *)result;
15582   return jresult;
15583 }
15584
15585
15586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_STEEL_BLUE_get() {
15587   void * jresult;
15588   Dali::Vector4 *result = 0 ;
15589
15590   result = (Dali::Vector4 *)&Dali::Color::LIGHT_STEEL_BLUE;
15591   jresult = (void *)result;
15592   return jresult;
15593 }
15594
15595
15596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_YELLOW_get() {
15597   void * jresult;
15598   Dali::Vector4 *result = 0 ;
15599
15600   result = (Dali::Vector4 *)&Dali::Color::LIGHT_YELLOW;
15601   jresult = (void *)result;
15602   return jresult;
15603 }
15604
15605
15606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIME_get() {
15607   void * jresult;
15608   Dali::Vector4 *result = 0 ;
15609
15610   result = (Dali::Vector4 *)&Dali::Color::LIME;
15611   jresult = (void *)result;
15612   return jresult;
15613 }
15614
15615
15616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIME_GREEN_get() {
15617   void * jresult;
15618   Dali::Vector4 *result = 0 ;
15619
15620   result = (Dali::Vector4 *)&Dali::Color::LIME_GREEN;
15621   jresult = (void *)result;
15622   return jresult;
15623 }
15624
15625
15626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LINEN_get() {
15627   void * jresult;
15628   Dali::Vector4 *result = 0 ;
15629
15630   result = (Dali::Vector4 *)&Dali::Color::LINEN;
15631   jresult = (void *)result;
15632   return jresult;
15633 }
15634
15635
15636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
15637   void * jresult;
15638   Dali::Vector4 *result = 0 ;
15639
15640   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
15641   jresult = (void *)result;
15642   return jresult;
15643 }
15644
15645
15646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAROON_get() {
15647   void * jresult;
15648   Dali::Vector4 *result = 0 ;
15649
15650   result = (Dali::Vector4 *)&Dali::Color::MAROON;
15651   jresult = (void *)result;
15652   return jresult;
15653 }
15654
15655
15656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_AQUA_MARINE_get() {
15657   void * jresult;
15658   Dali::Vector4 *result = 0 ;
15659
15660   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_AQUA_MARINE;
15661   jresult = (void *)result;
15662   return jresult;
15663 }
15664
15665
15666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_BLUE_get() {
15667   void * jresult;
15668   Dali::Vector4 *result = 0 ;
15669
15670   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_BLUE;
15671   jresult = (void *)result;
15672   return jresult;
15673 }
15674
15675
15676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_ORCHID_get() {
15677   void * jresult;
15678   Dali::Vector4 *result = 0 ;
15679
15680   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_ORCHID;
15681   jresult = (void *)result;
15682   return jresult;
15683 }
15684
15685
15686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_PURPLE_get() {
15687   void * jresult;
15688   Dali::Vector4 *result = 0 ;
15689
15690   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_PURPLE;
15691   jresult = (void *)result;
15692   return jresult;
15693 }
15694
15695
15696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_SEA_GREEN_get() {
15697   void * jresult;
15698   Dali::Vector4 *result = 0 ;
15699
15700   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_SEA_GREEN;
15701   jresult = (void *)result;
15702   return jresult;
15703 }
15704
15705
15706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_SLATE_BLUE_get() {
15707   void * jresult;
15708   Dali::Vector4 *result = 0 ;
15709
15710   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_SLATE_BLUE;
15711   jresult = (void *)result;
15712   return jresult;
15713 }
15714
15715
15716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_SPRING_GREEN_get() {
15717   void * jresult;
15718   Dali::Vector4 *result = 0 ;
15719
15720   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_SPRING_GREEN;
15721   jresult = (void *)result;
15722   return jresult;
15723 }
15724
15725
15726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_TURQUOISE_get() {
15727   void * jresult;
15728   Dali::Vector4 *result = 0 ;
15729
15730   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_TURQUOISE;
15731   jresult = (void *)result;
15732   return jresult;
15733 }
15734
15735
15736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_VIOLETRED_get() {
15737   void * jresult;
15738   Dali::Vector4 *result = 0 ;
15739
15740   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_VIOLETRED;
15741   jresult = (void *)result;
15742   return jresult;
15743 }
15744
15745
15746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MIDNIGHT_BLUE_get() {
15747   void * jresult;
15748   Dali::Vector4 *result = 0 ;
15749
15750   result = (Dali::Vector4 *)&Dali::Color::MIDNIGHT_BLUE;
15751   jresult = (void *)result;
15752   return jresult;
15753 }
15754
15755
15756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MINT_CREAM_get() {
15757   void * jresult;
15758   Dali::Vector4 *result = 0 ;
15759
15760   result = (Dali::Vector4 *)&Dali::Color::MINT_CREAM;
15761   jresult = (void *)result;
15762   return jresult;
15763 }
15764
15765
15766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MISTY_ROSE_get() {
15767   void * jresult;
15768   Dali::Vector4 *result = 0 ;
15769
15770   result = (Dali::Vector4 *)&Dali::Color::MISTY_ROSE;
15771   jresult = (void *)result;
15772   return jresult;
15773 }
15774
15775
15776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MOCCASIN_get() {
15777   void * jresult;
15778   Dali::Vector4 *result = 0 ;
15779
15780   result = (Dali::Vector4 *)&Dali::Color::MOCCASIN;
15781   jresult = (void *)result;
15782   return jresult;
15783 }
15784
15785
15786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NAVAJO_WHITE_get() {
15787   void * jresult;
15788   Dali::Vector4 *result = 0 ;
15789
15790   result = (Dali::Vector4 *)&Dali::Color::NAVAJO_WHITE;
15791   jresult = (void *)result;
15792   return jresult;
15793 }
15794
15795
15796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NAVY_get() {
15797   void * jresult;
15798   Dali::Vector4 *result = 0 ;
15799
15800   result = (Dali::Vector4 *)&Dali::Color::NAVY;
15801   jresult = (void *)result;
15802   return jresult;
15803 }
15804
15805
15806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OLD_LACE_get() {
15807   void * jresult;
15808   Dali::Vector4 *result = 0 ;
15809
15810   result = (Dali::Vector4 *)&Dali::Color::OLD_LACE;
15811   jresult = (void *)result;
15812   return jresult;
15813 }
15814
15815
15816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OLIVE_get() {
15817   void * jresult;
15818   Dali::Vector4 *result = 0 ;
15819
15820   result = (Dali::Vector4 *)&Dali::Color::OLIVE;
15821   jresult = (void *)result;
15822   return jresult;
15823 }
15824
15825
15826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OLIVE_DRAB_get() {
15827   void * jresult;
15828   Dali::Vector4 *result = 0 ;
15829
15830   result = (Dali::Vector4 *)&Dali::Color::OLIVE_DRAB;
15831   jresult = (void *)result;
15832   return jresult;
15833 }
15834
15835
15836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ORANGE_get() {
15837   void * jresult;
15838   Dali::Vector4 *result = 0 ;
15839
15840   result = (Dali::Vector4 *)&Dali::Color::ORANGE;
15841   jresult = (void *)result;
15842   return jresult;
15843 }
15844
15845
15846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ORANGE_RED_get() {
15847   void * jresult;
15848   Dali::Vector4 *result = 0 ;
15849
15850   result = (Dali::Vector4 *)&Dali::Color::ORANGE_RED;
15851   jresult = (void *)result;
15852   return jresult;
15853 }
15854
15855
15856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ORCHID_get() {
15857   void * jresult;
15858   Dali::Vector4 *result = 0 ;
15859
15860   result = (Dali::Vector4 *)&Dali::Color::ORCHID;
15861   jresult = (void *)result;
15862   return jresult;
15863 }
15864
15865
15866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PALE_GOLDEN_ROD_get() {
15867   void * jresult;
15868   Dali::Vector4 *result = 0 ;
15869
15870   result = (Dali::Vector4 *)&Dali::Color::PALE_GOLDEN_ROD;
15871   jresult = (void *)result;
15872   return jresult;
15873 }
15874
15875
15876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PALE_GREEN_get() {
15877   void * jresult;
15878   Dali::Vector4 *result = 0 ;
15879
15880   result = (Dali::Vector4 *)&Dali::Color::PALE_GREEN;
15881   jresult = (void *)result;
15882   return jresult;
15883 }
15884
15885
15886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PALE_TURQUOISE_get() {
15887   void * jresult;
15888   Dali::Vector4 *result = 0 ;
15889
15890   result = (Dali::Vector4 *)&Dali::Color::PALE_TURQUOISE;
15891   jresult = (void *)result;
15892   return jresult;
15893 }
15894
15895
15896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PALE_VIOLET_RED_get() {
15897   void * jresult;
15898   Dali::Vector4 *result = 0 ;
15899
15900   result = (Dali::Vector4 *)&Dali::Color::PALE_VIOLET_RED;
15901   jresult = (void *)result;
15902   return jresult;
15903 }
15904
15905
15906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PAPAYA_WHIP_get() {
15907   void * jresult;
15908   Dali::Vector4 *result = 0 ;
15909
15910   result = (Dali::Vector4 *)&Dali::Color::PAPAYA_WHIP;
15911   jresult = (void *)result;
15912   return jresult;
15913 }
15914
15915
15916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PEACH_PUFF_get() {
15917   void * jresult;
15918   Dali::Vector4 *result = 0 ;
15919
15920   result = (Dali::Vector4 *)&Dali::Color::PEACH_PUFF;
15921   jresult = (void *)result;
15922   return jresult;
15923 }
15924
15925
15926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PERU_get() {
15927   void * jresult;
15928   Dali::Vector4 *result = 0 ;
15929
15930   result = (Dali::Vector4 *)&Dali::Color::PERU;
15931   jresult = (void *)result;
15932   return jresult;
15933 }
15934
15935
15936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PINK_get() {
15937   void * jresult;
15938   Dali::Vector4 *result = 0 ;
15939
15940   result = (Dali::Vector4 *)&Dali::Color::PINK;
15941   jresult = (void *)result;
15942   return jresult;
15943 }
15944
15945
15946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PLUM_get() {
15947   void * jresult;
15948   Dali::Vector4 *result = 0 ;
15949
15950   result = (Dali::Vector4 *)&Dali::Color::PLUM;
15951   jresult = (void *)result;
15952   return jresult;
15953 }
15954
15955
15956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_POWDER_BLUE_get() {
15957   void * jresult;
15958   Dali::Vector4 *result = 0 ;
15959
15960   result = (Dali::Vector4 *)&Dali::Color::POWDER_BLUE;
15961   jresult = (void *)result;
15962   return jresult;
15963 }
15964
15965
15966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PURPLE_get() {
15967   void * jresult;
15968   Dali::Vector4 *result = 0 ;
15969
15970   result = (Dali::Vector4 *)&Dali::Color::PURPLE;
15971   jresult = (void *)result;
15972   return jresult;
15973 }
15974
15975
15976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
15977   void * jresult;
15978   Dali::Vector4 *result = 0 ;
15979
15980   result = (Dali::Vector4 *)&Dali::Color::RED;
15981   jresult = (void *)result;
15982   return jresult;
15983 }
15984
15985
15986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ROSY_BROWN_get() {
15987   void * jresult;
15988   Dali::Vector4 *result = 0 ;
15989
15990   result = (Dali::Vector4 *)&Dali::Color::ROSY_BROWN;
15991   jresult = (void *)result;
15992   return jresult;
15993 }
15994
15995
15996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ROYAL_BLUE_get() {
15997   void * jresult;
15998   Dali::Vector4 *result = 0 ;
15999
16000   result = (Dali::Vector4 *)&Dali::Color::ROYAL_BLUE;
16001   jresult = (void *)result;
16002   return jresult;
16003 }
16004
16005
16006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SADDLE_BROWN_get() {
16007   void * jresult;
16008   Dali::Vector4 *result = 0 ;
16009
16010   result = (Dali::Vector4 *)&Dali::Color::SADDLE_BROWN;
16011   jresult = (void *)result;
16012   return jresult;
16013 }
16014
16015
16016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SALMON_get() {
16017   void * jresult;
16018   Dali::Vector4 *result = 0 ;
16019
16020   result = (Dali::Vector4 *)&Dali::Color::SALMON;
16021   jresult = (void *)result;
16022   return jresult;
16023 }
16024
16025
16026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SANDY_BROWN_get() {
16027   void * jresult;
16028   Dali::Vector4 *result = 0 ;
16029
16030   result = (Dali::Vector4 *)&Dali::Color::SANDY_BROWN;
16031   jresult = (void *)result;
16032   return jresult;
16033 }
16034
16035
16036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SEA_GREEN_get() {
16037   void * jresult;
16038   Dali::Vector4 *result = 0 ;
16039
16040   result = (Dali::Vector4 *)&Dali::Color::SEA_GREEN;
16041   jresult = (void *)result;
16042   return jresult;
16043 }
16044
16045
16046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SEA_SHELL_get() {
16047   void * jresult;
16048   Dali::Vector4 *result = 0 ;
16049
16050   result = (Dali::Vector4 *)&Dali::Color::SEA_SHELL;
16051   jresult = (void *)result;
16052   return jresult;
16053 }
16054
16055
16056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SIENNA_get() {
16057   void * jresult;
16058   Dali::Vector4 *result = 0 ;
16059
16060   result = (Dali::Vector4 *)&Dali::Color::SIENNA;
16061   jresult = (void *)result;
16062   return jresult;
16063 }
16064
16065
16066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SILVER_get() {
16067   void * jresult;
16068   Dali::Vector4 *result = 0 ;
16069
16070   result = (Dali::Vector4 *)&Dali::Color::SILVER;
16071   jresult = (void *)result;
16072   return jresult;
16073 }
16074
16075
16076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SKY_BLUE_get() {
16077   void * jresult;
16078   Dali::Vector4 *result = 0 ;
16079
16080   result = (Dali::Vector4 *)&Dali::Color::SKY_BLUE;
16081   jresult = (void *)result;
16082   return jresult;
16083 }
16084
16085
16086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SLATE_BLUE_get() {
16087   void * jresult;
16088   Dali::Vector4 *result = 0 ;
16089
16090   result = (Dali::Vector4 *)&Dali::Color::SLATE_BLUE;
16091   jresult = (void *)result;
16092   return jresult;
16093 }
16094
16095
16096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SLATE_GRAY_get() {
16097   void * jresult;
16098   Dali::Vector4 *result = 0 ;
16099
16100   result = (Dali::Vector4 *)&Dali::Color::SLATE_GRAY;
16101   jresult = (void *)result;
16102   return jresult;
16103 }
16104
16105
16106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SLATE_GREY_get() {
16107   void * jresult;
16108   Dali::Vector4 *result = 0 ;
16109
16110   result = (Dali::Vector4 *)&Dali::Color::SLATE_GREY;
16111   jresult = (void *)result;
16112   return jresult;
16113 }
16114
16115
16116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SNOW_get() {
16117   void * jresult;
16118   Dali::Vector4 *result = 0 ;
16119
16120   result = (Dali::Vector4 *)&Dali::Color::SNOW;
16121   jresult = (void *)result;
16122   return jresult;
16123 }
16124
16125
16126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SPRING_GREEN_get() {
16127   void * jresult;
16128   Dali::Vector4 *result = 0 ;
16129
16130   result = (Dali::Vector4 *)&Dali::Color::SPRING_GREEN;
16131   jresult = (void *)result;
16132   return jresult;
16133 }
16134
16135
16136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_STEEL_BLUE_get() {
16137   void * jresult;
16138   Dali::Vector4 *result = 0 ;
16139
16140   result = (Dali::Vector4 *)&Dali::Color::STEEL_BLUE;
16141   jresult = (void *)result;
16142   return jresult;
16143 }
16144
16145
16146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TAN_get() {
16147   void * jresult;
16148   Dali::Vector4 *result = 0 ;
16149
16150   result = (Dali::Vector4 *)&Dali::Color::TAN;
16151   jresult = (void *)result;
16152   return jresult;
16153 }
16154
16155
16156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TEAL_get() {
16157   void * jresult;
16158   Dali::Vector4 *result = 0 ;
16159
16160   result = (Dali::Vector4 *)&Dali::Color::TEAL;
16161   jresult = (void *)result;
16162   return jresult;
16163 }
16164
16165
16166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_THISTLE_get() {
16167   void * jresult;
16168   Dali::Vector4 *result = 0 ;
16169
16170   result = (Dali::Vector4 *)&Dali::Color::THISTLE;
16171   jresult = (void *)result;
16172   return jresult;
16173 }
16174
16175
16176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TOMATO_get() {
16177   void * jresult;
16178   Dali::Vector4 *result = 0 ;
16179
16180   result = (Dali::Vector4 *)&Dali::Color::TOMATO;
16181   jresult = (void *)result;
16182   return jresult;
16183 }
16184
16185
16186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
16187   void * jresult;
16188   Dali::Vector4 *result = 0 ;
16189
16190   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
16191   jresult = (void *)result;
16192   return jresult;
16193 }
16194
16195
16196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TURQUOISE_get() {
16197   void * jresult;
16198   Dali::Vector4 *result = 0 ;
16199
16200   result = (Dali::Vector4 *)&Dali::Color::TURQUOISE;
16201   jresult = (void *)result;
16202   return jresult;
16203 }
16204
16205
16206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VIOLET_get() {
16207   void * jresult;
16208   Dali::Vector4 *result = 0 ;
16209
16210   result = (Dali::Vector4 *)&Dali::Color::VIOLET;
16211   jresult = (void *)result;
16212   return jresult;
16213 }
16214
16215
16216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHEAT_get() {
16217   void * jresult;
16218   Dali::Vector4 *result = 0 ;
16219
16220   result = (Dali::Vector4 *)&Dali::Color::WHEAT;
16221   jresult = (void *)result;
16222   return jresult;
16223 }
16224
16225
16226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
16227   void * jresult;
16228   Dali::Vector4 *result = 0 ;
16229
16230   result = (Dali::Vector4 *)&Dali::Color::WHITE;
16231   jresult = (void *)result;
16232   return jresult;
16233 }
16234
16235
16236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_SMOKE_get() {
16237   void * jresult;
16238   Dali::Vector4 *result = 0 ;
16239
16240   result = (Dali::Vector4 *)&Dali::Color::WHITE_SMOKE;
16241   jresult = (void *)result;
16242   return jresult;
16243 }
16244
16245
16246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
16247   void * jresult;
16248   Dali::Vector4 *result = 0 ;
16249
16250   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
16251   jresult = (void *)result;
16252   return jresult;
16253 }
16254
16255
16256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_GREEN_get() {
16257   void * jresult;
16258   Dali::Vector4 *result = 0 ;
16259
16260   result = (Dali::Vector4 *)&Dali::Color::YELLOW_GREEN;
16261   jresult = (void *)result;
16262   return jresult;
16263 }
16264
16265
16266 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
16267   float jresult ;
16268   float result;
16269
16270   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
16271   jresult = result;
16272   return jresult;
16273 }
16274
16275
16276 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
16277   float jresult ;
16278   float result;
16279
16280   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
16281   jresult = result;
16282   return jresult;
16283 }
16284
16285
16286 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
16287   float jresult ;
16288   float result;
16289
16290   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
16291   jresult = result;
16292   return jresult;
16293 }
16294
16295
16296 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
16297   float jresult ;
16298   float result;
16299
16300   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
16301   jresult = result;
16302   return jresult;
16303 }
16304
16305
16306 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
16307   float jresult ;
16308   float result;
16309
16310   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
16311   jresult = result;
16312   return jresult;
16313 }
16314
16315
16316 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
16317   float jresult ;
16318   float result;
16319
16320   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
16321   jresult = result;
16322   return jresult;
16323 }
16324
16325
16326 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
16327   float jresult ;
16328   float result;
16329
16330   result = (float)(float)Dali::Math::PI;
16331   jresult = result;
16332   return jresult;
16333 }
16334
16335
16336 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
16337   float jresult ;
16338   float result;
16339
16340   result = (float)(float)Dali::Math::PI_2;
16341   jresult = result;
16342   return jresult;
16343 }
16344
16345
16346 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
16347   float jresult ;
16348   float result;
16349
16350   result = (float)(float)Dali::Math::PI_4;
16351   jresult = result;
16352   return jresult;
16353 }
16354
16355
16356 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
16357   float jresult ;
16358   float result;
16359
16360   result = (float)(float)Dali::Math::PI_OVER_180;
16361   jresult = result;
16362   return jresult;
16363 }
16364
16365
16366 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
16367   float jresult ;
16368   float result;
16369
16370   result = (float)(float)Dali::Math::ONE80_OVER_PI;
16371   jresult = result;
16372   return jresult;
16373 }
16374
16375
16376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
16377   int jresult ;
16378   Dali::ResizePolicy::Type result;
16379
16380   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
16381   jresult = (int)result;
16382   return jresult;
16383 }
16384
16385
16386 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
16387   unsigned long jresult ;
16388   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
16389   Dali::VectorBase::SizeType result;
16390
16391   arg1 = (Dali::VectorBase *)jarg1;
16392   {
16393     try {
16394       result = ((Dali::VectorBase const *)arg1)->Count();
16395     } CALL_CATCH_EXCEPTION(0);
16396   }
16397
16398   jresult = (unsigned long)result;
16399   return jresult;
16400 }
16401
16402
16403 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
16404   unsigned long jresult ;
16405   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
16406   Dali::VectorBase::SizeType result;
16407
16408   arg1 = (Dali::VectorBase *)jarg1;
16409   {
16410     try {
16411       result = ((Dali::VectorBase const *)arg1)->Size();
16412     } CALL_CATCH_EXCEPTION(0);
16413   }
16414
16415   jresult = (unsigned long)result;
16416   return jresult;
16417 }
16418
16419
16420 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
16421   bool jresult ;
16422   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
16423   bool result;
16424
16425   arg1 = (Dali::VectorBase *)jarg1;
16426   {
16427     try {
16428       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
16429     } CALL_CATCH_EXCEPTION(0);
16430   }
16431
16432   jresult = result;
16433   return jresult;
16434 }
16435
16436
16437 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
16438   unsigned long jresult ;
16439   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
16440   Dali::VectorBase::SizeType result;
16441
16442   arg1 = (Dali::VectorBase *)jarg1;
16443   {
16444     try {
16445       result = ((Dali::VectorBase const *)arg1)->Capacity();
16446     } CALL_CATCH_EXCEPTION(0);
16447   }
16448
16449   jresult = (unsigned long)result;
16450   return jresult;
16451 }
16452
16453
16454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
16455   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
16456
16457   arg1 = (Dali::VectorBase *)jarg1;
16458   {
16459     try {
16460       (arg1)->Release();
16461     } CALL_CATCH_EXCEPTION();
16462   }
16463
16464 }
16465
16466
16467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
16468   int jresult ;
16469   Dali::Pixel::Format result;
16470
16471   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
16472   jresult = (int)result;
16473   return jresult;
16474 }
16475
16476
16477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
16478   int jresult ;
16479   Dali::Pixel::Format result;
16480
16481   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
16482   jresult = (int)result;
16483   return jresult;
16484 }
16485
16486
16487 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
16488   bool jresult ;
16489   Dali::Pixel::Format arg1 ;
16490   bool result;
16491
16492   arg1 = (Dali::Pixel::Format)jarg1;
16493   {
16494     try {
16495       result = (bool)Dali::Pixel::HasAlpha(arg1);
16496     } CALL_CATCH_EXCEPTION(0);
16497   }
16498
16499   jresult = result;
16500   return jresult;
16501 }
16502
16503
16504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
16505   unsigned int jresult ;
16506   Dali::Pixel::Format arg1 ;
16507   unsigned int result;
16508
16509   arg1 = (Dali::Pixel::Format)jarg1;
16510   {
16511     try {
16512       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
16513     } CALL_CATCH_EXCEPTION(0);
16514   }
16515
16516   jresult = result;
16517   return jresult;
16518 }
16519
16520
16521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
16522   Dali::Pixel::Format arg1 ;
16523   int *arg2 = 0 ;
16524   int *arg3 = 0 ;
16525
16526   arg1 = (Dali::Pixel::Format)jarg1;
16527   arg2 = (int *)jarg2;
16528   if (!arg2) {
16529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
16530     return ;
16531   }
16532   arg3 = (int *)jarg3;
16533   if (!arg3) {
16534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
16535     return ;
16536   }
16537   {
16538     try {
16539       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
16540     } CALL_CATCH_EXCEPTION();
16541   }
16542
16543 }
16544
16545
16546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* nuiBuffer, unsigned int nuiBufferSize, unsigned int nuiWidth, unsigned int nuiHeight, int nuiPixelFormat) {
16547   void * jresult ;
16548   Dali::PixelData result;
16549
16550   {
16551     unsigned char* copiedBuffer;
16552     try
16553     {
16554       copiedBuffer = new unsigned char[nuiBufferSize];
16555     } CALL_CATCH_EXCEPTION(0);
16556
16557     try
16558     {
16559       // Note : copiedBuffer created by 'new' method. So ReleaseFunction always be DELETE_ARRAY.
16560       memcpy(copiedBuffer, nuiBuffer, nuiBufferSize);
16561       result = Dali::PixelData::New(copiedBuffer, nuiBufferSize, nuiWidth, nuiHeight, (Dali::Pixel::Format)nuiPixelFormat, Dali::PixelData::ReleaseFunction::DELETE_ARRAY);
16562     } CALL_CATCH_EXCEPTION_WITH_FUNCTION(0, [](unsigned char* buffer){delete[] buffer;}, copiedBuffer);
16563   }
16564
16565   jresult = new Dali::PixelData((const Dali::PixelData &)result);
16566
16567   return jresult;
16568 }
16569
16570
16571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
16572   void * jresult ;
16573   Dali::PixelData *result = 0 ;
16574
16575   {
16576     try {
16577       result = (Dali::PixelData *)new Dali::PixelData();
16578     } CALL_CATCH_EXCEPTION(0);
16579   }
16580
16581   jresult = (void *)result;
16582   return jresult;
16583 }
16584
16585
16586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * nuiHandle) {
16587   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
16588
16589   pixelData = (Dali::PixelData *)nuiHandle;
16590   {
16591     try {
16592       delete pixelData;
16593     } CALL_CATCH_EXCEPTION();
16594   }
16595
16596 }
16597
16598
16599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * nuiHandle) {
16600   void * jresult ;
16601   Dali::PixelData *pixelData = 0 ;
16602   Dali::PixelData *result = 0 ;
16603
16604   pixelData = (Dali::PixelData *)nuiHandle;
16605   if (!pixelData) {
16606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
16607     return 0;
16608   }
16609   {
16610     try {
16611       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*pixelData);
16612     } CALL_CATCH_EXCEPTION(0);
16613   }
16614
16615   jresult = (void *)result;
16616   return jresult;
16617 }
16618
16619
16620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * nuiHandle, void * nuiHandleSource) {
16621   void * jresult ;
16622   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
16623   Dali::PixelData *pixelDataSource = 0 ;
16624   Dali::PixelData *result = 0 ;
16625
16626   pixelData = (Dali::PixelData *)nuiHandle;
16627   pixelDataSource = (Dali::PixelData *)nuiHandleSource;
16628   if (!pixelDataSource) {
16629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
16630     return 0;
16631   }
16632   {
16633     try {
16634       result = (Dali::PixelData *) &(pixelData)->operator =((Dali::PixelData const &)*pixelDataSource);
16635     } CALL_CATCH_EXCEPTION(0);
16636   }
16637
16638   jresult = (void *)result;
16639   return jresult;
16640 }
16641
16642
16643 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * nuiHandle) {
16644   unsigned int jresult ;
16645   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
16646   unsigned int result;
16647
16648   pixelData = (Dali::PixelData *)nuiHandle;
16649   {
16650     try {
16651       result = (unsigned int)((Dali::PixelData const *)pixelData)->GetWidth();
16652     } CALL_CATCH_EXCEPTION(0);
16653   }
16654
16655   jresult = result;
16656   return jresult;
16657 }
16658
16659
16660 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * nuiHandle) {
16661   unsigned int jresult ;
16662   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
16663   unsigned int result;
16664
16665   pixelData = (Dali::PixelData *)nuiHandle;
16666   {
16667     try {
16668       result = (unsigned int)((Dali::PixelData const *)pixelData)->GetHeight();
16669     } CALL_CATCH_EXCEPTION(0);
16670   }
16671
16672   jresult = result;
16673   return jresult;
16674 }
16675
16676
16677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * nuiHandle) {
16678   int jresult ;
16679   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
16680   Dali::Pixel::Format result;
16681
16682   pixelData = (Dali::PixelData *)nuiHandle;
16683   {
16684     try {
16685       result = (Dali::Pixel::Format)((Dali::PixelData const *)pixelData)->GetPixelFormat();
16686     } CALL_CATCH_EXCEPTION(0);
16687   }
16688
16689   jresult = (int)result;
16690   return jresult;
16691 }
16692
16693 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_PixelData_GenerateUrl(void* nuiHandle)
16694 {
16695   Dali::PixelData *pixelData = (Dali::PixelData*)nuiHandle;
16696   Dali::Toolkit::ImageUrl result;
16697   void *jresult;
16698
16699   if (!pixelData)
16700   {
16701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0);
16702     return 0;
16703   }
16704   {
16705     try
16706     {
16707       result = Dali::Toolkit::Image::GenerateUrl(*pixelData);
16708     } CALL_CATCH_EXCEPTION(0);
16709   }
16710
16711   jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl&)result);
16712   return jresult;
16713 }
16714
16715
16716 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
16717   unsigned int jresult ;
16718   unsigned int result;
16719
16720   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
16721   jresult = result;
16722   return jresult;
16723 }
16724
16725
16726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
16727   unsigned int jresult ;
16728   unsigned int result;
16729
16730   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
16731   jresult = result;
16732   return jresult;
16733 }
16734
16735
16736 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
16737   unsigned int jresult ;
16738   unsigned int result;
16739
16740   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
16741   jresult = result;
16742   return jresult;
16743 }
16744
16745
16746 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
16747   unsigned int jresult ;
16748   unsigned int result;
16749
16750   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
16751   jresult = result;
16752   return jresult;
16753 }
16754
16755
16756 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
16757   unsigned int jresult ;
16758   unsigned int result;
16759
16760   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
16761   jresult = result;
16762   return jresult;
16763 }
16764
16765
16766 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
16767   unsigned int jresult ;
16768   unsigned int result;
16769
16770   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
16771   jresult = result;
16772   return jresult;
16773 }
16774
16775
16776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
16777   void * jresult ;
16778   Dali::TextureType::Type arg1 ;
16779   Dali::Pixel::Format arg2 ;
16780   unsigned int arg3 ;
16781   unsigned int arg4 ;
16782   Dali::Texture result;
16783
16784   arg1 = (Dali::TextureType::Type)jarg1;
16785   arg2 = (Dali::Pixel::Format)jarg2;
16786   arg3 = (unsigned int)jarg3;
16787   arg4 = (unsigned int)jarg4;
16788   {
16789     try {
16790       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
16791     } CALL_CATCH_EXCEPTION(0);
16792   }
16793
16794   jresult = new Dali::Texture((const Dali::Texture &)result);
16795   return jresult;
16796 }
16797
16798
16799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
16800   void * jresult ;
16801   NativeImageInterface *arg1 = 0 ;
16802   Dali::Texture result;
16803
16804   arg1 = (NativeImageInterface *)jarg1;
16805   if (!arg1) {
16806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
16807     return 0;
16808   }
16809   {
16810     try {
16811       result = Dali::Texture::New(*arg1);
16812     } CALL_CATCH_EXCEPTION(0);
16813   }
16814
16815   jresult = new Dali::Texture((const Dali::Texture &)result);
16816   return jresult;
16817 }
16818
16819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
16820   void * jresult ;
16821   Dali::Texture *result = 0 ;
16822
16823   {
16824     try {
16825       result = (Dali::Texture *)new Dali::Texture();
16826     } CALL_CATCH_EXCEPTION(0);
16827   }
16828
16829   jresult = (void *)result;
16830   return jresult;
16831 }
16832
16833
16834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
16835   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16836
16837   arg1 = (Dali::Texture *)jarg1;
16838   {
16839     try {
16840       delete arg1;
16841     } CALL_CATCH_EXCEPTION();
16842   }
16843
16844 }
16845
16846
16847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
16848   void * jresult ;
16849   Dali::Texture *arg1 = 0 ;
16850   Dali::Texture *result = 0 ;
16851
16852   arg1 = (Dali::Texture *)jarg1;
16853   if (!arg1) {
16854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
16855     return 0;
16856   }
16857   {
16858     try {
16859       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
16860     } CALL_CATCH_EXCEPTION(0);
16861   }
16862
16863   jresult = (void *)result;
16864   return jresult;
16865 }
16866
16867
16868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
16869   void * jresult ;
16870   Dali::BaseHandle arg1 ;
16871   Dali::BaseHandle *argp1 ;
16872   Dali::Texture result;
16873
16874   argp1 = (Dali::BaseHandle *)jarg1;
16875   if (!argp1) {
16876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16877     return 0;
16878   }
16879   arg1 = *argp1;
16880   {
16881     try {
16882       result = Dali::Texture::DownCast(arg1);
16883     } CALL_CATCH_EXCEPTION(0);
16884   }
16885
16886   jresult = new Dali::Texture((const Dali::Texture &)result);
16887   return jresult;
16888 }
16889
16890
16891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
16892   void * jresult ;
16893   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16894   Dali::Texture *arg2 = 0 ;
16895   Dali::Texture *result = 0 ;
16896
16897   arg1 = (Dali::Texture *)jarg1;
16898   arg2 = (Dali::Texture *)jarg2;
16899   if (!arg2) {
16900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
16901     return 0;
16902   }
16903   {
16904     try {
16905       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
16906     } CALL_CATCH_EXCEPTION(0);
16907   }
16908
16909   jresult = (void *)result;
16910   return jresult;
16911 }
16912
16913
16914 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
16915   bool jresult ;
16916   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16917   Dali::PixelData arg2 ;
16918   Dali::PixelData *argp2 ;
16919   bool result;
16920
16921   arg1 = (Dali::Texture *)jarg1;
16922   argp2 = (Dali::PixelData *)jarg2;
16923   if (!argp2) {
16924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
16925     return 0;
16926   }
16927   arg2 = *argp2;
16928   {
16929     try {
16930       result = (bool)(arg1)->Upload(arg2);
16931     } CALL_CATCH_EXCEPTION(0);
16932   }
16933
16934   jresult = result;
16935   return jresult;
16936 }
16937
16938
16939 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) {
16940   bool jresult ;
16941   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16942   Dali::PixelData arg2 ;
16943   unsigned int arg3 ;
16944   unsigned int arg4 ;
16945   unsigned int arg5 ;
16946   unsigned int arg6 ;
16947   unsigned int arg7 ;
16948   unsigned int arg8 ;
16949   Dali::PixelData *argp2 ;
16950   bool result;
16951
16952   arg1 = (Dali::Texture *)jarg1;
16953   argp2 = (Dali::PixelData *)jarg2;
16954   if (!argp2) {
16955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
16956     return 0;
16957   }
16958   arg2 = *argp2;
16959   arg3 = (unsigned int)jarg3;
16960   arg4 = (unsigned int)jarg4;
16961   arg5 = (unsigned int)jarg5;
16962   arg6 = (unsigned int)jarg6;
16963   arg7 = (unsigned int)jarg7;
16964   arg8 = (unsigned int)jarg8;
16965   {
16966     try {
16967       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
16968     } CALL_CATCH_EXCEPTION(0);
16969   }
16970
16971   jresult = result;
16972   return jresult;
16973 }
16974
16975
16976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
16977   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16978
16979   arg1 = (Dali::Texture *)jarg1;
16980   {
16981     try {
16982       (arg1)->GenerateMipmaps();
16983     } CALL_CATCH_EXCEPTION();
16984   }
16985
16986 }
16987
16988
16989 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
16990   unsigned int jresult ;
16991   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16992   unsigned int result;
16993
16994   arg1 = (Dali::Texture *)jarg1;
16995   {
16996     try {
16997       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
16998     } CALL_CATCH_EXCEPTION(0);
16999   }
17000
17001   jresult = result;
17002   return jresult;
17003 }
17004
17005
17006 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
17007   unsigned int jresult ;
17008   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
17009   unsigned int result;
17010
17011   arg1 = (Dali::Texture *)jarg1;
17012   {
17013     try {
17014       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
17015     } CALL_CATCH_EXCEPTION(0);
17016   }
17017
17018   jresult = result;
17019   return jresult;
17020 }
17021
17022
17023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
17024   void * jresult ;
17025   Dali::Sampler result;
17026
17027   {
17028     try {
17029       result = Dali::Sampler::New();
17030     } CALL_CATCH_EXCEPTION(0);
17031   }
17032
17033   jresult = new Dali::Sampler((const Dali::Sampler &)result);
17034   return jresult;
17035 }
17036
17037
17038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
17039   void * jresult ;
17040   Dali::Sampler *result = 0 ;
17041
17042   {
17043     try {
17044       result = (Dali::Sampler *)new Dali::Sampler();
17045     } CALL_CATCH_EXCEPTION(0);
17046   }
17047
17048   jresult = (void *)result;
17049   return jresult;
17050 }
17051
17052
17053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
17054   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
17055
17056   arg1 = (Dali::Sampler *)jarg1;
17057   {
17058     try {
17059       delete arg1;
17060     } CALL_CATCH_EXCEPTION();
17061   }
17062
17063 }
17064
17065
17066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
17067   void * jresult ;
17068   Dali::Sampler *arg1 = 0 ;
17069   Dali::Sampler *result = 0 ;
17070
17071   arg1 = (Dali::Sampler *)jarg1;
17072   if (!arg1) {
17073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
17074     return 0;
17075   }
17076   {
17077     try {
17078       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
17079     } CALL_CATCH_EXCEPTION(0);
17080   }
17081
17082   jresult = (void *)result;
17083   return jresult;
17084 }
17085
17086
17087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
17088   void * jresult ;
17089   Dali::BaseHandle arg1 ;
17090   Dali::BaseHandle *argp1 ;
17091   Dali::Sampler result;
17092
17093   argp1 = (Dali::BaseHandle *)jarg1;
17094   if (!argp1) {
17095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17096     return 0;
17097   }
17098   arg1 = *argp1;
17099   {
17100     try {
17101       result = Dali::Sampler::DownCast(arg1);
17102     } CALL_CATCH_EXCEPTION(0);
17103   }
17104
17105   jresult = new Dali::Sampler((const Dali::Sampler &)result);
17106   return jresult;
17107 }
17108
17109
17110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
17111   void * jresult ;
17112   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
17113   Dali::Sampler *arg2 = 0 ;
17114   Dali::Sampler *result = 0 ;
17115
17116   arg1 = (Dali::Sampler *)jarg1;
17117   arg2 = (Dali::Sampler *)jarg2;
17118   if (!arg2) {
17119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
17120     return 0;
17121   }
17122   {
17123     try {
17124       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
17125     } CALL_CATCH_EXCEPTION(0);
17126   }
17127
17128   jresult = (void *)result;
17129   return jresult;
17130 }
17131
17132
17133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
17134   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
17135   Dali::FilterMode::Type arg2 ;
17136   Dali::FilterMode::Type arg3 ;
17137
17138   arg1 = (Dali::Sampler *)jarg1;
17139   arg2 = (Dali::FilterMode::Type)jarg2;
17140   arg3 = (Dali::FilterMode::Type)jarg3;
17141   {
17142     try {
17143       (arg1)->SetFilterMode(arg2,arg3);
17144     } CALL_CATCH_EXCEPTION();
17145   }
17146
17147 }
17148
17149
17150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
17151   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
17152   Dali::WrapMode::Type arg2 ;
17153   Dali::WrapMode::Type arg3 ;
17154
17155   arg1 = (Dali::Sampler *)jarg1;
17156   arg2 = (Dali::WrapMode::Type)jarg2;
17157   arg3 = (Dali::WrapMode::Type)jarg3;
17158   {
17159     try {
17160       (arg1)->SetWrapMode(arg2,arg3);
17161     } CALL_CATCH_EXCEPTION();
17162   }
17163
17164 }
17165
17166
17167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
17168   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
17169   Dali::WrapMode::Type arg2 ;
17170   Dali::WrapMode::Type arg3 ;
17171   Dali::WrapMode::Type arg4 ;
17172
17173   arg1 = (Dali::Sampler *)jarg1;
17174   arg2 = (Dali::WrapMode::Type)jarg2;
17175   arg3 = (Dali::WrapMode::Type)jarg3;
17176   arg4 = (Dali::WrapMode::Type)jarg4;
17177   {
17178     try {
17179       (arg1)->SetWrapMode(arg2,arg3,arg4);
17180     } CALL_CATCH_EXCEPTION();
17181   }
17182
17183 }
17184
17185
17186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
17187   void * jresult ;
17188   Dali::TextureSet result;
17189
17190   {
17191     try {
17192       result = Dali::TextureSet::New();
17193     } CALL_CATCH_EXCEPTION(0);
17194   }
17195
17196   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
17197   return jresult;
17198 }
17199
17200
17201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
17202   void * jresult ;
17203   Dali::TextureSet *result = 0 ;
17204
17205   {
17206     try {
17207       result = (Dali::TextureSet *)new Dali::TextureSet();
17208     } CALL_CATCH_EXCEPTION(0);
17209   }
17210
17211   jresult = (void *)result;
17212   return jresult;
17213 }
17214
17215
17216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
17217   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
17218
17219   arg1 = (Dali::TextureSet *)jarg1;
17220   {
17221     try {
17222       delete arg1;
17223     } CALL_CATCH_EXCEPTION();
17224   }
17225
17226 }
17227
17228
17229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
17230   void * jresult ;
17231   Dali::TextureSet *arg1 = 0 ;
17232   Dali::TextureSet *result = 0 ;
17233
17234   arg1 = (Dali::TextureSet *)jarg1;
17235   if (!arg1) {
17236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
17237     return 0;
17238   }
17239   {
17240     try {
17241       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
17242     } CALL_CATCH_EXCEPTION(0);
17243   }
17244
17245   jresult = (void *)result;
17246   return jresult;
17247 }
17248
17249
17250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
17251   void * jresult ;
17252   Dali::BaseHandle arg1 ;
17253   Dali::BaseHandle *argp1 ;
17254   Dali::TextureSet result;
17255
17256   argp1 = (Dali::BaseHandle *)jarg1;
17257   if (!argp1) {
17258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17259     return 0;
17260   }
17261   arg1 = *argp1;
17262   {
17263     try {
17264       result = Dali::TextureSet::DownCast(arg1);
17265     } CALL_CATCH_EXCEPTION(0);
17266   }
17267
17268   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
17269   return jresult;
17270 }
17271
17272
17273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
17274   void * jresult ;
17275   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
17276   Dali::TextureSet *arg2 = 0 ;
17277   Dali::TextureSet *result = 0 ;
17278
17279   arg1 = (Dali::TextureSet *)jarg1;
17280   arg2 = (Dali::TextureSet *)jarg2;
17281   if (!arg2) {
17282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
17283     return 0;
17284   }
17285   {
17286     try {
17287       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
17288     } CALL_CATCH_EXCEPTION(0);
17289   }
17290
17291   jresult = (void *)result;
17292   return jresult;
17293 }
17294
17295
17296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
17297   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
17298   size_t arg2 ;
17299   Dali::Texture arg3 ;
17300   Dali::Texture *argp3 ;
17301
17302   arg1 = (Dali::TextureSet *)jarg1;
17303   arg2 = (size_t)jarg2;
17304   argp3 = (Dali::Texture *)jarg3;
17305   if (!argp3) {
17306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
17307     return ;
17308   }
17309   arg3 = *argp3;
17310   {
17311     try {
17312       (arg1)->SetTexture(arg2,arg3);
17313     } CALL_CATCH_EXCEPTION();
17314   }
17315
17316 }
17317
17318
17319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
17320   void * jresult ;
17321   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
17322   size_t arg2 ;
17323   Dali::Texture result;
17324
17325   arg1 = (Dali::TextureSet *)jarg1;
17326   arg2 = (size_t)jarg2;
17327   {
17328     try {
17329       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
17330     } CALL_CATCH_EXCEPTION(0);
17331   }
17332
17333   jresult = new Dali::Texture((const Dali::Texture &)result);
17334   return jresult;
17335 }
17336
17337
17338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
17339   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
17340   size_t arg2 ;
17341   Dali::Sampler arg3 ;
17342   Dali::Sampler *argp3 ;
17343
17344   arg1 = (Dali::TextureSet *)jarg1;
17345   arg2 = (size_t)jarg2;
17346   argp3 = (Dali::Sampler *)jarg3;
17347   if (!argp3) {
17348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
17349     return ;
17350   }
17351   arg3 = *argp3;
17352   {
17353     try {
17354       (arg1)->SetSampler(arg2,arg3);
17355     } CALL_CATCH_EXCEPTION();
17356   }
17357
17358 }
17359
17360
17361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
17362   void * jresult ;
17363   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
17364   size_t arg2 ;
17365   Dali::Sampler result;
17366
17367   arg1 = (Dali::TextureSet *)jarg1;
17368   arg2 = (size_t)jarg2;
17369   {
17370     try {
17371       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
17372     } CALL_CATCH_EXCEPTION(0);
17373   }
17374
17375   jresult = new Dali::Sampler((const Dali::Sampler &)result);
17376   return jresult;
17377 }
17378
17379
17380 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
17381   unsigned long jresult ;
17382   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
17383   size_t result;
17384
17385   arg1 = (Dali::TextureSet *)jarg1;
17386   {
17387     try {
17388       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
17389     } CALL_CATCH_EXCEPTION(0);
17390   }
17391
17392   jresult = (unsigned long)result;
17393   return jresult;
17394 }
17395
17396
17397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_New(void * jarg1) {
17398   void * jresult ;
17399   Dali::Property::Map *arg1 = 0 ;
17400   Dali::VertexBuffer result;
17401
17402   arg1 = (Dali::Property::Map *)jarg1;
17403   if (!arg1) {
17404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17405     return 0;
17406   }
17407   {
17408     try {
17409       result = Dali::VertexBuffer::New(*arg1);
17410     } CALL_CATCH_EXCEPTION(0);
17411   }
17412
17413   jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result);
17414   return jresult;
17415 }
17416
17417
17418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_0() {
17419   void * jresult ;
17420   Dali::VertexBuffer *result = 0 ;
17421
17422   {
17423     try {
17424       result = (Dali::VertexBuffer *)new Dali::VertexBuffer();
17425     } CALL_CATCH_EXCEPTION(0);
17426   }
17427
17428   jresult = (void *)result;
17429   return jresult;
17430 }
17431
17432
17433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VertexBuffer(void * jarg1) {
17434   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
17435
17436   arg1 = (Dali::VertexBuffer *)jarg1;
17437   {
17438     try {
17439       delete arg1;
17440     } CALL_CATCH_EXCEPTION();
17441   }
17442
17443 }
17444
17445
17446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_1(void * jarg1) {
17447   void * jresult ;
17448   Dali::VertexBuffer *arg1 = 0 ;
17449   Dali::VertexBuffer *result = 0 ;
17450
17451   arg1 = (Dali::VertexBuffer *)jarg1;
17452   if (!arg1) {
17453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0);
17454     return 0;
17455   }
17456   {
17457     try {
17458       result = (Dali::VertexBuffer *)new Dali::VertexBuffer((Dali::VertexBuffer const &)*arg1);
17459     } CALL_CATCH_EXCEPTION(0);
17460   }
17461
17462   jresult = (void *)result;
17463   return jresult;
17464 }
17465
17466
17467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_DownCast(void * jarg1) {
17468   void * jresult ;
17469   Dali::BaseHandle arg1 ;
17470   Dali::BaseHandle *argp1 ;
17471   Dali::VertexBuffer result;
17472
17473   argp1 = (Dali::BaseHandle *)jarg1;
17474   if (!argp1) {
17475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17476     return 0;
17477   }
17478   arg1 = *argp1;
17479   {
17480     try {
17481       result = Dali::VertexBuffer::DownCast(arg1);
17482     } CALL_CATCH_EXCEPTION(0);
17483   }
17484
17485   jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result);
17486   return jresult;
17487 }
17488
17489
17490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_Assign(void * jarg1, void * jarg2) {
17491   void * jresult ;
17492   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
17493   Dali::VertexBuffer *arg2 = 0 ;
17494   Dali::VertexBuffer *result = 0 ;
17495
17496   arg1 = (Dali::VertexBuffer *)jarg1;
17497   arg2 = (Dali::VertexBuffer *)jarg2;
17498   if (!arg2) {
17499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0);
17500     return 0;
17501   }
17502   {
17503     try {
17504       result = (Dali::VertexBuffer *) &(arg1)->operator =((Dali::VertexBuffer const &)*arg2);
17505     } CALL_CATCH_EXCEPTION(0);
17506   }
17507
17508   jresult = (void *)result;
17509   return jresult;
17510 }
17511
17512
17513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VertexBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
17514   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
17515   void *arg2 = (void *) 0 ;
17516   std::size_t arg3 ;
17517
17518   arg1 = (Dali::VertexBuffer *)jarg1;
17519   arg2 = jarg2;
17520   arg3 = (std::size_t)jarg3;
17521   {
17522     try {
17523       (arg1)->SetData((void const *)arg2,arg3);
17524     } CALL_CATCH_EXCEPTION();
17525   }
17526
17527 }
17528
17529
17530 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VertexBuffer_GetSize(void * jarg1) {
17531   unsigned long jresult ;
17532   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
17533   std::size_t result;
17534
17535   arg1 = (Dali::VertexBuffer *)jarg1;
17536   {
17537     try {
17538       result = ((Dali::VertexBuffer const *)arg1)->GetSize();
17539     } CALL_CATCH_EXCEPTION(0);
17540   }
17541
17542   jresult = (unsigned long)result;
17543   return jresult;
17544 }
17545
17546
17547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
17548   void * jresult ;
17549   Dali::Geometry result;
17550
17551   {
17552     try {
17553       result = Dali::Geometry::New();
17554     } CALL_CATCH_EXCEPTION(0);
17555   }
17556
17557   jresult = new Dali::Geometry((const Dali::Geometry &)result);
17558   return jresult;
17559 }
17560
17561
17562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
17563   void * jresult ;
17564   Dali::Geometry *result = 0 ;
17565
17566   {
17567     try {
17568       result = (Dali::Geometry *)new Dali::Geometry();
17569     } CALL_CATCH_EXCEPTION(0);
17570   }
17571
17572   jresult = (void *)result;
17573   return jresult;
17574 }
17575
17576
17577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
17578   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17579
17580   arg1 = (Dali::Geometry *)jarg1;
17581   {
17582     try {
17583       delete arg1;
17584     } CALL_CATCH_EXCEPTION();
17585   }
17586
17587 }
17588
17589
17590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
17591   void * jresult ;
17592   Dali::Geometry *arg1 = 0 ;
17593   Dali::Geometry *result = 0 ;
17594
17595   arg1 = (Dali::Geometry *)jarg1;
17596   if (!arg1) {
17597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
17598     return 0;
17599   }
17600   {
17601     try {
17602       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
17603     } CALL_CATCH_EXCEPTION(0);
17604   }
17605
17606   jresult = (void *)result;
17607   return jresult;
17608 }
17609
17610
17611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
17612   void * jresult ;
17613   Dali::BaseHandle arg1 ;
17614   Dali::BaseHandle *argp1 ;
17615   Dali::Geometry result;
17616
17617   argp1 = (Dali::BaseHandle *)jarg1;
17618   if (!argp1) {
17619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17620     return 0;
17621   }
17622   arg1 = *argp1;
17623   {
17624     try {
17625       result = Dali::Geometry::DownCast(arg1);
17626     } CALL_CATCH_EXCEPTION(0);
17627   }
17628
17629   jresult = new Dali::Geometry((const Dali::Geometry &)result);
17630   return jresult;
17631 }
17632
17633
17634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
17635   void * jresult ;
17636   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17637   Dali::Geometry *arg2 = 0 ;
17638   Dali::Geometry *result = 0 ;
17639
17640   arg1 = (Dali::Geometry *)jarg1;
17641   arg2 = (Dali::Geometry *)jarg2;
17642   if (!arg2) {
17643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
17644     return 0;
17645   }
17646   {
17647     try {
17648       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
17649     } CALL_CATCH_EXCEPTION(0);
17650   }
17651
17652   jresult = (void *)result;
17653   return jresult;
17654 }
17655
17656
17657 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
17658   unsigned long jresult ;
17659   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17660   Dali::VertexBuffer *arg2 = 0 ;
17661   std::size_t result;
17662
17663   arg1 = (Dali::Geometry *)jarg1;
17664   arg2 = (Dali::VertexBuffer *)jarg2;
17665   if (!arg2) {
17666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer & type is null", 0);
17667     return 0;
17668   }
17669   {
17670     try {
17671       result = (arg1)->AddVertexBuffer(*arg2);
17672     } CALL_CATCH_EXCEPTION(0);
17673   }
17674
17675   jresult = (unsigned long)result;
17676   return jresult;
17677 }
17678
17679
17680 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
17681   unsigned long jresult ;
17682   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17683   std::size_t result;
17684
17685   arg1 = (Dali::Geometry *)jarg1;
17686   {
17687     try {
17688       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
17689     } CALL_CATCH_EXCEPTION(0);
17690   }
17691
17692   jresult = (unsigned long)result;
17693   return jresult;
17694 }
17695
17696
17697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
17698   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17699   std::size_t arg2 ;
17700
17701   arg1 = (Dali::Geometry *)jarg1;
17702   arg2 = (std::size_t)jarg2;
17703   {
17704     try {
17705       (arg1)->RemoveVertexBuffer(arg2);
17706     } CALL_CATCH_EXCEPTION();
17707   }
17708
17709 }
17710
17711
17712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
17713   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17714   unsigned short *arg2 = (unsigned short *) 0 ;
17715   size_t arg3 ;
17716
17717   arg1 = (Dali::Geometry *)jarg1;
17718   arg2 = jarg2;
17719   arg3 = (size_t)jarg3;
17720   {
17721     try {
17722       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
17723     } CALL_CATCH_EXCEPTION();
17724   }
17725
17726
17727
17728 }
17729
17730
17731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
17732   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17733   Dali::Geometry::Type arg2 ;
17734
17735   arg1 = (Dali::Geometry *)jarg1;
17736   arg2 = (Dali::Geometry::Type)jarg2;
17737   {
17738     try {
17739       (arg1)->SetType(arg2);
17740     } CALL_CATCH_EXCEPTION();
17741   }
17742
17743 }
17744
17745
17746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
17747   int jresult ;
17748   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17749   Dali::Geometry::Type result;
17750
17751   arg1 = (Dali::Geometry *)jarg1;
17752   {
17753     try {
17754       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
17755     } CALL_CATCH_EXCEPTION(0);
17756   }
17757
17758   jresult = (int)result;
17759   return jresult;
17760 }
17761
17762
17763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
17764   void * jresult ;
17765   Dali::Shader::Hint *result = 0 ;
17766
17767   {
17768     try {
17769       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
17770     } CALL_CATCH_EXCEPTION(0);
17771   }
17772
17773   jresult = (void *)result;
17774   return jresult;
17775 }
17776
17777
17778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
17779   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
17780
17781   arg1 = (Dali::Shader::Hint *)jarg1;
17782   {
17783     try {
17784       delete arg1;
17785     } CALL_CATCH_EXCEPTION();
17786   }
17787
17788 }
17789
17790
17791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
17792   int jresult ;
17793   int result;
17794
17795   result = (int)Dali::Shader::Property::PROGRAM;
17796   jresult = (int)result;
17797   return jresult;
17798 }
17799
17800
17801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
17802   void * jresult ;
17803   Dali::Shader::Property *result = 0 ;
17804
17805   {
17806     try {
17807       result = (Dali::Shader::Property *)new Dali::Shader::Property();
17808     } CALL_CATCH_EXCEPTION(0);
17809   }
17810
17811   jresult = (void *)result;
17812   return jresult;
17813 }
17814
17815
17816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
17817   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
17818
17819   arg1 = (Dali::Shader::Property *)jarg1;
17820   {
17821     try {
17822       delete arg1;
17823     } CALL_CATCH_EXCEPTION();
17824   }
17825
17826 }
17827
17828
17829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
17830   void * jresult ;
17831   std::string *arg1 = 0 ;
17832   std::string *arg2 = 0 ;
17833   Dali::Shader::Hint::Value arg3 ;
17834   Dali::Shader result;
17835
17836   if (!jarg1) {
17837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17838     return 0;
17839   }
17840   std::string arg1_str(jarg1);
17841   arg1 = &arg1_str;
17842   if (!jarg2) {
17843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17844     return 0;
17845   }
17846   std::string arg2_str(jarg2);
17847   arg2 = &arg2_str;
17848   arg3 = (Dali::Shader::Hint::Value)jarg3;
17849   {
17850     try {
17851       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
17852     } CALL_CATCH_EXCEPTION(0);
17853   }
17854
17855   jresult = new Dali::Shader((const Dali::Shader &)result);
17856
17857   //argout typemap for const std::string&
17858
17859
17860   //argout typemap for const std::string&
17861
17862   return jresult;
17863 }
17864
17865
17866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
17867   void * jresult ;
17868   std::string *arg1 = 0 ;
17869   std::string *arg2 = 0 ;
17870   Dali::Shader result;
17871
17872   if (!jarg1) {
17873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17874     return 0;
17875   }
17876   std::string arg1_str(jarg1);
17877   arg1 = &arg1_str;
17878   if (!jarg2) {
17879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17880     return 0;
17881   }
17882   std::string arg2_str(jarg2);
17883   arg2 = &arg2_str;
17884   {
17885     try {
17886       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
17887     } CALL_CATCH_EXCEPTION(0);
17888   }
17889
17890   jresult = new Dali::Shader((const Dali::Shader &)result);
17891
17892   //argout typemap for const std::string&
17893
17894
17895   //argout typemap for const std::string&
17896
17897   return jresult;
17898 }
17899
17900
17901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
17902   void * jresult ;
17903   Dali::Shader *result = 0 ;
17904
17905   {
17906     try {
17907       result = (Dali::Shader *)new Dali::Shader();
17908     } CALL_CATCH_EXCEPTION(0);
17909   }
17910
17911   jresult = (void *)result;
17912   return jresult;
17913 }
17914
17915
17916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
17917   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
17918
17919   arg1 = (Dali::Shader *)jarg1;
17920   {
17921     try {
17922       delete arg1;
17923     } CALL_CATCH_EXCEPTION();
17924   }
17925
17926 }
17927
17928
17929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
17930   void * jresult ;
17931   Dali::Shader *arg1 = 0 ;
17932   Dali::Shader *result = 0 ;
17933
17934   arg1 = (Dali::Shader *)jarg1;
17935   if (!arg1) {
17936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
17937     return 0;
17938   }
17939   {
17940     try {
17941       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
17942     } CALL_CATCH_EXCEPTION(0);
17943   }
17944
17945   jresult = (void *)result;
17946   return jresult;
17947 }
17948
17949
17950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
17951   void * jresult ;
17952   Dali::BaseHandle arg1 ;
17953   Dali::BaseHandle *argp1 ;
17954   Dali::Shader result;
17955
17956   argp1 = (Dali::BaseHandle *)jarg1;
17957   if (!argp1) {
17958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17959     return 0;
17960   }
17961   arg1 = *argp1;
17962   {
17963     try {
17964       result = Dali::Shader::DownCast(arg1);
17965     } CALL_CATCH_EXCEPTION(0);
17966   }
17967
17968   jresult = new Dali::Shader((const Dali::Shader &)result);
17969   return jresult;
17970 }
17971
17972
17973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
17974   void * jresult ;
17975   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
17976   Dali::Shader *arg2 = 0 ;
17977   Dali::Shader *result = 0 ;
17978
17979   arg1 = (Dali::Shader *)jarg1;
17980   arg2 = (Dali::Shader *)jarg2;
17981   if (!arg2) {
17982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
17983     return 0;
17984   }
17985   {
17986     try {
17987       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
17988     } CALL_CATCH_EXCEPTION(0);
17989   }
17990
17991   jresult = (void *)result;
17992   return jresult;
17993 }
17994
17995
17996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
17997   int jresult ;
17998   int result;
17999
18000   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
18001   jresult = (int)result;
18002   return jresult;
18003 }
18004
18005
18006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
18007   int jresult ;
18008   int result;
18009
18010   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
18011   jresult = (int)result;
18012   return jresult;
18013 }
18014
18015
18016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
18017   int jresult ;
18018   int result;
18019
18020   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
18021   jresult = (int)result;
18022   return jresult;
18023 }
18024
18025
18026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
18027   int jresult ;
18028   int result;
18029
18030   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
18031   jresult = (int)result;
18032   return jresult;
18033 }
18034
18035
18036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
18037   int jresult ;
18038   int result;
18039
18040   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
18041   jresult = (int)result;
18042   return jresult;
18043 }
18044
18045
18046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
18047   int jresult ;
18048   int result;
18049
18050   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
18051   jresult = (int)result;
18052   return jresult;
18053 }
18054
18055
18056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
18057   int jresult ;
18058   int result;
18059
18060   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
18061   jresult = (int)result;
18062   return jresult;
18063 }
18064
18065
18066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
18067   int jresult ;
18068   int result;
18069
18070   result = (int)Dali::Renderer::Property::BLEND_MODE;
18071   jresult = (int)result;
18072   return jresult;
18073 }
18074
18075
18076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
18077   int jresult ;
18078   int result;
18079
18080   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
18081   jresult = (int)result;
18082   return jresult;
18083 }
18084
18085
18086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
18087   int jresult ;
18088   int result;
18089
18090   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
18091   jresult = (int)result;
18092   return jresult;
18093 }
18094
18095
18096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
18097   int jresult ;
18098   int result;
18099
18100   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
18101   jresult = (int)result;
18102   return jresult;
18103 }
18104
18105
18106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
18107   int jresult ;
18108   int result;
18109
18110   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
18111   jresult = (int)result;
18112   return jresult;
18113 }
18114
18115
18116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
18117   int jresult ;
18118   int result;
18119
18120   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
18121   jresult = (int)result;
18122   return jresult;
18123 }
18124
18125
18126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
18127   int jresult ;
18128   int result;
18129
18130   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
18131   jresult = (int)result;
18132   return jresult;
18133 }
18134
18135
18136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
18137   int jresult ;
18138   int result;
18139
18140   result = (int)Dali::Renderer::Property::BLEND_COLOR;
18141   jresult = (int)result;
18142   return jresult;
18143 }
18144
18145
18146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
18147   int jresult ;
18148   int result;
18149
18150   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
18151   jresult = (int)result;
18152   return jresult;
18153 }
18154
18155
18156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
18157   int jresult ;
18158   int result;
18159
18160   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
18161   jresult = (int)result;
18162   return jresult;
18163 }
18164
18165
18166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
18167   int jresult ;
18168   int result;
18169
18170   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
18171   jresult = (int)result;
18172   return jresult;
18173 }
18174
18175
18176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
18177   int jresult ;
18178   int result;
18179
18180   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
18181   jresult = (int)result;
18182   return jresult;
18183 }
18184
18185
18186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
18187   int jresult ;
18188   int result;
18189
18190   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
18191   jresult = (int)result;
18192   return jresult;
18193 }
18194
18195
18196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
18197   int jresult ;
18198   int result;
18199
18200   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
18201   jresult = (int)result;
18202   return jresult;
18203 }
18204
18205
18206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
18207   int jresult ;
18208   int result;
18209
18210   result = (int)Dali::Renderer::Property::RENDER_MODE;
18211   jresult = (int)result;
18212   return jresult;
18213 }
18214
18215
18216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
18217   int jresult ;
18218   int result;
18219
18220   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
18221   jresult = (int)result;
18222   return jresult;
18223 }
18224
18225
18226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
18227   int jresult ;
18228   int result;
18229
18230   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
18231   jresult = (int)result;
18232   return jresult;
18233 }
18234
18235
18236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
18237   int jresult ;
18238   int result;
18239
18240   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
18241   jresult = (int)result;
18242   return jresult;
18243 }
18244
18245
18246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
18247   int jresult ;
18248   int result;
18249
18250   result = (int)Dali::Renderer::Property::STENCIL_MASK;
18251   jresult = (int)result;
18252   return jresult;
18253 }
18254
18255
18256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
18257   int jresult ;
18258   int result;
18259
18260   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
18261   jresult = (int)result;
18262   return jresult;
18263 }
18264
18265
18266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
18267   int jresult ;
18268   int result;
18269
18270   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
18271   jresult = (int)result;
18272   return jresult;
18273 }
18274
18275
18276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
18277   int jresult ;
18278   int result;
18279
18280   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
18281   jresult = (int)result;
18282   return jresult;
18283 }
18284
18285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CULLED_get() {
18286   return Dali::Actor::Property::CULLED;
18287 }
18288
18289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
18290   void * jresult ;
18291   Dali::Renderer::Property *result = 0 ;
18292
18293   {
18294     try {
18295       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
18296     } CALL_CATCH_EXCEPTION(0);
18297   }
18298
18299   jresult = (void *)result;
18300   return jresult;
18301 }
18302
18303
18304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
18305   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
18306
18307   arg1 = (Dali::Renderer::Property *)jarg1;
18308   {
18309     try {
18310       delete arg1;
18311     } CALL_CATCH_EXCEPTION();
18312   }
18313
18314 }
18315
18316
18317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
18318   void * jresult ;
18319   Dali::Geometry *arg1 = 0 ;
18320   Dali::Shader *arg2 = 0 ;
18321   Dali::Renderer result;
18322
18323   arg1 = (Dali::Geometry *)jarg1;
18324   if (!arg1) {
18325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
18326     return 0;
18327   }
18328   arg2 = (Dali::Shader *)jarg2;
18329   if (!arg2) {
18330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
18331     return 0;
18332   }
18333   {
18334     try {
18335       result = Dali::Renderer::New(*arg1,*arg2);
18336     } CALL_CATCH_EXCEPTION(0);
18337   }
18338
18339   jresult = new Dali::Renderer((const Dali::Renderer &)result);
18340   return jresult;
18341 }
18342
18343
18344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
18345   void * jresult ;
18346   Dali::Renderer *result = 0 ;
18347
18348   {
18349     try {
18350       result = (Dali::Renderer *)new Dali::Renderer();
18351     } CALL_CATCH_EXCEPTION(0);
18352   }
18353
18354   jresult = (void *)result;
18355   return jresult;
18356 }
18357
18358
18359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
18360   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
18361
18362   arg1 = (Dali::Renderer *)jarg1;
18363   {
18364     try {
18365       delete arg1;
18366     } CALL_CATCH_EXCEPTION();
18367   }
18368
18369 }
18370
18371
18372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
18373   void * jresult ;
18374   Dali::Renderer *arg1 = 0 ;
18375   Dali::Renderer *result = 0 ;
18376
18377   arg1 = (Dali::Renderer *)jarg1;
18378   if (!arg1) {
18379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
18380     return 0;
18381   }
18382   {
18383     try {
18384       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
18385     } CALL_CATCH_EXCEPTION(0);
18386   }
18387
18388   jresult = (void *)result;
18389   return jresult;
18390 }
18391
18392
18393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
18394   void * jresult ;
18395   Dali::BaseHandle arg1 ;
18396   Dali::BaseHandle *argp1 ;
18397   Dali::Renderer result;
18398
18399   argp1 = (Dali::BaseHandle *)jarg1;
18400   if (!argp1) {
18401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
18402     return 0;
18403   }
18404   arg1 = *argp1;
18405   {
18406     try {
18407       result = Dali::Renderer::DownCast(arg1);
18408     } CALL_CATCH_EXCEPTION(0);
18409   }
18410
18411   jresult = new Dali::Renderer((const Dali::Renderer &)result);
18412   return jresult;
18413 }
18414
18415
18416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
18417   void * jresult ;
18418   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
18419   Dali::Renderer *arg2 = 0 ;
18420   Dali::Renderer *result = 0 ;
18421
18422   arg1 = (Dali::Renderer *)jarg1;
18423   arg2 = (Dali::Renderer *)jarg2;
18424   if (!arg2) {
18425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
18426     return 0;
18427   }
18428   {
18429     try {
18430       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
18431     } CALL_CATCH_EXCEPTION(0);
18432   }
18433
18434   jresult = (void *)result;
18435   return jresult;
18436 }
18437
18438
18439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
18440   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
18441   Dali::Geometry *arg2 = 0 ;
18442
18443   arg1 = (Dali::Renderer *)jarg1;
18444   arg2 = (Dali::Geometry *)jarg2;
18445   if (!arg2) {
18446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
18447     return ;
18448   }
18449   {
18450     try {
18451       (arg1)->SetGeometry(*arg2);
18452     } CALL_CATCH_EXCEPTION();
18453   }
18454
18455 }
18456
18457
18458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
18459   void * jresult ;
18460   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
18461   Dali::Geometry result;
18462
18463   arg1 = (Dali::Renderer *)jarg1;
18464   {
18465     try {
18466       result = ((Dali::Renderer const *)arg1)->GetGeometry();
18467     } CALL_CATCH_EXCEPTION(0);
18468   }
18469
18470   jresult = new Dali::Geometry((const Dali::Geometry &)result);
18471   return jresult;
18472 }
18473
18474
18475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
18476   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
18477   int arg2 ;
18478   int arg3 ;
18479
18480   arg1 = (Dali::Renderer *)jarg1;
18481   arg2 = (int)jarg2;
18482   arg3 = (int)jarg3;
18483   {
18484     try {
18485       (arg1)->SetIndexRange(arg2,arg3);
18486     } CALL_CATCH_EXCEPTION();
18487   }
18488
18489 }
18490
18491
18492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
18493   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
18494   Dali::TextureSet *arg2 = 0 ;
18495
18496   arg1 = (Dali::Renderer *)jarg1;
18497   arg2 = (Dali::TextureSet *)jarg2;
18498   if (!arg2) {
18499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
18500     return ;
18501   }
18502   {
18503     try {
18504       (arg1)->SetTextures(*arg2);
18505     } CALL_CATCH_EXCEPTION();
18506   }
18507
18508 }
18509
18510
18511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
18512   void * jresult ;
18513   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
18514   Dali::TextureSet result;
18515
18516   arg1 = (Dali::Renderer *)jarg1;
18517   {
18518     try {
18519       result = ((Dali::Renderer const *)arg1)->GetTextures();
18520     } CALL_CATCH_EXCEPTION(0);
18521   }
18522
18523   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
18524   return jresult;
18525 }
18526
18527
18528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
18529   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
18530   Dali::Shader *arg2 = 0 ;
18531
18532   arg1 = (Dali::Renderer *)jarg1;
18533   arg2 = (Dali::Shader *)jarg2;
18534   if (!arg2) {
18535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
18536     return ;
18537   }
18538   {
18539     try {
18540       (arg1)->SetShader(*arg2);
18541     } CALL_CATCH_EXCEPTION();
18542   }
18543
18544 }
18545
18546
18547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
18548   void * jresult ;
18549   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
18550   Dali::Shader result;
18551
18552   arg1 = (Dali::Renderer *)jarg1;
18553   {
18554     try {
18555       result = ((Dali::Renderer const *)arg1)->GetShader();
18556     } CALL_CATCH_EXCEPTION(0);
18557   }
18558
18559   jresult = new Dali::Shader((const Dali::Shader &)result);
18560   return jresult;
18561 }
18562
18563
18564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
18565   void * jresult ;
18566   Dali::FrameBuffer::Attachment *result = 0 ;
18567
18568   {
18569     try {
18570       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
18571     } CALL_CATCH_EXCEPTION(0);
18572   }
18573
18574   jresult = (void *)result;
18575   return jresult;
18576 }
18577
18578
18579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
18580   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
18581
18582   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
18583   {
18584     try {
18585       delete arg1;
18586     } CALL_CATCH_EXCEPTION();
18587   }
18588
18589 }
18590
18591
18592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
18593   void * jresult ;
18594   unsigned int arg1 ;
18595   unsigned int arg2 ;
18596   unsigned int arg3 ;
18597   Dali::FrameBuffer result;
18598
18599   arg1 = (unsigned int)jarg1;
18600   arg2 = (unsigned int)jarg2;
18601   arg3 = (unsigned int)jarg3;
18602   {
18603     try {
18604       result = Dali::FrameBuffer::New(arg1,arg2,static_cast<Dali::FrameBuffer::Attachment::Mask>(arg3));
18605     } CALL_CATCH_EXCEPTION(0);
18606   }
18607
18608   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
18609   return jresult;
18610 }
18611
18612
18613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
18614   void * jresult ;
18615   Dali::FrameBuffer *result = 0 ;
18616
18617   {
18618     try {
18619       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
18620     } CALL_CATCH_EXCEPTION(0);
18621   }
18622
18623   jresult = (void *)result;
18624   return jresult;
18625 }
18626
18627
18628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
18629   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
18630
18631   arg1 = (Dali::FrameBuffer *)jarg1;
18632   {
18633     try {
18634       delete arg1;
18635     } CALL_CATCH_EXCEPTION();
18636   }
18637
18638 }
18639
18640
18641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
18642   void * jresult ;
18643   Dali::FrameBuffer *arg1 = 0 ;
18644   Dali::FrameBuffer *result = 0 ;
18645
18646   arg1 = (Dali::FrameBuffer *)jarg1;
18647   if (!arg1) {
18648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
18649     return 0;
18650   }
18651   {
18652     try {
18653       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
18654     } CALL_CATCH_EXCEPTION(0);
18655   }
18656
18657   jresult = (void *)result;
18658   return jresult;
18659 }
18660
18661
18662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
18663   void * jresult ;
18664   Dali::BaseHandle arg1 ;
18665   Dali::BaseHandle *argp1 ;
18666   Dali::FrameBuffer result;
18667
18668   argp1 = (Dali::BaseHandle *)jarg1;
18669   if (!argp1) {
18670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
18671     return 0;
18672   }
18673   arg1 = *argp1;
18674   {
18675     try {
18676       result = Dali::FrameBuffer::DownCast(arg1);
18677     } CALL_CATCH_EXCEPTION(0);
18678   }
18679
18680   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
18681   return jresult;
18682 }
18683
18684
18685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
18686   void * jresult ;
18687   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
18688   Dali::FrameBuffer *arg2 = 0 ;
18689   Dali::FrameBuffer *result = 0 ;
18690
18691   arg1 = (Dali::FrameBuffer *)jarg1;
18692   arg2 = (Dali::FrameBuffer *)jarg2;
18693   if (!arg2) {
18694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
18695     return 0;
18696   }
18697   {
18698     try {
18699       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
18700     } CALL_CATCH_EXCEPTION(0);
18701   }
18702
18703   jresult = (void *)result;
18704   return jresult;
18705 }
18706
18707
18708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
18709   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
18710   Dali::Texture *arg2 = 0 ;
18711
18712   arg1 = (Dali::FrameBuffer *)jarg1;
18713   arg2 = (Dali::Texture *)jarg2;
18714   if (!arg2) {
18715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
18716     return ;
18717   }
18718   {
18719     try {
18720       (arg1)->AttachColorTexture(*arg2);
18721     } CALL_CATCH_EXCEPTION();
18722   }
18723
18724 }
18725
18726
18727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
18728   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
18729   Dali::Texture *arg2 = 0 ;
18730   unsigned int arg3 ;
18731   unsigned int arg4 ;
18732
18733   arg1 = (Dali::FrameBuffer *)jarg1;
18734   arg2 = (Dali::Texture *)jarg2;
18735   if (!arg2) {
18736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
18737     return ;
18738   }
18739   arg3 = (unsigned int)jarg3;
18740   arg4 = (unsigned int)jarg4;
18741   {
18742     try {
18743       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
18744     } CALL_CATCH_EXCEPTION();
18745   }
18746
18747 }
18748
18749
18750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
18751   void * jresult ;
18752   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
18753   Dali::Texture result;
18754
18755   arg1 = (Dali::FrameBuffer *)jarg1;
18756   {
18757     try {
18758       result = (arg1)->GetColorTexture();
18759     } CALL_CATCH_EXCEPTION(0);
18760   }
18761
18762   jresult = new Dali::Texture((const Dali::Texture &)result);
18763   return jresult;
18764 }
18765
18766 SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_FrameBuffer_GenerateUrl(void *jFrameBuffer, int pixelFormat, int width, int height)
18767 {
18768   void *jresult;
18769   Dali::Toolkit::ImageUrl result;
18770   Dali::FrameBuffer *frameBuffer = (Dali::FrameBuffer*)jFrameBuffer;;
18771
18772   if (!frameBuffer)
18773   {
18774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer is null", 0);
18775     return 0;
18776   }
18777   {
18778     try
18779     {
18780       result = Dali::Toolkit::Image::GenerateUrl((const Dali::FrameBuffer&)*frameBuffer, (Pixel::Format)pixelFormat, (uint32_t)width, (uint32_t)height);
18781     }
18782     CALL_CATCH_EXCEPTION(0);
18783   }
18784
18785   jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl &)result);
18786   return jresult;
18787 }
18788
18789
18790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
18791   void * jresult ;
18792   Dali::RenderTaskList *result = 0 ;
18793
18794   {
18795     try {
18796       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
18797     } CALL_CATCH_EXCEPTION(0);
18798   }
18799
18800   jresult = (void *)result;
18801   return jresult;
18802 }
18803
18804
18805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
18806   void * jresult ;
18807   Dali::BaseHandle arg1 ;
18808   Dali::BaseHandle *argp1 ;
18809   Dali::RenderTaskList result;
18810
18811   argp1 = (Dali::BaseHandle *)jarg1;
18812   if (!argp1) {
18813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
18814     return 0;
18815   }
18816   arg1 = *argp1;
18817   {
18818     try {
18819       result = Dali::RenderTaskList::DownCast(arg1);
18820     } CALL_CATCH_EXCEPTION(0);
18821   }
18822
18823   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
18824   return jresult;
18825 }
18826
18827
18828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
18829   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
18830
18831   arg1 = (Dali::RenderTaskList *)jarg1;
18832   {
18833     try {
18834       delete arg1;
18835     } CALL_CATCH_EXCEPTION();
18836   }
18837
18838 }
18839
18840
18841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
18842   void * jresult ;
18843   Dali::RenderTaskList *arg1 = 0 ;
18844   Dali::RenderTaskList *result = 0 ;
18845
18846   arg1 = (Dali::RenderTaskList *)jarg1;
18847   if (!arg1) {
18848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
18849     return 0;
18850   }
18851   {
18852     try {
18853       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
18854     } CALL_CATCH_EXCEPTION(0);
18855   }
18856
18857   jresult = (void *)result;
18858   return jresult;
18859 }
18860
18861
18862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
18863   void * jresult ;
18864   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
18865   Dali::RenderTaskList *arg2 = 0 ;
18866   Dali::RenderTaskList *result = 0 ;
18867
18868   arg1 = (Dali::RenderTaskList *)jarg1;
18869   arg2 = (Dali::RenderTaskList *)jarg2;
18870   if (!arg2) {
18871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
18872     return 0;
18873   }
18874   {
18875     try {
18876       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
18877     } CALL_CATCH_EXCEPTION(0);
18878   }
18879
18880   jresult = (void *)result;
18881   return jresult;
18882 }
18883
18884
18885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
18886   void * jresult ;
18887   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
18888   Dali::RenderTask result;
18889
18890   arg1 = (Dali::RenderTaskList *)jarg1;
18891   {
18892     try {
18893       result = (arg1)->CreateTask();
18894     } CALL_CATCH_EXCEPTION(0);
18895   }
18896
18897   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
18898   return jresult;
18899 }
18900
18901
18902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
18903   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
18904   Dali::RenderTask arg2 ;
18905   Dali::RenderTask *argp2 ;
18906
18907   arg1 = (Dali::RenderTaskList *)jarg1;
18908   argp2 = (Dali::RenderTask *)jarg2;
18909   if (!argp2) {
18910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
18911     return ;
18912   }
18913   arg2 = *argp2;
18914   {
18915     try {
18916       (arg1)->RemoveTask(arg2);
18917     } CALL_CATCH_EXCEPTION();
18918   }
18919
18920 }
18921
18922
18923 //// ===============================================end part 1 =================
18924
18925 //// ========================= part 2 ===============================
18926
18927 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
18928   unsigned int jresult ;
18929   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
18930   unsigned int result;
18931
18932   arg1 = (Dali::RenderTaskList *)jarg1;
18933   {
18934     try {
18935       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
18936     } CALL_CATCH_EXCEPTION(0);
18937   }
18938
18939   jresult = result;
18940   return jresult;
18941 }
18942
18943
18944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
18945   void * jresult ;
18946   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
18947   unsigned int arg2 ;
18948   Dali::RenderTask result;
18949
18950   arg1 = (Dali::RenderTaskList *)jarg1;
18951   arg2 = (unsigned int)jarg2;
18952   {
18953     try {
18954       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
18955     } CALL_CATCH_EXCEPTION(0);
18956   }
18957
18958   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
18959   return jresult;
18960 }
18961
18962
18963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
18964   int jresult ;
18965   int result;
18966
18967   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
18968   jresult = (int)result;
18969   return jresult;
18970 }
18971
18972
18973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
18974   int jresult ;
18975   int result;
18976
18977   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
18978   jresult = (int)result;
18979   return jresult;
18980 }
18981
18982
18983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
18984   int jresult ;
18985   int result;
18986
18987   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
18988   jresult = (int)result;
18989   return jresult;
18990 }
18991
18992
18993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
18994   int jresult ;
18995   int result;
18996
18997   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
18998   jresult = (int)result;
18999   return jresult;
19000 }
19001
19002
19003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
19004   void * jresult ;
19005   Dali::RenderTask::Property *result = 0 ;
19006
19007   {
19008     try {
19009       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
19010     } CALL_CATCH_EXCEPTION(0);
19011   }
19012
19013   jresult = (void *)result;
19014   return jresult;
19015 }
19016
19017
19018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
19019   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
19020
19021   arg1 = (Dali::RenderTask::Property *)jarg1;
19022   {
19023     try {
19024       delete arg1;
19025     } CALL_CATCH_EXCEPTION();
19026   }
19027
19028 }
19029
19030
19031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
19032   void * jresult ;
19033   bool (*result)(Dali::Vector2 &) = 0 ;
19034
19035   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
19036   jresult = (void *)result;
19037   return jresult;
19038 }
19039
19040
19041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
19042   void * jresult ;
19043   bool (*result)(Dali::Vector2 &) = 0 ;
19044
19045   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
19046   jresult = (void *)result;
19047   return jresult;
19048 }
19049
19050
19051 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
19052   bool jresult ;
19053   bool result;
19054
19055   result = (bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
19056   jresult = result;
19057   return jresult;
19058 }
19059
19060
19061 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
19062   bool jresult ;
19063   bool result;
19064
19065   result = (bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
19066   jresult = result;
19067   return jresult;
19068 }
19069
19070
19071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
19072   void * jresult ;
19073   Dali::Vector4 *result = 0 ;
19074
19075   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
19076   jresult = (void *)result;
19077   return jresult;
19078 }
19079
19080
19081 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
19082   bool jresult ;
19083   bool result;
19084
19085   result = (bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
19086   jresult = result;
19087   return jresult;
19088 }
19089
19090
19091 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
19092   bool jresult ;
19093   bool result;
19094
19095   result = (bool)Dali::RenderTask::DEFAULT_CULL_MODE;
19096   jresult = result;
19097   return jresult;
19098 }
19099
19100
19101 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
19102   unsigned int jresult ;
19103   unsigned int result;
19104
19105   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
19106   jresult = result;
19107   return jresult;
19108 }
19109
19110
19111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
19112   void * jresult ;
19113   Dali::RenderTask *result = 0 ;
19114
19115   {
19116     try {
19117       result = (Dali::RenderTask *)new Dali::RenderTask();
19118     } CALL_CATCH_EXCEPTION(0);
19119   }
19120
19121   jresult = (void *)result;
19122   return jresult;
19123 }
19124
19125
19126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
19127   void * jresult ;
19128   Dali::BaseHandle arg1 ;
19129   Dali::BaseHandle *argp1 ;
19130   Dali::RenderTask result;
19131
19132   argp1 = (Dali::BaseHandle *)jarg1;
19133   if (!argp1) {
19134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19135     return 0;
19136   }
19137   arg1 = *argp1;
19138   {
19139     try {
19140       result = Dali::RenderTask::DownCast(arg1);
19141     } CALL_CATCH_EXCEPTION(0);
19142   }
19143
19144   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
19145   return jresult;
19146 }
19147
19148
19149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
19150   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19151
19152   arg1 = (Dali::RenderTask *)jarg1;
19153   {
19154     try {
19155       delete arg1;
19156     } CALL_CATCH_EXCEPTION();
19157   }
19158
19159 }
19160
19161
19162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
19163   void * jresult ;
19164   Dali::RenderTask *arg1 = 0 ;
19165   Dali::RenderTask *result = 0 ;
19166
19167   arg1 = (Dali::RenderTask *)jarg1;
19168   if (!arg1) {
19169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
19170     return 0;
19171   }
19172   {
19173     try {
19174       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
19175     } CALL_CATCH_EXCEPTION(0);
19176   }
19177
19178   jresult = (void *)result;
19179   return jresult;
19180 }
19181
19182
19183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
19184   void * jresult ;
19185   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19186   Dali::RenderTask *arg2 = 0 ;
19187   Dali::RenderTask *result = 0 ;
19188
19189   arg1 = (Dali::RenderTask *)jarg1;
19190   arg2 = (Dali::RenderTask *)jarg2;
19191   if (!arg2) {
19192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
19193     return 0;
19194   }
19195   {
19196     try {
19197       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
19198     } CALL_CATCH_EXCEPTION(0);
19199   }
19200
19201   jresult = (void *)result;
19202   return jresult;
19203 }
19204
19205
19206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
19207   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19208   Dali::Actor arg2 ;
19209   Dali::Actor *argp2 ;
19210
19211   arg1 = (Dali::RenderTask *)jarg1;
19212   argp2 = (Dali::Actor *)jarg2;
19213   if (!argp2) {
19214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
19215     return ;
19216   }
19217   arg2 = *argp2;
19218   {
19219     try {
19220       (arg1)->SetSourceActor(arg2);
19221     } CALL_CATCH_EXCEPTION();
19222   }
19223
19224 }
19225
19226
19227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
19228   void * jresult ;
19229   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19230   Dali::Actor result;
19231
19232   arg1 = (Dali::RenderTask *)jarg1;
19233   {
19234     try {
19235       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
19236     } CALL_CATCH_EXCEPTION(0);
19237   }
19238
19239   jresult = new Dali::Actor((const Dali::Actor &)result);
19240   return jresult;
19241 }
19242
19243
19244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, bool jarg2) {
19245   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19246   bool arg2 ;
19247
19248   arg1 = (Dali::RenderTask *)jarg1;
19249   arg2 = jarg2 ? true : false;
19250   {
19251     try {
19252       (arg1)->SetExclusive(arg2);
19253     } CALL_CATCH_EXCEPTION();
19254   }
19255
19256 }
19257
19258
19259 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
19260   bool jresult ;
19261   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19262   bool result;
19263
19264   arg1 = (Dali::RenderTask *)jarg1;
19265   {
19266     try {
19267       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
19268     } CALL_CATCH_EXCEPTION(0);
19269   }
19270
19271   jresult = result;
19272   return jresult;
19273 }
19274
19275
19276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, bool jarg2) {
19277   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19278   bool arg2 ;
19279
19280   arg1 = (Dali::RenderTask *)jarg1;
19281   arg2 = jarg2 ? true : false;
19282   {
19283     try {
19284       (arg1)->SetInputEnabled(arg2);
19285     } CALL_CATCH_EXCEPTION();
19286   }
19287
19288 }
19289
19290
19291 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
19292   bool jresult ;
19293   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19294   bool result;
19295
19296   arg1 = (Dali::RenderTask *)jarg1;
19297   {
19298     try {
19299       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
19300     } CALL_CATCH_EXCEPTION(0);
19301   }
19302
19303   jresult = result;
19304   return jresult;
19305 }
19306
19307
19308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
19309   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19310   Dali::CameraActor arg2 ;
19311   Dali::CameraActor *argp2 ;
19312
19313   arg1 = (Dali::RenderTask *)jarg1;
19314   argp2 = (Dali::CameraActor *)jarg2;
19315   if (!argp2) {
19316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
19317     return ;
19318   }
19319   arg2 = *argp2;
19320   {
19321     try {
19322       (arg1)->SetCameraActor(arg2);
19323     } CALL_CATCH_EXCEPTION();
19324   }
19325
19326 }
19327
19328
19329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
19330   void * jresult ;
19331   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19332   Dali::CameraActor result;
19333
19334   arg1 = (Dali::RenderTask *)jarg1;
19335   {
19336     try {
19337       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
19338     } CALL_CATCH_EXCEPTION(0);
19339   }
19340
19341   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
19342   return jresult;
19343 }
19344
19345
19346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
19347   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19348   Dali::FrameBuffer arg2 ;
19349   Dali::FrameBuffer *argp2 ;
19350
19351   arg1 = (Dali::RenderTask *)jarg1;
19352   argp2 = (Dali::FrameBuffer *)jarg2;
19353   if (!argp2) {
19354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
19355     return ;
19356   }
19357   arg2 = *argp2;
19358   {
19359     try {
19360       (arg1)->SetFrameBuffer(arg2);
19361     } CALL_CATCH_EXCEPTION();
19362   }
19363
19364 }
19365
19366
19367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
19368   void * jresult ;
19369   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19370   Dali::FrameBuffer result;
19371
19372   arg1 = (Dali::RenderTask *)jarg1;
19373   {
19374     try {
19375       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
19376     } CALL_CATCH_EXCEPTION(0);
19377   }
19378
19379   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
19380   return jresult;
19381 }
19382
19383
19384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
19385   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19386   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
19387
19388   arg1 = (Dali::RenderTask *)jarg1;
19389   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
19390   {
19391     try {
19392       (arg1)->SetScreenToFrameBufferFunction(arg2);
19393     } CALL_CATCH_EXCEPTION();
19394   }
19395
19396 }
19397
19398
19399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
19400   void * jresult ;
19401   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19402   Dali::RenderTask::ScreenToFrameBufferFunction result;
19403
19404   arg1 = (Dali::RenderTask *)jarg1;
19405   {
19406     try {
19407       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
19408     } CALL_CATCH_EXCEPTION(0);
19409   }
19410
19411   jresult = (void *)result;
19412   return jresult;
19413 }
19414
19415
19416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
19417   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19418   Dali::Actor arg2 ;
19419   Dali::Actor *argp2 ;
19420
19421   arg1 = (Dali::RenderTask *)jarg1;
19422   argp2 = (Dali::Actor *)jarg2;
19423   if (!argp2) {
19424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
19425     return ;
19426   }
19427   arg2 = *argp2;
19428   {
19429     try {
19430       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
19431     } CALL_CATCH_EXCEPTION();
19432   }
19433
19434 }
19435
19436
19437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
19438   void * jresult ;
19439   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19440   Dali::Actor result;
19441
19442   arg1 = (Dali::RenderTask *)jarg1;
19443   {
19444     try {
19445       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
19446     } CALL_CATCH_EXCEPTION(0);
19447   }
19448
19449   jresult = new Dali::Actor((const Dali::Actor &)result);
19450   return jresult;
19451 }
19452
19453
19454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
19455   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19456   Dali::Vector2 arg2 ;
19457   Dali::Vector2 *argp2 ;
19458
19459   arg1 = (Dali::RenderTask *)jarg1;
19460   argp2 = (Dali::Vector2 *)jarg2;
19461   if (!argp2) {
19462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
19463     return ;
19464   }
19465   arg2 = *argp2;
19466   {
19467     try {
19468       (arg1)->SetViewportPosition(arg2);
19469     } CALL_CATCH_EXCEPTION();
19470   }
19471
19472 }
19473
19474
19475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
19476   void * jresult ;
19477   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19478   Dali::Vector2 result;
19479
19480   arg1 = (Dali::RenderTask *)jarg1;
19481   {
19482     try {
19483       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
19484     } CALL_CATCH_EXCEPTION(0);
19485   }
19486
19487   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
19488   return jresult;
19489 }
19490
19491
19492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
19493   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19494   Dali::Vector2 arg2 ;
19495   Dali::Vector2 *argp2 ;
19496
19497   arg1 = (Dali::RenderTask *)jarg1;
19498   argp2 = (Dali::Vector2 *)jarg2;
19499   if (!argp2) {
19500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
19501     return ;
19502   }
19503   arg2 = *argp2;
19504   {
19505     try {
19506       (arg1)->SetViewportSize(arg2);
19507     } CALL_CATCH_EXCEPTION();
19508   }
19509
19510 }
19511
19512
19513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
19514   void * jresult ;
19515   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19516   Dali::Vector2 result;
19517
19518   arg1 = (Dali::RenderTask *)jarg1;
19519   {
19520     try {
19521       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
19522     } CALL_CATCH_EXCEPTION(0);
19523   }
19524
19525   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
19526   return jresult;
19527 }
19528
19529
19530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
19531   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19532   Dali::Viewport arg2 ;
19533   Dali::Viewport *argp2 ;
19534
19535   arg1 = (Dali::RenderTask *)jarg1;
19536   argp2 = (Dali::Viewport *)jarg2;
19537   if (!argp2) {
19538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
19539     return ;
19540   }
19541   arg2 = *argp2;
19542   {
19543     try {
19544       (arg1)->SetViewport(arg2);
19545     } CALL_CATCH_EXCEPTION();
19546   }
19547
19548 }
19549
19550
19551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
19552   void * jresult ;
19553   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19554   Dali::Viewport result;
19555
19556   arg1 = (Dali::RenderTask *)jarg1;
19557   {
19558     try {
19559       result = ((Dali::RenderTask const *)arg1)->GetViewport();
19560     } CALL_CATCH_EXCEPTION(0);
19561   }
19562
19563   jresult = new Dali::Viewport((const Dali::Viewport &)result);
19564   return jresult;
19565 }
19566
19567
19568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
19569   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19570   Dali::Vector4 *arg2 = 0 ;
19571
19572   arg1 = (Dali::RenderTask *)jarg1;
19573   arg2 = (Dali::Vector4 *)jarg2;
19574   if (!arg2) {
19575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
19576     return ;
19577   }
19578   {
19579     try {
19580       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
19581     } CALL_CATCH_EXCEPTION();
19582   }
19583
19584 }
19585
19586
19587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
19588   void * jresult ;
19589   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19590   Dali::Vector4 result;
19591
19592   arg1 = (Dali::RenderTask *)jarg1;
19593   {
19594     try {
19595       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
19596     } CALL_CATCH_EXCEPTION(0);
19597   }
19598
19599   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
19600   return jresult;
19601 }
19602
19603
19604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, bool jarg2) {
19605   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19606   bool arg2 ;
19607
19608   arg1 = (Dali::RenderTask *)jarg1;
19609   arg2 = jarg2 ? true : false;
19610   {
19611     try {
19612       (arg1)->SetClearEnabled(arg2);
19613     } CALL_CATCH_EXCEPTION();
19614   }
19615
19616 }
19617
19618
19619 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
19620   bool jresult ;
19621   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19622   bool result;
19623
19624   arg1 = (Dali::RenderTask *)jarg1;
19625   {
19626     try {
19627       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
19628     } CALL_CATCH_EXCEPTION(0);
19629   }
19630
19631   jresult = result;
19632   return jresult;
19633 }
19634
19635
19636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, bool jarg2) {
19637   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19638   bool arg2 ;
19639
19640   arg1 = (Dali::RenderTask *)jarg1;
19641   arg2 = jarg2 ? true : false;
19642   {
19643     try {
19644       (arg1)->SetCullMode(arg2);
19645     } CALL_CATCH_EXCEPTION();
19646   }
19647
19648 }
19649
19650
19651 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
19652   bool jresult ;
19653   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19654   bool result;
19655
19656   arg1 = (Dali::RenderTask *)jarg1;
19657   {
19658     try {
19659       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
19660     } CALL_CATCH_EXCEPTION(0);
19661   }
19662
19663   jresult = result;
19664   return jresult;
19665 }
19666
19667
19668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
19669   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19670   unsigned int arg2 ;
19671
19672   arg1 = (Dali::RenderTask *)jarg1;
19673   arg2 = (unsigned int)jarg2;
19674   {
19675     try {
19676       (arg1)->SetRefreshRate(arg2);
19677     } CALL_CATCH_EXCEPTION();
19678   }
19679
19680 }
19681
19682
19683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
19684   unsigned int jresult ;
19685   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19686   unsigned int result;
19687
19688   arg1 = (Dali::RenderTask *)jarg1;
19689   {
19690     try {
19691       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
19692     } CALL_CATCH_EXCEPTION(0);
19693   }
19694
19695   jresult = result;
19696   return jresult;
19697 }
19698
19699
19700 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
19701   bool jresult ;
19702   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19703   Dali::Vector3 *arg2 = 0 ;
19704   float *arg3 = 0 ;
19705   float *arg4 = 0 ;
19706   bool result;
19707
19708   arg1 = (Dali::RenderTask *)jarg1;
19709   arg2 = (Dali::Vector3 *)jarg2;
19710   if (!arg2) {
19711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
19712     return 0;
19713   }
19714   arg3 = (float *)jarg3;
19715   arg4 = (float *)jarg4;
19716   {
19717     try {
19718       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
19719     } CALL_CATCH_EXCEPTION(0);
19720   }
19721
19722   jresult = result;
19723   return jresult;
19724 }
19725
19726
19727 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
19728   bool jresult ;
19729   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19730   Dali::Actor arg2 ;
19731   float arg3 ;
19732   float arg4 ;
19733   float *arg5 = 0 ;
19734   float *arg6 = 0 ;
19735   Dali::Actor *argp2 ;
19736   bool result;
19737
19738   arg1 = (Dali::RenderTask *)jarg1;
19739   argp2 = (Dali::Actor *)jarg2;
19740   if (!argp2) {
19741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
19742     return 0;
19743   }
19744   arg2 = *argp2;
19745   arg3 = (float)jarg3;
19746   arg4 = (float)jarg4;
19747   arg5 = (float *)jarg5;
19748   arg6 = (float *)jarg6;
19749   {
19750     try {
19751       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
19752     } CALL_CATCH_EXCEPTION(0);
19753   }
19754
19755   jresult = result;
19756   return jresult;
19757 }
19758
19759
19760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
19761   void * jresult ;
19762   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19763   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
19764
19765   arg1 = (Dali::RenderTask *)jarg1;
19766   {
19767     try {
19768       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
19769     } CALL_CATCH_EXCEPTION(0);
19770   }
19771
19772   jresult = (void *)result;
19773   return jresult;
19774 }
19775
19776
19777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
19778   void * jresult ;
19779   int arg1 ;
19780   Dali::PointState::Type arg2 ;
19781   float arg3 ;
19782   float arg4 ;
19783   Dali::TouchPoint *result = 0 ;
19784
19785   arg1 = (int)jarg1;
19786   arg2 = (Dali::PointState::Type)jarg2;
19787   arg3 = (float)jarg3;
19788   arg4 = (float)jarg4;
19789   {
19790     try {
19791       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
19792     } CALL_CATCH_EXCEPTION(0);
19793   }
19794
19795   jresult = (void *)result;
19796   return jresult;
19797 }
19798
19799
19800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
19801   void * jresult ;
19802   int arg1 ;
19803   Dali::PointState::Type arg2 ;
19804   float arg3 ;
19805   float arg4 ;
19806   float arg5 ;
19807   float arg6 ;
19808   Dali::TouchPoint *result = 0 ;
19809
19810   arg1 = (int)jarg1;
19811   arg2 = (Dali::PointState::Type)jarg2;
19812   arg3 = (float)jarg3;
19813   arg4 = (float)jarg4;
19814   arg5 = (float)jarg5;
19815   arg6 = (float)jarg6;
19816   {
19817     try {
19818       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
19819     } CALL_CATCH_EXCEPTION(0);
19820   }
19821
19822   jresult = (void *)result;
19823   return jresult;
19824 }
19825
19826
19827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
19828   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19829
19830   arg1 = (Dali::TouchPoint *)jarg1;
19831   {
19832     try {
19833       delete arg1;
19834     } CALL_CATCH_EXCEPTION();
19835   }
19836
19837 }
19838
19839
19840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
19841   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19842   int arg2 ;
19843
19844   arg1 = (Dali::TouchPoint *)jarg1;
19845   arg2 = (int)jarg2;
19846   if (arg1) (arg1)->deviceId = arg2;
19847 }
19848
19849
19850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
19851   int jresult ;
19852   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19853   int result;
19854
19855   arg1 = (Dali::TouchPoint *)jarg1;
19856   result = (int) ((arg1)->deviceId);
19857   jresult = result;
19858   return jresult;
19859 }
19860
19861
19862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
19863   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19864   Dali::PointState::Type arg2 ;
19865
19866   arg1 = (Dali::TouchPoint *)jarg1;
19867   arg2 = (Dali::PointState::Type)jarg2;
19868   if (arg1) (arg1)->state = arg2;
19869 }
19870
19871
19872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
19873   int jresult ;
19874   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19875   Dali::PointState::Type result;
19876
19877   arg1 = (Dali::TouchPoint *)jarg1;
19878   result = (Dali::PointState::Type) ((arg1)->state);
19879   jresult = (int)result;
19880   return jresult;
19881 }
19882
19883
19884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
19885   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19886   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
19887
19888   arg1 = (Dali::TouchPoint *)jarg1;
19889   arg2 = (Dali::Actor *)jarg2;
19890   if (arg1) (arg1)->hitActor = *arg2;
19891 }
19892
19893
19894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
19895   void * jresult ;
19896   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19897   Dali::Actor *result = 0 ;
19898
19899   arg1 = (Dali::TouchPoint *)jarg1;
19900   result = (Dali::Actor *)& ((arg1)->hitActor);
19901   jresult = (void *)result;
19902   return jresult;
19903 }
19904
19905
19906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
19907   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19908   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
19909
19910   arg1 = (Dali::TouchPoint *)jarg1;
19911   arg2 = (Dali::Vector2 *)jarg2;
19912   if (arg1) (arg1)->local = *arg2;
19913 }
19914
19915
19916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
19917   void * jresult ;
19918   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19919   Dali::Vector2 *result = 0 ;
19920
19921   arg1 = (Dali::TouchPoint *)jarg1;
19922   result = (Dali::Vector2 *)& ((arg1)->local);
19923   jresult = (void *)result;
19924   return jresult;
19925 }
19926
19927
19928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
19929   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19930   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
19931
19932   arg1 = (Dali::TouchPoint *)jarg1;
19933   arg2 = (Dali::Vector2 *)jarg2;
19934   if (arg1) (arg1)->screen = *arg2;
19935 }
19936
19937
19938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
19939   void * jresult ;
19940   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19941   Dali::Vector2 *result = 0 ;
19942
19943   arg1 = (Dali::TouchPoint *)jarg1;
19944   result = (Dali::Vector2 *)& ((arg1)->screen);
19945   jresult = (void *)result;
19946   return jresult;
19947 }
19948
19949
19950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
19951   void * jresult ;
19952   Dali::TouchEvent *result = 0 ;
19953
19954   {
19955     try {
19956       result = (Dali::TouchEvent *)new Dali::TouchEvent();
19957     } CALL_CATCH_EXCEPTION(0);
19958   }
19959
19960   jresult = (void *)result;
19961   return jresult;
19962 }
19963
19964
19965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
19966   void * jresult ;
19967   Dali::TouchEvent *arg1 = 0 ;
19968   Dali::TouchEvent *result = 0 ;
19969
19970   arg1 = (Dali::TouchEvent *)jarg1;
19971   if (!arg1) {
19972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
19973     return 0;
19974   }
19975   {
19976     try {
19977       result = (Dali::TouchEvent *)new Dali::TouchEvent((Dali::TouchEvent const &)*arg1);
19978     } CALL_CATCH_EXCEPTION(0);
19979   }
19980
19981   jresult = (void *)result;
19982   return jresult;
19983 }
19984
19985
19986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
19987   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19988
19989   arg1 = (Dali::TouchEvent *)jarg1;
19990   {
19991     try {
19992       delete arg1;
19993     } CALL_CATCH_EXCEPTION();
19994   }
19995
19996 }
19997
19998
19999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
20000   void * jresult ;
20001   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
20002   Dali::TouchEvent *arg2 = 0 ;
20003   Dali::TouchEvent *result = 0 ;
20004
20005   arg1 = (Dali::TouchEvent *)jarg1;
20006   arg2 = (Dali::TouchEvent *)jarg2;
20007   if (!arg2) {
20008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
20009     return 0;
20010   }
20011   {
20012     try {
20013       result = (Dali::TouchEvent *) &(arg1)->operator =((Dali::TouchEvent const &)*arg2);
20014     } CALL_CATCH_EXCEPTION(0);
20015   }
20016
20017   jresult = (void *)result;
20018   return jresult;
20019 }
20020
20021
20022 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
20023   unsigned long jresult ;
20024   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
20025   unsigned long result;
20026
20027   arg1 = (Dali::TouchEvent *)jarg1;
20028   {
20029     try {
20030       result = (unsigned long)((Dali::TouchEvent const *)arg1)->GetTime();
20031     } CALL_CATCH_EXCEPTION(0);
20032   }
20033
20034   jresult = (unsigned long)result;
20035   return jresult;
20036 }
20037
20038
20039 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
20040   unsigned long jresult ;
20041   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
20042   std::size_t result;
20043
20044   arg1 = (Dali::TouchEvent *)jarg1;
20045   {
20046     try {
20047       result = ((Dali::TouchEvent const *)arg1)->GetPointCount();
20048     } CALL_CATCH_EXCEPTION(0);
20049   }
20050
20051   jresult = (unsigned long)result;
20052   return jresult;
20053 }
20054
20055
20056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
20057   int jresult ;
20058   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
20059   std::size_t arg2 ;
20060   int32_t result;
20061
20062   arg1 = (Dali::TouchEvent *)jarg1;
20063   arg2 = (std::size_t)jarg2;
20064   {
20065     try {
20066       result = ((Dali::TouchEvent const *)arg1)->GetDeviceId(arg2);
20067     } CALL_CATCH_EXCEPTION(0);
20068   }
20069
20070   jresult = result;
20071   return jresult;
20072 }
20073
20074
20075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
20076   int jresult ;
20077   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
20078   std::size_t arg2 ;
20079   Dali::PointState::Type result;
20080
20081   arg1 = (Dali::TouchEvent *)jarg1;
20082   arg2 = (std::size_t)jarg2;
20083   {
20084     try {
20085       result = (Dali::PointState::Type)((Dali::TouchEvent const *)arg1)->GetState(arg2);
20086     } CALL_CATCH_EXCEPTION(0);
20087   }
20088
20089   jresult = (int)result;
20090   return jresult;
20091 }
20092
20093
20094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
20095   void * jresult ;
20096   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
20097   std::size_t arg2 ;
20098   Dali::Actor result;
20099
20100   arg1 = (Dali::TouchEvent *)jarg1;
20101   arg2 = (std::size_t)jarg2;
20102   {
20103     try {
20104       result = ((Dali::TouchEvent const *)arg1)->GetHitActor(arg2);
20105     } CALL_CATCH_EXCEPTION(0);
20106   }
20107
20108   jresult = new Dali::Actor((const Dali::Actor &)result);
20109   return jresult;
20110 }
20111
20112
20113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
20114   void * jresult ;
20115   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
20116   std::size_t arg2 ;
20117   Dali::Vector2 *result = 0 ;
20118
20119   arg1 = (Dali::TouchEvent *)jarg1;
20120   arg2 = (std::size_t)jarg2;
20121   {
20122     try {
20123       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetLocalPosition(arg2);
20124     } CALL_CATCH_EXCEPTION(0);
20125   }
20126
20127   jresult = (void *)result;
20128   return jresult;
20129 }
20130
20131
20132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
20133   void * jresult ;
20134   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
20135   std::size_t arg2 ;
20136   Dali::Vector2 *result = 0 ;
20137
20138   arg1 = (Dali::TouchEvent *)jarg1;
20139   arg2 = (std::size_t)jarg2;
20140   {
20141     try {
20142       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetScreenPosition(arg2);
20143     } CALL_CATCH_EXCEPTION(0);
20144   }
20145
20146   jresult = (void *)result;
20147   return jresult;
20148 }
20149
20150
20151 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
20152   float jresult ;
20153   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
20154   std::size_t arg2 ;
20155   float result;
20156
20157   arg1 = (Dali::TouchEvent *)jarg1;
20158   arg2 = (std::size_t)jarg2;
20159   {
20160     try {
20161       result = (float)((Dali::TouchEvent const *)arg1)->GetRadius(arg2);
20162     } CALL_CATCH_EXCEPTION(0);
20163   }
20164
20165   jresult = result;
20166   return jresult;
20167 }
20168
20169
20170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
20171   void * jresult ;
20172   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
20173   std::size_t arg2 ;
20174   Dali::Vector2 *result = 0 ;
20175
20176   arg1 = (Dali::TouchEvent *)jarg1;
20177   arg2 = (std::size_t)jarg2;
20178   {
20179     try {
20180       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetEllipseRadius(arg2);
20181     } CALL_CATCH_EXCEPTION(0);
20182   }
20183
20184   jresult = (void *)result;
20185   return jresult;
20186 }
20187
20188
20189 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
20190   float jresult ;
20191   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
20192   std::size_t arg2 ;
20193   float result;
20194
20195   arg1 = (Dali::TouchEvent *)jarg1;
20196   arg2 = (std::size_t)jarg2;
20197   {
20198     try {
20199       result = (float)((Dali::TouchEvent const *)arg1)->GetPressure(arg2);
20200     } CALL_CATCH_EXCEPTION(0);
20201   }
20202
20203   jresult = result;
20204   return jresult;
20205 }
20206
20207
20208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
20209   void * jresult ;
20210   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
20211   std::size_t arg2 ;
20212   Dali::Degree result;
20213
20214   arg1 = (Dali::TouchEvent *)jarg1;
20215   arg2 = (std::size_t)jarg2;
20216   {
20217     try {
20218       result = ((Dali::TouchEvent const *)arg1)->GetAngle(arg2);
20219     } CALL_CATCH_EXCEPTION(0);
20220   }
20221
20222   jresult = new Dali::Degree((const Dali::Degree &)result);
20223   return jresult;
20224 }
20225
20226
20227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceClass(void * jarg1, unsigned long jarg2) {
20228   int jresult ;
20229   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
20230   std::size_t arg2 ;
20231   Dali::Device::Class::Type result;
20232
20233   arg1 = (Dali::TouchEvent *)jarg1;
20234   arg2 = (std::size_t)jarg2;
20235   {
20236     try {
20237       result = ((Dali::TouchEvent const *)arg1)->GetDeviceClass(arg2);
20238     } CALL_CATCH_EXCEPTION(0);
20239   }
20240
20241   jresult = (int)result;
20242   return jresult;
20243 }
20244
20245
20246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceSubclass(void * jarg1, unsigned long jarg2) {
20247   int jresult ;
20248   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
20249   std::size_t arg2 ;
20250   Dali::Device::Subclass::Type result;
20251
20252   arg1 = (Dali::TouchEvent *)jarg1;
20253   arg2 = (std::size_t)jarg2;
20254   {
20255     try {
20256       result = ((Dali::TouchEvent const *)arg1)->GetDeviceSubclass(arg2);
20257     } CALL_CATCH_EXCEPTION(0);
20258   }
20259
20260   jresult = (int)result;
20261   return jresult;
20262 }
20263
20264
20265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
20266   int jresult ;
20267   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
20268   std::size_t arg2 ;
20269   Dali::MouseButton::Type result;
20270
20271   arg1 = (Dali::TouchEvent *)jarg1;
20272   arg2 = (std::size_t)jarg2;
20273   {
20274     try {
20275       result = ((Dali::TouchEvent const *)arg1)->GetMouseButton(arg2);
20276     } CALL_CATCH_EXCEPTION(0);
20277   }
20278
20279   jresult = static_cast< int >(result);
20280   return jresult;
20281 }
20282
20283
20284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
20285   void * jresult ;
20286   Dali::GestureDetector *result = 0 ;
20287
20288   {
20289     try {
20290       result = (Dali::GestureDetector *)new Dali::GestureDetector();
20291     } CALL_CATCH_EXCEPTION(0);
20292   }
20293
20294   jresult = (void *)result;
20295   return jresult;
20296 }
20297
20298
20299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
20300   void * jresult ;
20301   Dali::BaseHandle arg1 ;
20302   Dali::BaseHandle *argp1 ;
20303   Dali::GestureDetector result;
20304
20305   argp1 = (Dali::BaseHandle *)jarg1;
20306   if (!argp1) {
20307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20308     return 0;
20309   }
20310   arg1 = *argp1;
20311   {
20312     try {
20313       result = Dali::GestureDetector::DownCast(arg1);
20314     } CALL_CATCH_EXCEPTION(0);
20315   }
20316
20317   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
20318   return jresult;
20319 }
20320
20321
20322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
20323   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
20324
20325   arg1 = (Dali::GestureDetector *)jarg1;
20326   {
20327     try {
20328       delete arg1;
20329     } CALL_CATCH_EXCEPTION();
20330   }
20331
20332 }
20333
20334
20335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
20336   void * jresult ;
20337   Dali::GestureDetector *arg1 = 0 ;
20338   Dali::GestureDetector *result = 0 ;
20339
20340   arg1 = (Dali::GestureDetector *)jarg1;
20341   if (!arg1) {
20342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
20343     return 0;
20344   }
20345   {
20346     try {
20347       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
20348     } CALL_CATCH_EXCEPTION(0);
20349   }
20350
20351   jresult = (void *)result;
20352   return jresult;
20353 }
20354
20355
20356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
20357   void * jresult ;
20358   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
20359   Dali::GestureDetector *arg2 = 0 ;
20360   Dali::GestureDetector *result = 0 ;
20361
20362   arg1 = (Dali::GestureDetector *)jarg1;
20363   arg2 = (Dali::GestureDetector *)jarg2;
20364   if (!arg2) {
20365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
20366     return 0;
20367   }
20368   {
20369     try {
20370       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
20371     } CALL_CATCH_EXCEPTION(0);
20372   }
20373
20374   jresult = (void *)result;
20375   return jresult;
20376 }
20377
20378
20379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
20380   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
20381   Dali::Actor arg2 ;
20382   Dali::Actor *argp2 ;
20383
20384   arg1 = (Dali::GestureDetector *)jarg1;
20385   argp2 = (Dali::Actor *)jarg2;
20386   if (!argp2) {
20387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20388     return ;
20389   }
20390   arg2 = *argp2;
20391   {
20392     try {
20393       (arg1)->Attach(arg2);
20394     } CALL_CATCH_EXCEPTION();
20395   }
20396
20397 }
20398
20399
20400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
20401   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
20402   Dali::Actor arg2 ;
20403   Dali::Actor *argp2 ;
20404
20405   arg1 = (Dali::GestureDetector *)jarg1;
20406   argp2 = (Dali::Actor *)jarg2;
20407   if (!argp2) {
20408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20409     return ;
20410   }
20411   arg2 = *argp2;
20412   {
20413     try {
20414       (arg1)->Detach(arg2);
20415     } CALL_CATCH_EXCEPTION();
20416   }
20417
20418 }
20419
20420
20421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
20422   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
20423
20424   arg1 = (Dali::GestureDetector *)jarg1;
20425   {
20426     try {
20427       (arg1)->DetachAll();
20428     } CALL_CATCH_EXCEPTION();
20429   }
20430
20431 }
20432
20433
20434 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
20435   unsigned long jresult ;
20436   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
20437   size_t result;
20438
20439   arg1 = (Dali::GestureDetector *)jarg1;
20440   {
20441     try {
20442       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
20443     } CALL_CATCH_EXCEPTION(0);
20444   }
20445
20446   jresult = (unsigned long)result;
20447   return jresult;
20448 }
20449
20450
20451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
20452   void * jresult ;
20453   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
20454   size_t arg2 ;
20455   Dali::Actor result;
20456
20457   arg1 = (Dali::GestureDetector *)jarg1;
20458   arg2 = (size_t)jarg2;
20459   {
20460     try {
20461       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
20462     } CALL_CATCH_EXCEPTION(0);
20463   }
20464
20465   jresult = new Dali::Actor((const Dali::Actor &)result);
20466   return jresult;
20467 }
20468
20469
20470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
20471   void * jresult ;
20472   Dali::Gesture *arg1 = 0 ;
20473   Dali::Gesture *result = 0 ;
20474
20475   arg1 = (Dali::Gesture *)jarg1;
20476   if (!arg1) {
20477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
20478     return 0;
20479   }
20480   {
20481     try {
20482       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
20483     } CALL_CATCH_EXCEPTION(0);
20484   }
20485
20486   jresult = (void *)result;
20487   return jresult;
20488 }
20489
20490
20491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
20492   void * jresult ;
20493   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
20494   Dali::Gesture *arg2 = 0 ;
20495   Dali::Gesture *result = 0 ;
20496
20497   arg1 = (Dali::Gesture *)jarg1;
20498   arg2 = (Dali::Gesture *)jarg2;
20499   if (!arg2) {
20500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
20501     return 0;
20502   }
20503   {
20504     try {
20505       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
20506     } CALL_CATCH_EXCEPTION(0);
20507   }
20508
20509   jresult = (void *)result;
20510   return jresult;
20511 }
20512
20513
20514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
20515   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
20516
20517   arg1 = (Dali::Gesture *)jarg1;
20518   {
20519     try {
20520       delete arg1;
20521     } CALL_CATCH_EXCEPTION();
20522   }
20523
20524 }
20525
20526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
20527   int jresult ;
20528   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
20529   Dali::GestureType::Value result;
20530
20531   arg1 = (Dali::Gesture *)jarg1;
20532   result = (Dali::GestureType::Value) ((arg1)->GetType());
20533   jresult = (int)result;
20534   return jresult;
20535 }
20536
20537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
20538   int jresult ;
20539   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
20540   Dali::GestureState result;
20541
20542   arg1 = (Dali::Gesture *)jarg1;
20543   result = (Dali::GestureState) ((arg1)->GetState());
20544   jresult = (int)result;
20545   return jresult;
20546 }
20547
20548 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
20549   unsigned int jresult ;
20550   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
20551   unsigned int result;
20552
20553   arg1 = (Dali::Gesture *)jarg1;
20554   result = (unsigned int) ((arg1)->GetTime());
20555   jresult = result;
20556   return jresult;
20557 }
20558
20559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_sourceType_get(void * gesture) {
20560   int jresult ;
20561   Dali::Gesture *jGesture = (Dali::Gesture *) gesture;
20562   Dali::GestureSourceType result;
20563
20564   if (!jGesture) {
20565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
20566     return 0;
20567   }
20568   {
20569     try {
20570       result = (Dali::GestureSourceType)jGesture->GetSourceType();
20571     } CALL_CATCH_EXCEPTION(0);
20572   }
20573
20574   jresult = (int)result;
20575   return jresult;
20576 }
20577
20578
20579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_sourceData_get(void * gesture) {
20580   int jresult ;
20581   Dali::Gesture *jGesture = (Dali::Gesture *) gesture;
20582   Dali::GestureSourceData result;
20583
20584   if (!jGesture) {
20585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::gesture const & type is null", 0);
20586     return 0;
20587   }
20588   {
20589     try {
20590       result = (Dali::GestureSourceData)jGesture->GetSourceData();
20591     } CALL_CATCH_EXCEPTION(0);
20592   }
20593
20594   jresult = (int)result;
20595   return jresult;
20596 }
20597
20598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
20599   void * jresult ;
20600   Dali::HoverEvent *result = 0 ;
20601
20602   {
20603     try {
20604       result = (Dali::HoverEvent *)new Dali::HoverEvent();
20605     } CALL_CATCH_EXCEPTION(0);
20606   }
20607
20608   jresult = (void *)result;
20609   return jresult;
20610 }
20611
20612
20613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(void * jarg1) {
20614   void * jresult ;
20615   Dali::HoverEvent *arg1 = 0 ;
20616   Dali::HoverEvent *result = 0 ;
20617
20618   arg1 = (Dali::HoverEvent *)jarg1;
20619   if (!arg1) {
20620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
20621     return 0;
20622   }
20623   {
20624     try {
20625       result = (Dali::HoverEvent *)new Dali::HoverEvent((Dali::HoverEvent const &)*arg1);
20626     } CALL_CATCH_EXCEPTION(0);
20627   }
20628
20629   jresult = (void *)result;
20630   return jresult;
20631 }
20632
20633
20634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
20635   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20636
20637   arg1 = (Dali::HoverEvent *)jarg1;
20638   {
20639     try {
20640       delete arg1;
20641     } CALL_CATCH_EXCEPTION();
20642   }
20643
20644 }
20645
20646
20647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_Assign(void * jarg1, void * jarg2) {
20648   void * jresult ;
20649   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20650   Dali::HoverEvent *arg2 = 0 ;
20651   Dali::HoverEvent *result = 0 ;
20652
20653   arg1 = (Dali::HoverEvent *)jarg1;
20654   arg2 = (Dali::HoverEvent *)jarg2;
20655   if (!arg2) {
20656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
20657     return 0;
20658   }
20659   {
20660     try {
20661       result = (Dali::HoverEvent *) &(arg1)->operator =((Dali::HoverEvent const &)*arg2);
20662     } catch (std::out_of_range& e) {
20663       {
20664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20665       };
20666     } catch (std::exception& e) {
20667       {
20668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20669       };
20670     } catch (Dali::DaliException e) {
20671       {
20672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20673       };
20674     } catch (...) {
20675       {
20676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20677       };
20678     }
20679   }
20680
20681   jresult = (void *)result;
20682   return jresult;
20683 }
20684
20685
20686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_New(unsigned int jarg1) {
20687   void * jresult ;
20688   unsigned int arg1 ;
20689   Dali::HoverEvent result;
20690
20691   arg1 = (unsigned int)jarg1;
20692   {
20693     try {
20694       result = DevelHoverEvent::New(arg1);
20695     } CALL_CATCH_EXCEPTION(0);
20696   }
20697
20698   jresult = new Dali::HoverEvent((const Dali::HoverEvent &)result);
20699   return jresult;
20700 }
20701
20702
20703 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetTime(void * jarg1) {
20704   unsigned long jresult ;
20705   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20706   unsigned long result;
20707
20708   arg1 = (Dali::HoverEvent *)jarg1;
20709   {
20710     try {
20711       result = (unsigned long)((Dali::HoverEvent const *)arg1)->GetTime();
20712     } catch (std::out_of_range& e) {
20713       {
20714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20715       };
20716     } catch (std::exception& e) {
20717       {
20718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20719       };
20720     } catch (Dali::DaliException e) {
20721       {
20722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20723       };
20724     } catch (...) {
20725       {
20726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20727       };
20728     }
20729   }
20730
20731   jresult = (unsigned long)result;
20732   return jresult;
20733 }
20734
20735
20736 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
20737   unsigned long jresult ;
20738   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20739   std::size_t result;
20740
20741   arg1 = (Dali::HoverEvent *)jarg1;
20742   {
20743     try {
20744       result = ((Dali::HoverEvent const *)arg1)->GetPointCount();
20745     } catch (std::out_of_range& e) {
20746       {
20747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20748       };
20749     } catch (std::exception& e) {
20750       {
20751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20752       };
20753     } catch (Dali::DaliException e) {
20754       {
20755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20756       };
20757     } catch (...) {
20758       {
20759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20760       };
20761     }
20762   }
20763
20764   jresult = (unsigned long)result;
20765   return jresult;
20766 }
20767
20768
20769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetDeviceId(void * jarg1, unsigned long jarg2) {
20770   int jresult ;
20771   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20772   std::size_t arg2 ;
20773   int32_t result;
20774
20775   arg1 = (Dali::HoverEvent *)jarg1;
20776   arg2 = (std::size_t)jarg2;
20777   {
20778     try {
20779       result = ((Dali::HoverEvent const *)arg1)->GetDeviceId(arg2);
20780     } catch (std::out_of_range& e) {
20781       {
20782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20783       };
20784     } catch (std::exception& e) {
20785       {
20786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20787       };
20788     } catch (Dali::DaliException e) {
20789       {
20790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20791       };
20792     } catch (...) {
20793       {
20794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20795       };
20796     }
20797   }
20798
20799   jresult = result;
20800   return jresult;
20801 }
20802
20803
20804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetState(void * jarg1, unsigned long jarg2) {
20805   int jresult ;
20806   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20807   std::size_t arg2 ;
20808   Dali::PointState::Type result;
20809
20810   arg1 = (Dali::HoverEvent *)jarg1;
20811   arg2 = (std::size_t)jarg2;
20812   {
20813     try {
20814       result = (Dali::PointState::Type)((Dali::HoverEvent const *)arg1)->GetState(arg2);
20815     } CALL_CATCH_EXCEPTION(0);
20816   }
20817
20818   jresult = (int)result;
20819   return jresult;
20820 }
20821
20822
20823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetHitActor(void * jarg1, unsigned long jarg2) {
20824   void * jresult ;
20825   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20826   std::size_t arg2 ;
20827   Dali::Actor result;
20828
20829   arg1 = (Dali::HoverEvent *)jarg1;
20830   arg2 = (std::size_t)jarg2;
20831   {
20832     try {
20833       result = ((Dali::HoverEvent const *)arg1)->GetHitActor(arg2);
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 = new Dali::Actor((const Dali::Actor &)result);
20854   return jresult;
20855 }
20856
20857
20858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetLocalPosition(void * jarg1, unsigned long jarg2) {
20859   void * jresult ;
20860   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20861   std::size_t arg2 ;
20862   Dali::Vector2 *result = 0 ;
20863
20864   arg1 = (Dali::HoverEvent *)jarg1;
20865   arg2 = (std::size_t)jarg2;
20866   {
20867     try {
20868       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetLocalPosition(arg2);
20869     } catch (std::out_of_range& e) {
20870       {
20871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20872       };
20873     } catch (std::exception& e) {
20874       {
20875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20876       };
20877     } catch (Dali::DaliException e) {
20878       {
20879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20880       };
20881     } catch (...) {
20882       {
20883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20884       };
20885     }
20886   }
20887
20888   jresult = (void *)result;
20889   return jresult;
20890 }
20891
20892
20893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetScreenPosition(void * jarg1, unsigned long jarg2) {
20894   void * jresult ;
20895   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20896   std::size_t arg2 ;
20897   Dali::Vector2 *result = 0 ;
20898
20899   arg1 = (Dali::HoverEvent *)jarg1;
20900   arg2 = (std::size_t)jarg2;
20901   {
20902     try {
20903       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetScreenPosition(arg2);
20904     } CALL_CATCH_EXCEPTION(0);
20905   }
20906
20907   jresult = (void *)result;
20908   return jresult;
20909 }
20910
20911
20912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
20913   void * jresult ;
20914   Dali::KeyEvent *result = 0 ;
20915
20916   {
20917     try {
20918       result = (Dali::KeyEvent *)new Dali::KeyEvent();
20919     } CALL_CATCH_EXCEPTION(0);
20920   }
20921
20922   jresult = (void *)result;
20923   return jresult;
20924 }
20925
20926
20927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(void * jarg1) {
20928   void * jresult ;
20929   Dali::KeyEvent *arg1 = 0 ;
20930   Dali::KeyEvent *result = 0 ;
20931
20932   arg1 = (Dali::KeyEvent *)jarg1;
20933   if (!arg1) {
20934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
20935     return 0;
20936   }
20937   {
20938     try {
20939       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
20940     } CALL_CATCH_EXCEPTION(0);
20941   }
20942
20943   jresult = (void *)result;
20944   return jresult;
20945 }
20946
20947
20948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
20949   void * jresult ;
20950   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
20951   Dali::KeyEvent *arg2 = 0 ;
20952   Dali::KeyEvent *result = 0 ;
20953
20954   arg1 = (Dali::KeyEvent *)jarg1;
20955   arg2 = (Dali::KeyEvent *)jarg2;
20956   if (!arg2) {
20957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
20958     return 0;
20959   }
20960   {
20961     try {
20962       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
20963     } CALL_CATCH_EXCEPTION(0);
20964   }
20965
20966   jresult = (void *)result;
20967   return jresult;
20968 }
20969
20970
20971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_New(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
20972   void * jresult ;
20973   std::string *arg1 = 0 ;
20974   std::string *arg2 = 0 ;
20975   int arg3 ;
20976   int arg4 ;
20977   unsigned long arg5 ;
20978   Dali::KeyEvent::State *arg6 = 0 ;
20979   Dali::KeyEvent::State temp6 ;
20980   Dali::KeyEvent result;
20981
20982   if (!jarg1) {
20983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20984     return 0;
20985   }
20986   std::string arg1_str(jarg1);
20987   arg1 = &arg1_str;
20988   if (!jarg2) {
20989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20990     return 0;
20991   }
20992   std::string arg2_str(jarg2);
20993   arg2 = &arg2_str;
20994   arg3 = (int)jarg3;
20995   arg4 = (int)jarg4;
20996   arg5 = (unsigned long)jarg5;
20997   temp6 = (Dali::KeyEvent::State)jarg6;
20998   arg6 = &temp6;
20999   {
21000     try {
21001       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);
21002     } CALL_CATCH_EXCEPTION(0);
21003   }
21004
21005   jresult = new Dali::KeyEvent((const Dali::KeyEvent &)result);
21006
21007   //argout typemap for const std::string&
21008
21009
21010   //argout typemap for const std::string&
21011
21012   return jresult;
21013 }
21014
21015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
21016   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
21017
21018   arg1 = (Dali::KeyEvent *)jarg1;
21019   {
21020     try {
21021       delete arg1;
21022     } CALL_CATCH_EXCEPTION();
21023   }
21024
21025 }
21026
21027
21028 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
21029   bool jresult ;
21030   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
21031   bool result;
21032
21033   arg1 = (Dali::KeyEvent *)jarg1;
21034   {
21035     try {
21036       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
21037     } CALL_CATCH_EXCEPTION(0);
21038   }
21039
21040   jresult = result;
21041   return jresult;
21042 }
21043
21044
21045 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
21046   bool jresult ;
21047   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
21048   bool result;
21049
21050   arg1 = (Dali::KeyEvent *)jarg1;
21051   {
21052     try {
21053       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
21054     } CALL_CATCH_EXCEPTION(0);
21055   }
21056
21057   jresult = result;
21058   return jresult;
21059 }
21060
21061
21062 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
21063   bool jresult ;
21064   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
21065   bool result;
21066
21067   arg1 = (Dali::KeyEvent *)jarg1;
21068   {
21069     try {
21070       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
21071     } CALL_CATCH_EXCEPTION(0);
21072   }
21073
21074   jresult = result;
21075   return jresult;
21076 }
21077
21078
21079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
21080   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
21081   std::string *arg2 = 0 ;
21082
21083   argp1 = (Dali::KeyEvent *) jarg1;
21084   if (!argp1) {
21085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
21086     return ;
21087   }
21088
21089   Dali::KeyEvent arg1 = *argp1;
21090   if (!jarg2) {
21091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21092     return ;
21093   }
21094   std::string arg2_str(jarg2);
21095   arg2 = &arg2_str;
21096
21097   {
21098     try {
21099       Dali::DevelKeyEvent::SetKeyName(arg1, (std::string const &)*arg2);
21100     } catch (std::out_of_range& e) {
21101       {
21102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21103       };
21104     } catch (std::exception& e) {
21105       {
21106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21107       };
21108     } catch (Dali::DaliException e) {
21109       {
21110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21111       };
21112     } catch (...) {
21113       {
21114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21115       };
21116     }
21117   }
21118 }
21119
21120
21121 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
21122   char * jresult ;
21123
21124   if( jarg1 == NULL )
21125   {
21126     jresult = SWIG_csharp_string_callback( "" );
21127   }
21128   else
21129   {
21130     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
21131     std::string *result = 0;
21132     std::string str = "";
21133
21134     arg1 = ( Dali::KeyEvent * )jarg1;
21135     {
21136       try {
21137         str = ((Dali::KeyEvent const *)arg1)->GetKeyName();
21138         result = (std::string *) &str;
21139         jresult = SWIG_csharp_string_callback(result->c_str());
21140       } catch (std::out_of_range& e) {
21141         {
21142           SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21143         };
21144       } catch (std::exception& e) {
21145         {
21146           SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21147         };
21148       } catch (Dali::DaliException e) {
21149         {
21150           SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21151         };
21152       } catch (...) {
21153         {
21154           SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21155         };
21156       }
21157     }
21158
21159   }
21160
21161   return jresult;
21162 }
21163
21164
21165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
21166   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
21167   std::string *arg2 = 0 ;
21168
21169   argp1 = (Dali::KeyEvent *) jarg1;
21170   if (!argp1) {
21171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
21172     return ;
21173   }
21174
21175   Dali::KeyEvent arg1 = *argp1;
21176   if (!jarg2) {
21177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21178     return ;
21179   }
21180   std::string arg2_str(jarg2);
21181   arg2 = &arg2_str;
21182
21183   {
21184     try {
21185       Dali::DevelKeyEvent::SetKeyString(arg1, (std::string const &)*arg2);
21186     } catch (std::out_of_range& e) {
21187       {
21188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21189       };
21190     } catch (std::exception& e) {
21191       {
21192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21193       };
21194     } catch (Dali::DaliException e) {
21195       {
21196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21197       };
21198     } catch (...) {
21199       {
21200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21201       };
21202     }
21203   }
21204 }
21205
21206
21207 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
21208   char * jresult ;
21209
21210   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
21211   std::string *result = 0;
21212   std::string str = "";
21213   arg1 = ( Dali::KeyEvent * )jarg1;
21214   {
21215     try {
21216       str = ((Dali::KeyEvent const *)arg1)->GetKeyString();
21217       result = (std::string *) &str;
21218       jresult = SWIG_csharp_string_callback(result->c_str());
21219     } catch (std::out_of_range& e) {
21220       {
21221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21222       };
21223     } catch (std::exception& e) {
21224       {
21225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21226       };
21227     } catch (Dali::DaliException e) {
21228       {
21229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21230       };
21231     } catch (...) {
21232       {
21233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21234       };
21235     }
21236   }
21237
21238   return jresult;
21239 }
21240
21241
21242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
21243   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
21244   int arg2 ;
21245
21246   argp1 = (Dali::KeyEvent *) jarg1;
21247   if (!argp1) {
21248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
21249     return ;
21250   }
21251
21252   Dali::KeyEvent arg1 = *argp1;
21253   arg2 = (int)jarg2;
21254   {
21255     try {
21256       Dali::DevelKeyEvent::SetKeyCode(arg1, arg2);
21257     } catch (std::out_of_range& e) {
21258       {
21259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21260       };
21261     } catch (std::exception& e) {
21262       {
21263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21264       };
21265     } catch (Dali::DaliException e) {
21266       {
21267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21268       };
21269     } catch (...) {
21270       {
21271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21272       };
21273     }
21274   }
21275 }
21276
21277
21278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
21279   int jresult ;
21280   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
21281   int result;
21282
21283   arg1 = (Dali::KeyEvent *)jarg1;
21284   {
21285     try {
21286       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyCode();
21287     } catch (std::out_of_range& e) {
21288       {
21289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21290       };
21291     } catch (std::exception& e) {
21292       {
21293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21294       };
21295     } catch (Dali::DaliException e) {
21296       {
21297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21298       };
21299     } catch (...) {
21300       {
21301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21302       };
21303     }
21304   }
21305
21306   jresult = result;
21307   return jresult;
21308 }
21309
21310
21311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
21312   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
21313   int arg2 ;
21314
21315   argp1 = (Dali::KeyEvent *) jarg1;
21316   if (!argp1) {
21317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
21318     return ;
21319   }
21320
21321   Dali::KeyEvent arg1 = *argp1;
21322   arg2 = (int)jarg2;
21323   {
21324     try {
21325       Dali::DevelKeyEvent::SetKeyModifier(arg1, arg2);
21326     } catch (std::out_of_range& e) {
21327       {
21328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21329       };
21330     } catch (std::exception& e) {
21331       {
21332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21333       };
21334     } catch (Dali::DaliException e) {
21335       {
21336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21337       };
21338     } catch (...) {
21339       {
21340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21341       };
21342     }
21343   }
21344 }
21345
21346
21347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
21348   int jresult ;
21349   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
21350   int result;
21351
21352   arg1 = (Dali::KeyEvent *)jarg1;
21353   {
21354     try {
21355       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyModifier();
21356     } catch (std::out_of_range& e) {
21357       {
21358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21359       };
21360     } catch (std::exception& e) {
21361       {
21362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21363       };
21364     } catch (Dali::DaliException e) {
21365       {
21366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21367       };
21368     } catch (...) {
21369       {
21370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21371       };
21372     }
21373   }
21374
21375   jresult = result;
21376   return jresult;
21377 }
21378
21379
21380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
21381   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
21382   unsigned long arg2 ;
21383
21384   argp1 = (Dali::KeyEvent *) jarg1;
21385   if (!argp1) {
21386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
21387     return ;
21388   }
21389
21390   Dali::KeyEvent arg1 = *argp1;
21391   arg2 = (int)jarg2;
21392   {
21393     try {
21394       Dali::DevelKeyEvent::SetTime(arg1, arg2);
21395     } catch (std::out_of_range& e) {
21396       {
21397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21398       };
21399     } catch (std::exception& e) {
21400       {
21401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21402       };
21403     } catch (Dali::DaliException e) {
21404       {
21405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21406       };
21407     } catch (...) {
21408       {
21409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21410       };
21411     }
21412   }
21413 }
21414
21415
21416 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
21417   unsigned long jresult ;
21418   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
21419   unsigned long result;
21420
21421   arg1 = (Dali::KeyEvent *)jarg1;
21422   {
21423     try {
21424       result = (int)((Dali::KeyEvent const *)arg1)->GetTime();
21425     } catch (std::out_of_range& e) {
21426       {
21427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21428       };
21429     } catch (std::exception& e) {
21430       {
21431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21432       };
21433     } catch (Dali::DaliException e) {
21434       {
21435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21436       };
21437     } catch (...) {
21438       {
21439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21440       };
21441     }
21442   }
21443
21444   jresult = result;
21445   return jresult;
21446 }
21447
21448
21449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
21450   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0;
21451   Dali::KeyEvent::State arg2;
21452
21453   argp1 = (Dali::KeyEvent *) jarg1;
21454   if (!argp1) {
21455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
21456     return ;
21457   }
21458
21459   Dali::KeyEvent arg1 = *argp1;
21460   arg2 = (Dali::KeyEvent::State)jarg2;
21461   {
21462     try {
21463       Dali::DevelKeyEvent::SetState(arg1, arg2);
21464     } catch (std::out_of_range& e) {
21465       {
21466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21467       };
21468     } catch (std::exception& e) {
21469       {
21470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21471       };
21472     } catch (Dali::DaliException e) {
21473       {
21474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21475       };
21476     } catch (...) {
21477       {
21478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21479       };
21480     }
21481   }
21482 }
21483
21484
21485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
21486   int jresult ;
21487   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
21488   Dali::KeyEvent::State result;
21489
21490   arg1 = (Dali::KeyEvent *)jarg1;
21491   {
21492     try {
21493       result = (Dali::KeyEvent::State)((Dali::KeyEvent const *)arg1)->GetState();
21494     } catch (std::out_of_range& e) {
21495       {
21496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21497       };
21498     } catch (std::exception& e) {
21499       {
21500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21501       };
21502     } catch (Dali::DaliException e) {
21503       {
21504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21505       };
21506     } catch (...) {
21507       {
21508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21509       };
21510     }
21511   }
21512
21513   jresult = (int)result;
21514   return jresult;
21515
21516 }
21517
21518 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
21519   char * jresult ;
21520
21521   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
21522   std::string *result = 0;
21523   std::string str = "";
21524
21525   arg1 = ( Dali::KeyEvent * )jarg1;
21526   {
21527     try {
21528       str = ((Dali::KeyEvent const *)arg1)->GetLogicalKey();
21529       result = (std::string *) &str;
21530       jresult = SWIG_csharp_string_callback(result->c_str());
21531     } CALL_CATCH_EXCEPTION(0);
21532   }
21533
21534   return jresult;
21535 }
21536
21537
21538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
21539   void * jresult ;
21540   Dali::LongPressGestureDetector *result = 0 ;
21541
21542   {
21543     try {
21544       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
21545     } CALL_CATCH_EXCEPTION(0);
21546   }
21547
21548   jresult = (void *)result;
21549   return jresult;
21550 }
21551
21552
21553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
21554   void * jresult ;
21555   Dali::LongPressGestureDetector result;
21556
21557   {
21558     try {
21559       result = Dali::LongPressGestureDetector::New();
21560     } CALL_CATCH_EXCEPTION(0);
21561   }
21562
21563   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
21564   return jresult;
21565 }
21566
21567
21568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
21569   void * jresult ;
21570   unsigned int arg1 ;
21571   Dali::LongPressGestureDetector result;
21572
21573   arg1 = (unsigned int)jarg1;
21574   {
21575     try {
21576       result = Dali::LongPressGestureDetector::New(arg1);
21577     } CALL_CATCH_EXCEPTION(0);
21578   }
21579
21580   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
21581   return jresult;
21582 }
21583
21584
21585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
21586   void * jresult ;
21587   unsigned int arg1 ;
21588   unsigned int arg2 ;
21589   Dali::LongPressGestureDetector result;
21590
21591   arg1 = (unsigned int)jarg1;
21592   arg2 = (unsigned int)jarg2;
21593   {
21594     try {
21595       result = Dali::LongPressGestureDetector::New(arg1,arg2);
21596     } CALL_CATCH_EXCEPTION(0);
21597   }
21598
21599   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
21600   return jresult;
21601 }
21602
21603
21604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
21605   void * jresult ;
21606   Dali::BaseHandle arg1 ;
21607   Dali::BaseHandle *argp1 ;
21608   Dali::LongPressGestureDetector result;
21609
21610   argp1 = (Dali::BaseHandle *)jarg1;
21611   if (!argp1) {
21612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21613     return 0;
21614   }
21615   arg1 = *argp1;
21616   {
21617     try {
21618       result = Dali::LongPressGestureDetector::DownCast(arg1);
21619     } CALL_CATCH_EXCEPTION(0);
21620   }
21621
21622   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
21623   return jresult;
21624 }
21625
21626
21627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
21628   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
21629
21630   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21631   {
21632     try {
21633       delete arg1;
21634     } CALL_CATCH_EXCEPTION();
21635   }
21636
21637 }
21638
21639
21640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
21641   void * jresult ;
21642   Dali::LongPressGestureDetector *arg1 = 0 ;
21643   Dali::LongPressGestureDetector *result = 0 ;
21644
21645   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21646   if (!arg1) {
21647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
21648     return 0;
21649   }
21650   {
21651     try {
21652       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
21653     } CALL_CATCH_EXCEPTION(0);
21654   }
21655
21656   jresult = (void *)result;
21657   return jresult;
21658 }
21659
21660
21661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
21662   void * jresult ;
21663   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
21664   Dali::LongPressGestureDetector *arg2 = 0 ;
21665   Dali::LongPressGestureDetector *result = 0 ;
21666
21667   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21668   arg2 = (Dali::LongPressGestureDetector *)jarg2;
21669   if (!arg2) {
21670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
21671     return 0;
21672   }
21673   {
21674     try {
21675       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
21676     } CALL_CATCH_EXCEPTION(0);
21677   }
21678
21679   jresult = (void *)result;
21680   return jresult;
21681 }
21682
21683
21684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
21685   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
21686   unsigned int arg2 ;
21687
21688   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21689   arg2 = (unsigned int)jarg2;
21690   {
21691     try {
21692       (arg1)->SetTouchesRequired(arg2);
21693     } CALL_CATCH_EXCEPTION();
21694   }
21695
21696 }
21697
21698
21699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
21700   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
21701   unsigned int arg2 ;
21702   unsigned int arg3 ;
21703
21704   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21705   arg2 = (unsigned int)jarg2;
21706   arg3 = (unsigned int)jarg3;
21707   {
21708     try {
21709       (arg1)->SetTouchesRequired(arg2,arg3);
21710     } CALL_CATCH_EXCEPTION();
21711   }
21712
21713 }
21714
21715
21716 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
21717   unsigned int jresult ;
21718   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
21719   unsigned int result;
21720
21721   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21722   {
21723     try {
21724       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
21725     } CALL_CATCH_EXCEPTION(0);
21726   }
21727
21728   jresult = result;
21729   return jresult;
21730 }
21731
21732
21733 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
21734   unsigned int jresult ;
21735   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
21736   unsigned int result;
21737
21738   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21739   {
21740     try {
21741       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
21742     } CALL_CATCH_EXCEPTION(0);
21743   }
21744
21745   jresult = result;
21746   return jresult;
21747 }
21748
21749
21750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
21751   void * jresult ;
21752   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
21753   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
21754
21755   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21756   {
21757     try {
21758       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
21759     } CALL_CATCH_EXCEPTION(0);
21760   }
21761
21762   jresult = (void *)result;
21763   return jresult;
21764 }
21765
21766
21767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0() {
21768   void * jresult ;
21769   Dali::LongPressGesture *result = 0 ;
21770
21771   {
21772     try {
21773       result = (Dali::LongPressGesture *)new Dali::LongPressGesture();
21774     } CALL_CATCH_EXCEPTION(0);
21775   }
21776
21777   jresult = (void *)result;
21778   return jresult;
21779 }
21780
21781
21782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_New(int jarg1) {
21783   void * jresult ;
21784   Dali::GestureState arg1 ;
21785   Dali::LongPressGesture result;
21786
21787   arg1 = (Dali::GestureState)jarg1;
21788   {
21789     try {
21790       result = DevelLongPressGesture::New(arg1);
21791     } CALL_CATCH_EXCEPTION(0);
21792   }
21793
21794   jresult = new Dali::LongPressGesture((const Dali::LongPressGesture &)result);
21795   return jresult;
21796 }
21797
21798
21799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
21800   void * jresult ;
21801   Dali::LongPressGesture *arg1 = 0 ;
21802   Dali::LongPressGesture *result = 0 ;
21803
21804   arg1 = (Dali::LongPressGesture *)jarg1;
21805   if (!arg1) {
21806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
21807     return 0;
21808   }
21809   {
21810     try {
21811       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
21812     } CALL_CATCH_EXCEPTION(0);
21813   }
21814
21815   jresult = (void *)result;
21816   return jresult;
21817 }
21818
21819
21820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
21821   void * jresult ;
21822   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
21823   Dali::LongPressGesture *arg2 = 0 ;
21824   Dali::LongPressGesture *result = 0 ;
21825
21826   arg1 = (Dali::LongPressGesture *)jarg1;
21827   arg2 = (Dali::LongPressGesture *)jarg2;
21828   if (!arg2) {
21829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
21830     return 0;
21831   }
21832   {
21833     try {
21834       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
21835     } CALL_CATCH_EXCEPTION(0);
21836   }
21837
21838   jresult = (void *)result;
21839   return jresult;
21840 }
21841
21842
21843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
21844   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
21845
21846   arg1 = (Dali::LongPressGesture *)jarg1;
21847   {
21848     try {
21849       delete arg1;
21850     } CALL_CATCH_EXCEPTION();
21851   }
21852
21853 }
21854
21855
21856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
21857   unsigned int jresult ;
21858   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
21859   unsigned int result;
21860
21861   arg1 = (Dali::LongPressGesture *)jarg1;
21862   result = (unsigned int) ((arg1)->GetNumberOfTouches());
21863   jresult = result;
21864   return jresult;
21865 }
21866
21867
21868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
21869   void * jresult ;
21870   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
21871   Dali::Vector2 result;
21872
21873   arg1 = (Dali::LongPressGesture *)jarg1;
21874   {
21875     try {
21876       result = ((Dali::LongPressGesture const *)arg1)->GetScreenPoint();
21877     } catch (std::out_of_range& e) {
21878       {
21879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21880       };
21881     } catch (std::exception& e) {
21882       {
21883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21884       };
21885     } catch (Dali::DaliException e) {
21886       {
21887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21888       };
21889     } catch (...) {
21890       {
21891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21892       };
21893     }
21894   }
21895   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
21896   return jresult;
21897 }
21898
21899
21900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
21901   void * jresult ;
21902   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
21903   Dali::Vector2 result;
21904
21905   arg1 = (Dali::LongPressGesture *)jarg1;
21906   {
21907     try {
21908       result = ((Dali::LongPressGesture const *)arg1)->GetLocalPoint();
21909     } catch (std::out_of_range& e) {
21910       {
21911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21912       };
21913     } catch (std::exception& e) {
21914       {
21915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21916       };
21917     } catch (Dali::DaliException e) {
21918       {
21919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21920       };
21921     } catch (...) {
21922       {
21923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21924       };
21925     }
21926   }
21927   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
21928   return jresult;
21929 }
21930
21931
21932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
21933   void * jresult ;
21934   Dali::WheelEvent *result = 0 ;
21935
21936   {
21937     try {
21938       result = (Dali::WheelEvent *)new Dali::WheelEvent();
21939     } CALL_CATCH_EXCEPTION(0);
21940   }
21941
21942   jresult = (void *)result;
21943   return jresult;
21944 }
21945
21946
21947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(void * jarg1) {
21948   void * jresult ;
21949   Dali::WheelEvent *arg1 = 0 ;
21950   Dali::WheelEvent *result = 0 ;
21951
21952   arg1 = (Dali::WheelEvent *)jarg1;
21953   if (!arg1) {
21954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
21955     return 0;
21956   }
21957   {
21958     try {
21959       result = (Dali::WheelEvent *)new Dali::WheelEvent((Dali::WheelEvent const &)*arg1);
21960     } catch (std::out_of_range& e) {
21961       {
21962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21963       };
21964     } catch (std::exception& e) {
21965       {
21966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21967       };
21968     } catch (Dali::DaliException e) {
21969       {
21970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21971       };
21972     } catch (...) {
21973       {
21974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21975       };
21976     }
21977   }
21978
21979   jresult = (void *)result;
21980   return jresult;
21981 }
21982
21983
21984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_Assign(void * jarg1, void * jarg2) {
21985   void * jresult ;
21986   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21987   Dali::WheelEvent *arg2 = 0 ;
21988   Dali::WheelEvent *result = 0 ;
21989
21990   arg1 = (Dali::WheelEvent *)jarg1;
21991   arg2 = (Dali::WheelEvent *)jarg2;
21992   if (!arg2) {
21993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
21994     return 0;
21995   }
21996   {
21997     try {
21998       result = (Dali::WheelEvent *) &(arg1)->operator =((Dali::WheelEvent const &)*arg2);
21999     } catch (std::out_of_range& e) {
22000       {
22001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22002       };
22003     } catch (std::exception& e) {
22004       {
22005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22006       };
22007     } catch (Dali::DaliException e) {
22008       {
22009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22010       };
22011     } catch (...) {
22012       {
22013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22014       };
22015     }
22016   }
22017
22018   jresult = (void *)result;
22019   return jresult;
22020 }
22021
22022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_New(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
22023   void * jresult ;
22024   Dali::WheelEvent::Type arg1 ;
22025   int arg2 ;
22026   unsigned int arg3 ;
22027   Dali::Vector2 arg4 ;
22028   int arg5 ;
22029   unsigned int arg6 ;
22030   Dali::Vector2 *argp4 ;
22031   Dali::WheelEvent result;
22032
22033   arg1 = (Dali::WheelEvent::Type)jarg1;
22034   arg2 = (int)jarg2;
22035   arg3 = (unsigned int)jarg3;
22036   argp4 = (Dali::Vector2 *)jarg4;
22037   if (!argp4) {
22038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
22039     return 0;
22040   }
22041   arg4 = *argp4;
22042   arg5 = (int)jarg5;
22043   arg6 = (unsigned int)jarg6;
22044   {
22045     try {
22046       result = DevelWheelEvent::New(arg1,arg2,arg3,arg4,arg5,arg6);
22047     } CALL_CATCH_EXCEPTION(0);
22048   }
22049
22050   jresult = new Dali::WheelEvent((const Dali::WheelEvent &)result);
22051   return jresult;
22052 }
22053
22054
22055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
22056   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
22057
22058   arg1 = (Dali::WheelEvent *)jarg1;
22059   {
22060     try {
22061       delete arg1;
22062     } CALL_CATCH_EXCEPTION();
22063   }
22064
22065 }
22066
22067
22068 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
22069   bool jresult ;
22070   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
22071   bool result;
22072
22073   arg1 = (Dali::WheelEvent *)jarg1;
22074   {
22075     try {
22076       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
22077     } CALL_CATCH_EXCEPTION(0);
22078   }
22079
22080   jresult = result;
22081   return jresult;
22082 }
22083
22084
22085 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
22086   bool jresult ;
22087   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
22088   bool result;
22089
22090   arg1 = (Dali::WheelEvent *)jarg1;
22091   {
22092     try {
22093       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
22094     } catch (std::out_of_range& e) {
22095       {
22096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22097       };
22098     } catch (std::exception& e) {
22099       {
22100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22101       };
22102     } catch (Dali::DaliException e) {
22103       {
22104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22105       };
22106     } catch (...) {
22107       {
22108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22109       };
22110     }
22111   }
22112
22113   jresult = result;
22114   return jresult;
22115 }
22116
22117
22118 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
22119   bool jresult ;
22120   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
22121   bool result;
22122
22123   arg1 = (Dali::WheelEvent *)jarg1;
22124   {
22125     try {
22126       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
22127     } catch (std::out_of_range& e) {
22128       {
22129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22130       };
22131     } catch (std::exception& e) {
22132       {
22133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22134       };
22135     } catch (Dali::DaliException e) {
22136       {
22137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22138       };
22139     } catch (...) {
22140       {
22141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22142       };
22143     }
22144   }
22145
22146   jresult = result;
22147   return jresult;
22148 }
22149
22150
22151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
22152   int jresult ;
22153   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
22154   Dali::WheelEvent::Type result;
22155
22156   arg1 = (Dali::WheelEvent *)jarg1;
22157   {
22158     try {
22159       result = ((Dali::WheelEvent const *)arg1)->GetType();
22160     } catch (std::out_of_range& e) {
22161       {
22162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22163       };
22164     } catch (std::exception& e) {
22165       {
22166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22167       };
22168     } catch (Dali::DaliException e) {
22169       {
22170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22171       };
22172     } catch (...) {
22173       {
22174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22175       };
22176     }
22177   }
22178
22179   jresult = (int)result;
22180   return jresult;
22181 }
22182
22183
22184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
22185   int jresult ;
22186   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
22187   int result;
22188
22189   arg1 = (Dali::WheelEvent *)jarg1;
22190   {
22191     try {
22192       result = ((Dali::WheelEvent const *)arg1)->GetDirection();
22193     } catch (std::out_of_range& e) {
22194       {
22195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22196       };
22197     } catch (std::exception& e) {
22198       {
22199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22200       };
22201     } catch (Dali::DaliException e) {
22202       {
22203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22204       };
22205     } catch (...) {
22206       {
22207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22208       };
22209     }
22210   }
22211
22212   jresult = result;
22213   return jresult;
22214 }
22215
22216
22217 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
22218   unsigned int jresult ;
22219   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
22220   unsigned int result;
22221
22222   arg1 = (Dali::WheelEvent *)jarg1;
22223   {
22224     try {
22225       result = ((Dali::WheelEvent const *)arg1)->GetModifiers();
22226     } CALL_CATCH_EXCEPTION(0);
22227   }
22228
22229   jresult = result;
22230   return jresult;
22231 }
22232
22233
22234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
22235   void * jresult ;
22236   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
22237   Dali::Vector2 *result = 0 ;
22238
22239   arg1 = (Dali::WheelEvent *)jarg1;
22240   {
22241     try {
22242       result = (Dali::Vector2 *) &((Dali::WheelEvent const *)arg1)->GetPoint();
22243     } CALL_CATCH_EXCEPTION(0);
22244   }
22245
22246   jresult = (void *)result;
22247   return jresult;
22248 }
22249
22250
22251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_delta_get(void * jarg1) {
22252   int jresult ;
22253   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
22254   int result;
22255
22256   arg1 = (Dali::WheelEvent *)jarg1;
22257   {
22258     try {
22259       result = ((Dali::WheelEvent const *)arg1)->GetDelta();
22260     } catch (std::out_of_range& e) {
22261       {
22262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22263       };
22264     } catch (std::exception& e) {
22265       {
22266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22267       };
22268     } catch (Dali::DaliException e) {
22269       {
22270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22271       };
22272     } catch (...) {
22273       {
22274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22275       };
22276     }
22277   }
22278
22279   jresult = result;
22280   return jresult;
22281 }
22282
22283
22284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
22285   unsigned int jresult ;
22286   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
22287   unsigned int result;
22288
22289   arg1 = (Dali::WheelEvent *)jarg1;
22290   {
22291     try {
22292       result = ((Dali::WheelEvent const *)arg1)->GetTime();
22293     } catch (std::out_of_range& e) {
22294       {
22295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22296       };
22297     } catch (std::exception& e) {
22298       {
22299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22300       };
22301     } catch (Dali::DaliException e) {
22302       {
22303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22304       };
22305     } catch (...) {
22306       {
22307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22308       };
22309     }
22310   }
22311
22312   jresult = result;
22313   return jresult;
22314 }
22315
22316 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
22317   char * jresult ;
22318   Dali::KeyEvent *arg1 = 0 ;
22319   std::string result;
22320
22321   arg1 = (Dali::KeyEvent *)jarg1;
22322   if (!arg1) {
22323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
22324     return 0;
22325   }
22326   {
22327     try {
22328       result = arg1->GetDeviceName();
22329     } CALL_CATCH_EXCEPTION(0);
22330   }
22331
22332   jresult = SWIG_csharp_string_callback((&result)->c_str());
22333   return jresult;
22334 }
22335
22336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
22337   int jresult ;
22338   Dali::KeyEvent *arg1 = 0 ;
22339   Dali::Device::Class::Type result;
22340
22341   arg1 = (Dali::KeyEvent *)jarg1;
22342   if (!arg1) {
22343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
22344     return 0;
22345   }
22346   {
22347     try {
22348       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
22349     } CALL_CATCH_EXCEPTION(0);
22350   }
22351
22352   jresult = (int)result;
22353   return jresult;
22354 }
22355
22356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
22357   int jresult ;
22358   Dali::KeyEvent *arg1 = 0 ;
22359   Dali::Device::Subclass::Type result;
22360
22361   arg1 = (Dali::KeyEvent *)jarg1;
22362   if (!arg1) {
22363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
22364     return 0;
22365   }
22366   {
22367     try {
22368       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
22369     } CALL_CATCH_EXCEPTION(0);
22370   }
22371
22372   jresult = (int)result;
22373   return jresult;
22374 }
22375
22376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
22377   Dali::Actor arg1 ;
22378   Dali::Actor *argp1 ;
22379
22380   argp1 = (Dali::Actor *)jarg1;
22381   if (!argp1) {
22382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
22383     return ;
22384   }
22385   arg1 = *argp1;
22386   {
22387     try {
22388       arg1.Raise();
22389     } CALL_CATCH_EXCEPTION();
22390   }
22391
22392 }
22393
22394
22395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
22396   Dali::Actor arg1 ;
22397   Dali::Actor *argp1 ;
22398
22399   argp1 = (Dali::Actor *)jarg1;
22400   if (!argp1) {
22401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
22402     return ;
22403   }
22404   arg1 = *argp1;
22405   {
22406     try {
22407       arg1.Lower();
22408     } CALL_CATCH_EXCEPTION();
22409   }
22410
22411 }
22412
22413
22414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
22415   Dali::Actor arg1 ;
22416   Dali::Actor *argp1 ;
22417
22418   argp1 = (Dali::Actor *)jarg1;
22419   if (!argp1) {
22420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
22421     return ;
22422   }
22423   arg1 = *argp1;
22424   {
22425     try {
22426       arg1.RaiseToTop();
22427     } CALL_CATCH_EXCEPTION();
22428   }
22429
22430 }
22431
22432
22433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
22434   Dali::Actor arg1 ;
22435   Dali::Actor *argp1 ;
22436
22437   argp1 = (Dali::Actor *)jarg1;
22438   if (!argp1) {
22439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
22440     return ;
22441   }
22442   arg1 = *argp1;
22443   {
22444     try {
22445       arg1.LowerToBottom();
22446     } CALL_CATCH_EXCEPTION();
22447   }
22448
22449 }
22450
22451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
22452   Dali::Actor arg1 ;
22453   Dali::Actor arg2 ;
22454   Dali::Actor *argp1 ;
22455   Dali::Actor *argp2 ;
22456
22457   argp1 = (Dali::Actor *)jarg1;
22458   if (!argp1) {
22459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
22460     return ;
22461   }
22462   arg1 = *argp1;
22463   argp2 = (Dali::Actor *)jarg2;
22464   if (!argp2) {
22465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
22466     return ;
22467   }
22468   arg2 = *argp2;
22469   {
22470     try {
22471       arg1.RaiseAbove(arg2);
22472     } CALL_CATCH_EXCEPTION();
22473   }
22474
22475 }
22476
22477
22478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
22479   Dali::Actor arg1 ;
22480   Dali::Actor arg2 ;
22481   Dali::Actor *argp1 ;
22482   Dali::Actor *argp2 ;
22483
22484   argp1 = (Dali::Actor *)jarg1;
22485   if (!argp1) {
22486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
22487     return ;
22488   }
22489   arg1 = *argp1;
22490   argp2 = (Dali::Actor *)jarg2;
22491   if (!argp2) {
22492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
22493     return ;
22494   }
22495   arg2 = *argp2;
22496   {
22497     try {
22498       arg1.LowerBelow(arg2);
22499     } CALL_CATCH_EXCEPTION();
22500   }
22501
22502 }
22503
22504
22505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
22506   void * jresult ;
22507   Dali::Actor arg1 ;
22508   Dali::Actor *argp1 ;
22509   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
22510
22511   argp1 = (Dali::Actor *)jarg1;
22512   if (!argp1) {
22513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
22514     return 0;
22515   }
22516   arg1 = *argp1;
22517   {
22518     try {
22519       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
22520     } CALL_CATCH_EXCEPTION(0);
22521   }
22522
22523   jresult = (void *)result;
22524   return jresult;
22525 }
22526
22527
22528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
22529   void * jresult ;
22530   Dali::Actor *arg1 ;
22531   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
22532
22533   arg1 = (Dali::Actor *)jarg1;
22534   {
22535     try {
22536       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
22537     } CALL_CATCH_EXCEPTION(0);
22538   }
22539
22540   jresult = (void *)result;
22541   return jresult;
22542 }
22543
22544
22545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
22546   int jresult ;
22547   int result;
22548
22549   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
22550   jresult = (int)result;
22551   return jresult;
22552 }
22553
22554
22555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
22556   int jresult ;
22557   int result;
22558
22559   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
22560   jresult = (int)result;
22561   return jresult;
22562 }
22563
22564
22565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
22566   int jresult ;
22567   int result;
22568
22569   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
22570   jresult = (int)result;
22571   return jresult;
22572 }
22573
22574
22575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
22576   int jresult ;
22577   int result;
22578
22579   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
22580   jresult = (int)result;
22581   return jresult;
22582 }
22583
22584
22585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
22586   int jresult ;
22587   int result;
22588
22589   result = (int)Dali::Actor::Property::ANCHOR_POINT;
22590   jresult = (int)result;
22591   return jresult;
22592 }
22593
22594
22595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
22596   int jresult ;
22597   int result;
22598
22599   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
22600   jresult = (int)result;
22601   return jresult;
22602 }
22603
22604
22605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
22606   int jresult ;
22607   int result;
22608
22609   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
22610   jresult = (int)result;
22611   return jresult;
22612 }
22613
22614
22615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
22616   int jresult ;
22617   int result;
22618
22619   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
22620   jresult = (int)result;
22621   return jresult;
22622 }
22623
22624
22625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
22626   int jresult ;
22627   int result;
22628
22629   result = (int)Dali::Actor::Property::SIZE;
22630   jresult = (int)result;
22631   return jresult;
22632 }
22633
22634
22635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
22636   int jresult ;
22637   int result;
22638
22639   result = (int)Dali::Actor::Property::SIZE_WIDTH;
22640   jresult = (int)result;
22641   return jresult;
22642 }
22643
22644
22645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
22646   int jresult ;
22647   int result;
22648
22649   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
22650   jresult = (int)result;
22651   return jresult;
22652 }
22653
22654
22655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
22656   int jresult ;
22657   int result;
22658
22659   result = (int)Dali::Actor::Property::SIZE_DEPTH;
22660   jresult = (int)result;
22661   return jresult;
22662 }
22663
22664
22665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
22666   int jresult ;
22667   int result;
22668
22669   result = (int)Dali::Actor::Property::POSITION;
22670   jresult = (int)result;
22671   return jresult;
22672 }
22673
22674
22675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
22676   int jresult ;
22677   int result;
22678
22679   result = (int)Dali::Actor::Property::POSITION_X;
22680   jresult = (int)result;
22681   return jresult;
22682 }
22683
22684
22685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
22686   int jresult ;
22687   int result;
22688
22689   result = (int)Dali::Actor::Property::POSITION_Y;
22690   jresult = (int)result;
22691   return jresult;
22692 }
22693
22694
22695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
22696   int jresult ;
22697   int result;
22698
22699   result = (int)Dali::Actor::Property::POSITION_Z;
22700   jresult = (int)result;
22701   return jresult;
22702 }
22703
22704
22705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
22706   int jresult ;
22707   int result;
22708
22709   result = (int)Dali::Actor::Property::WORLD_POSITION;
22710   jresult = (int)result;
22711   return jresult;
22712 }
22713
22714
22715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
22716   int jresult ;
22717   int result;
22718
22719   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
22720   jresult = (int)result;
22721   return jresult;
22722 }
22723
22724
22725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
22726   int jresult ;
22727   int result;
22728
22729   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
22730   jresult = (int)result;
22731   return jresult;
22732 }
22733
22734
22735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
22736   int jresult ;
22737   int result;
22738
22739   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
22740   jresult = (int)result;
22741   return jresult;
22742 }
22743
22744
22745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
22746   int jresult ;
22747   int result;
22748
22749   result = (int)Dali::Actor::Property::ORIENTATION;
22750   jresult = (int)result;
22751   return jresult;
22752 }
22753
22754
22755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
22756   int jresult ;
22757   int result;
22758
22759   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
22760   jresult = (int)result;
22761   return jresult;
22762 }
22763
22764
22765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
22766   int jresult ;
22767   int result;
22768
22769   result = (int)Dali::Actor::Property::SCALE;
22770   jresult = (int)result;
22771   return jresult;
22772 }
22773
22774
22775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
22776   int jresult ;
22777   int result;
22778
22779   result = (int)Dali::Actor::Property::SCALE_X;
22780   jresult = (int)result;
22781   return jresult;
22782 }
22783
22784
22785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
22786   int jresult ;
22787   int result;
22788
22789   result = (int)Dali::Actor::Property::SCALE_Y;
22790   jresult = (int)result;
22791   return jresult;
22792 }
22793
22794
22795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
22796   int jresult ;
22797   int result;
22798
22799   result = (int)Dali::Actor::Property::SCALE_Z;
22800   jresult = (int)result;
22801   return jresult;
22802 }
22803
22804
22805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
22806   int jresult ;
22807   int result;
22808
22809   result = (int)Dali::Actor::Property::WORLD_SCALE;
22810   jresult = (int)result;
22811   return jresult;
22812 }
22813
22814
22815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
22816   int jresult ;
22817   int result;
22818
22819   result = (int)Dali::Actor::Property::VISIBLE;
22820   jresult = (int)result;
22821   return jresult;
22822 }
22823
22824
22825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
22826   int jresult ;
22827   int result;
22828
22829   result = (int)Dali::Actor::Property::COLOR;
22830   jresult = (int)result;
22831   return jresult;
22832 }
22833
22834
22835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
22836   int jresult ;
22837   int result;
22838
22839   result = (int)Dali::Actor::Property::COLOR_RED;
22840   jresult = (int)result;
22841   return jresult;
22842 }
22843
22844
22845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
22846   int jresult ;
22847   int result;
22848
22849   result = (int)Dali::Actor::Property::COLOR_GREEN;
22850   jresult = (int)result;
22851   return jresult;
22852 }
22853
22854
22855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
22856   int jresult ;
22857   int result;
22858
22859   result = (int)Dali::Actor::Property::COLOR_BLUE;
22860   jresult = (int)result;
22861   return jresult;
22862 }
22863
22864
22865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
22866   int jresult ;
22867   int result;
22868
22869   result = (int)Dali::Actor::Property::COLOR_ALPHA;
22870   jresult = (int)result;
22871   return jresult;
22872 }
22873
22874
22875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
22876   int jresult ;
22877   int result;
22878
22879   result = (int)Dali::Actor::Property::WORLD_COLOR;
22880   jresult = (int)result;
22881   return jresult;
22882 }
22883
22884
22885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
22886   int jresult ;
22887   int result;
22888
22889   result = (int)Dali::Actor::Property::WORLD_MATRIX;
22890   jresult = (int)result;
22891   return jresult;
22892 }
22893
22894
22895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
22896   int jresult ;
22897   int result;
22898
22899   result = (int)Dali::Actor::Property::NAME;
22900   jresult = (int)result;
22901   return jresult;
22902 }
22903
22904
22905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
22906   int jresult ;
22907   int result;
22908
22909   result = (int)Dali::Actor::Property::SENSITIVE;
22910   jresult = (int)result;
22911   return jresult;
22912 }
22913
22914
22915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_USER_INTERACTION_ENABLED_get() {
22916   int jresult ;
22917   int result;
22918
22919   result = (int)Dali::DevelActor::Property::USER_INTERACTION_ENABLED;
22920   jresult = (int)result;
22921   return jresult;
22922 }
22923
22924
22925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
22926   int jresult ;
22927   int result;
22928
22929   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
22930   jresult = (int)result;
22931   return jresult;
22932 }
22933
22934
22935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
22936   int jresult ;
22937   int result;
22938
22939   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
22940   jresult = (int)result;
22941   return jresult;
22942 }
22943
22944
22945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
22946   int jresult ;
22947   int result;
22948
22949   result = (int)Dali::Actor::Property::INHERIT_SCALE;
22950   jresult = (int)result;
22951   return jresult;
22952 }
22953
22954
22955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
22956   int jresult ;
22957   int result;
22958
22959   result = (int)Dali::Actor::Property::COLOR_MODE;
22960   jresult = (int)result;
22961   return jresult;
22962 }
22963
22964
22965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
22966   int jresult ;
22967   int result;
22968
22969   result = (int)Dali::Actor::Property::DRAW_MODE;
22970   jresult = (int)result;
22971   return jresult;
22972 }
22973
22974
22975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
22976   int jresult ;
22977   int result;
22978
22979   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
22980   jresult = (int)result;
22981   return jresult;
22982 }
22983
22984
22985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
22986   int jresult ;
22987   int result;
22988
22989   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
22990   jresult = (int)result;
22991   return jresult;
22992 }
22993
22994
22995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
22996   int jresult ;
22997   int result;
22998
22999   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
23000   jresult = (int)result;
23001   return jresult;
23002 }
23003
23004
23005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
23006   int jresult ;
23007   int result;
23008
23009   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
23010   jresult = (int)result;
23011   return jresult;
23012 }
23013
23014
23015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
23016   int jresult ;
23017   int result;
23018
23019   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
23020   jresult = (int)result;
23021   return jresult;
23022 }
23023
23024
23025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
23026   int jresult ;
23027   int result;
23028
23029   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
23030   jresult = (int)result;
23031   return jresult;
23032 }
23033
23034
23035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
23036   int jresult ;
23037   int result;
23038
23039   result = (int)Dali::Actor::Property::PADDING;
23040   jresult = (int)result;
23041   return jresult;
23042 }
23043
23044
23045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
23046   int jresult ;
23047   int result;
23048
23049   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
23050   jresult = (int)result;
23051   return jresult;
23052 }
23053
23054
23055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
23056   int jresult ;
23057   int result;
23058
23059   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
23060   jresult = (int)result;
23061   return jresult;
23062 }
23063
23064
23065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
23066   int jresult ;
23067   int result;
23068
23069   result = (int)Dali::Actor::Property::INHERIT_POSITION;
23070   jresult = (int)result;
23071   return jresult;
23072 }
23073
23074
23075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
23076   int jresult ;
23077   int result;
23078
23079   result = (int)Dali::Actor::Property::CLIPPING_MODE;
23080   jresult = (int)result;
23081   return jresult;
23082 }
23083
23084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_UPDATE_AREA_HINT_get() {
23085   int jresult ;
23086   int result;
23087
23088   result = (int)Dali::Actor::Property::UPDATE_AREA_HINT;
23089   jresult = (int)result;
23090   return jresult;
23091 }
23092
23093 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_OPACITY_get() {
23094
23095   return Dali::Actor::Property::OPACITY;
23096 }
23097
23098 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SCREEN_POSITION_get() {
23099
23100   return Dali::Actor::Property::SCREEN_POSITION;
23101 }
23102
23103 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_POSITION_USES_ANCHOR_POINT_get() {
23104
23105   return Dali::Actor::Property::POSITION_USES_ANCHOR_POINT;
23106 }
23107
23108 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_INHERIT_LAYOUT_DIRECTION_get() {
23109   return Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION;
23110 }
23111
23112 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_LAYOUT_DIRECTION_get() {
23113   return Dali::Actor::Property::LAYOUT_DIRECTION;
23114 }
23115
23116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
23117   void * jresult ;
23118   Dali::Actor::Property *result = 0 ;
23119
23120   {
23121     try {
23122       result = (Dali::Actor::Property *)new Dali::Actor::Property();
23123     } CALL_CATCH_EXCEPTION(0);
23124   }
23125
23126   jresult = (void *)result;
23127   return jresult;
23128 }
23129
23130
23131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
23132   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
23133
23134   arg1 = (Dali::Actor::Property *)jarg1;
23135   {
23136     try {
23137       delete arg1;
23138     } CALL_CATCH_EXCEPTION();
23139   }
23140
23141 }
23142
23143
23144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
23145   void * jresult ;
23146   Dali::Actor *result = 0 ;
23147
23148   {
23149     try {
23150       result = (Dali::Actor *)new Dali::Actor();
23151     } CALL_CATCH_EXCEPTION(0);
23152   }
23153
23154   jresult = (void *)result;
23155   return jresult;
23156 }
23157
23158
23159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
23160   void * jresult ;
23161   Dali::Actor result;
23162
23163   {
23164     try {
23165       result = Dali::Actor::New();
23166     } CALL_CATCH_EXCEPTION(0);
23167   }
23168
23169   jresult = new Dali::Actor((const Dali::Actor &)result);
23170   return jresult;
23171 }
23172
23173
23174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
23175   void * jresult ;
23176   Dali::BaseHandle arg1 ;
23177   Dali::BaseHandle *argp1 ;
23178   Dali::Actor result;
23179
23180   argp1 = (Dali::BaseHandle *)jarg1;
23181   if (!argp1) {
23182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23183     return 0;
23184   }
23185   arg1 = *argp1;
23186   {
23187     try {
23188       result = Dali::Actor::DownCast(arg1);
23189     } CALL_CATCH_EXCEPTION(0);
23190   }
23191
23192   jresult = new Dali::Actor((const Dali::Actor &)result);
23193   return jresult;
23194 }
23195
23196
23197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
23198   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23199
23200   arg1 = (Dali::Actor *)jarg1;
23201   {
23202     try {
23203       delete arg1;
23204     } CALL_CATCH_EXCEPTION();
23205   }
23206
23207 }
23208
23209
23210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
23211   void * jresult ;
23212   Dali::Actor *arg1 = 0 ;
23213   Dali::Actor *result = 0 ;
23214
23215   arg1 = (Dali::Actor *)jarg1;
23216   if (!arg1) {
23217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
23218     return 0;
23219   }
23220   {
23221     try {
23222       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
23223     } CALL_CATCH_EXCEPTION(0);
23224   }
23225
23226   jresult = (void *)result;
23227   return jresult;
23228 }
23229
23230
23231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
23232   void * jresult ;
23233   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23234   Dali::Actor *arg2 = 0 ;
23235   Dali::Actor *result = 0 ;
23236
23237   if (!jarg1) {
23238     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23239     return 0;
23240   }
23241
23242   if (!jarg2) {
23243     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg2 is null!");
23244     return 0;
23245   }
23246
23247   arg1 = (Dali::Actor *)jarg1;
23248   arg2 = (Dali::Actor *)jarg2;
23249   {
23250     try {
23251       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
23252     } CALL_CATCH_EXCEPTION(0);
23253   }
23254
23255   jresult = (void *)result;
23256   return jresult;
23257 }
23258
23259
23260 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
23261   char * jresult ;
23262   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23263   std::string *result = 0 ;
23264   std::string name = "";
23265
23266   if (!jarg1) {
23267     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23268     return 0;
23269   }
23270
23271   arg1 = (Dali::Actor *)jarg1;
23272   {
23273     try {
23274       name = ((Dali::Actor const *)arg1)->GetProperty< std::string >( Dali::Actor::Property::NAME );
23275       result = (std::string *) &name;
23276       jresult = SWIG_csharp_string_callback(result->c_str());
23277     } CALL_CATCH_EXCEPTION(0);
23278   }
23279   return jresult;
23280 }
23281
23282
23283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
23284   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23285   std::string *arg2 = 0 ;
23286
23287   if (!jarg1) {
23288     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23289     return ;
23290   }
23291
23292   arg1 = (Dali::Actor *)jarg1;
23293   if (!jarg2) {
23294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23295     return ;
23296   }
23297   std::string arg2_str(jarg2);
23298   arg2 = &arg2_str;
23299   {
23300     try {
23301       (arg1)->SetProperty( Dali::Actor::Property::NAME, (std::string const &)*arg2);
23302     } CALL_CATCH_EXCEPTION();
23303   }
23304
23305
23306   //argout typemap for const std::string&
23307
23308 }
23309
23310
23311 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
23312   unsigned int jresult ;
23313   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23314   unsigned int result;
23315
23316   arg1 = (Dali::Actor *)jarg1;
23317
23318   if(!arg1) {
23319     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
23320     return -1;
23321   }
23322
23323   {
23324     try {
23325       result = (unsigned int)((Dali::Actor const *)arg1)->GetProperty< int >( Actor::Property::ID );
23326     } CALL_CATCH_EXCEPTION(0);
23327   }
23328
23329   jresult = result;
23330   return jresult;
23331 }
23332
23333
23334 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
23335   bool jresult ;
23336   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23337   bool result;
23338
23339   if (!jarg1) {
23340     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23341     return 0;
23342   }
23343
23344   arg1 = (Dali::Actor *)jarg1;
23345   {
23346     try {
23347       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_ROOT );
23348     } CALL_CATCH_EXCEPTION(0);
23349   }
23350
23351   jresult = result;
23352   return jresult;
23353 }
23354
23355
23356 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
23357   bool jresult ;
23358   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23359   bool result;
23360
23361   if (!jarg1) {
23362     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23363     return 0;
23364   }
23365
23366   arg1 = (Dali::Actor *)jarg1;
23367   {
23368     try {
23369       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE );
23370     } CALL_CATCH_EXCEPTION(0);
23371   }
23372
23373   jresult = result;
23374   return jresult;
23375 }
23376
23377
23378 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
23379   bool jresult ;
23380   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23381   bool result;
23382
23383   if (!jarg1) {
23384     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23385     return 0;
23386   }
23387
23388   arg1 = (Dali::Actor *)jarg1;
23389   {
23390     try {
23391       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_LAYER );
23392     } CALL_CATCH_EXCEPTION(0);
23393   }
23394
23395   jresult = result;
23396   return jresult;
23397 }
23398
23399
23400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
23401   void * jresult ;
23402   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23403   Dali::Layer result;
23404
23405   if (!jarg1) {
23406     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23407     return 0;
23408   }
23409
23410   arg1 = (Dali::Actor *)jarg1;
23411   {
23412     try {
23413       result = (arg1)->GetLayer();
23414     } CALL_CATCH_EXCEPTION(0);
23415   }
23416
23417   jresult = new Dali::Layer((const Dali::Layer &)result);
23418   return jresult;
23419 }
23420
23421
23422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
23423   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23424   Dali::Actor arg2 ;
23425
23426   if (!jarg1) {
23427     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23428     return ;
23429   }
23430   if (!jarg2) {
23431     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg2 is null!");
23432     return ;
23433   }
23434
23435   arg1 = (Dali::Actor *)jarg1;
23436   arg2 = *((Dali::Actor *)jarg2);
23437   {
23438     try {
23439       (arg1)->Add(arg2);
23440     } CALL_CATCH_EXCEPTION();
23441   }
23442
23443 }
23444
23445
23446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
23447   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23448   Dali::Actor arg2 ;
23449
23450   if (!jarg1) {
23451     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23452     return ;
23453   }
23454   if (!jarg2) {
23455     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg2 is null!");
23456     return ;
23457   }
23458
23459   arg1 = (Dali::Actor *)jarg1;
23460   arg2 = *((Dali::Actor *)jarg2);
23461   {
23462     try {
23463       (arg1)->Remove(arg2);
23464     } CALL_CATCH_EXCEPTION();
23465   }
23466
23467 }
23468
23469
23470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
23471   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23472
23473   if (!jarg1) {
23474     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23475     return ;
23476   }
23477
23478   arg1 = (Dali::Actor *)jarg1;
23479   {
23480     try {
23481       (arg1)->Unparent();
23482     } CALL_CATCH_EXCEPTION();
23483   }
23484
23485 }
23486
23487
23488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
23489   unsigned int jresult ;
23490   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23491   unsigned int result;
23492
23493   if (!jarg1) {
23494     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23495     return 0;
23496   }
23497
23498   arg1 = (Dali::Actor *)jarg1;
23499   {
23500     try {
23501       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
23502     } CALL_CATCH_EXCEPTION(0);
23503   }
23504
23505   jresult = result;
23506   return jresult;
23507 }
23508
23509
23510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
23511   void * jresult ;
23512   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23513   unsigned int arg2 ;
23514   Dali::Actor result;
23515
23516   if (!jarg1) {
23517     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23518     return 0;
23519   }
23520
23521   arg1 = (Dali::Actor *)jarg1;
23522   arg2 = (unsigned int)jarg2;
23523   {
23524     try {
23525       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
23526     } CALL_CATCH_EXCEPTION(0);
23527   }
23528
23529   jresult = new Dali::Actor((const Dali::Actor &)result);
23530   return jresult;
23531 }
23532
23533
23534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
23535   void * jresult ;
23536   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23537   std::string *arg2 = 0 ;
23538   Dali::Actor result;
23539
23540   if (!jarg1) {
23541     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23542     return 0;
23543   }
23544
23545   arg1 = (Dali::Actor *)jarg1;
23546   if (!jarg2) {
23547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23548     return 0;
23549   }
23550   std::string arg2_str(jarg2);
23551   arg2 = &arg2_str;
23552   {
23553     try {
23554       result = (arg1)->FindChildByName((std::string const &)*arg2);
23555     } CALL_CATCH_EXCEPTION(0);
23556   }
23557
23558   jresult = new Dali::Actor((const Dali::Actor &)result);
23559
23560   //argout typemap for const std::string&
23561
23562   return jresult;
23563 }
23564
23565
23566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
23567   void * jresult ;
23568   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23569   unsigned int arg2 ;
23570   Dali::Actor result;
23571
23572   if (!jarg1) {
23573     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23574     return 0;
23575   }
23576
23577   arg1 = (Dali::Actor *)jarg1;
23578   arg2 = (unsigned int)jarg2;
23579   {
23580     try {
23581       result = (arg1)->FindChildById(arg2);
23582     } CALL_CATCH_EXCEPTION(0);
23583   }
23584
23585   jresult = new Dali::Actor((const Dali::Actor &)result);
23586   return jresult;
23587 }
23588
23589
23590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
23591   void * jresult ;
23592   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23593   Dali::Actor result;
23594
23595   if (!jarg1) {
23596     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23597     return 0;
23598   }
23599
23600   arg1 = (Dali::Actor *)jarg1;
23601   {
23602     try {
23603       result = ((Dali::Actor const *)arg1)->GetParent();
23604     } CALL_CATCH_EXCEPTION(0);
23605   }
23606
23607   jresult = new Dali::Actor((const Dali::Actor &)result);
23608   return jresult;
23609 }
23610
23611
23612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
23613   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23614   Dali::Vector3 *arg2 = 0 ;
23615
23616   if (!jarg1) {
23617     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23618     return ;
23619   }
23620
23621   arg1 = (Dali::Actor *)jarg1;
23622   arg2 = (Dali::Vector3 *)jarg2;
23623   if (!arg2) {
23624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23625     return ;
23626   }
23627   {
23628     try {
23629       (arg1)->SetProperty( Actor::Property::PARENT_ORIGIN,(Dali::Vector3 const &)*arg2);
23630     } CALL_CATCH_EXCEPTION();
23631   }
23632
23633 }
23634
23635
23636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
23637   void * jresult ;
23638   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23639   Dali::Vector3 result;
23640
23641   if (!jarg1) {
23642     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23643     return 0;
23644   }
23645
23646   arg1 = (Dali::Actor *)jarg1;
23647   {
23648     try {
23649       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN );
23650     } CALL_CATCH_EXCEPTION(0);
23651   }
23652
23653   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23654   return jresult;
23655 }
23656
23657
23658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
23659   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23660   Dali::Vector3 *arg2 = 0 ;
23661
23662   if (!jarg1) {
23663     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23664     return ;
23665   }
23666
23667   arg1 = (Dali::Actor *)jarg1;
23668   arg2 = (Dali::Vector3 *)jarg2;
23669   if (!arg2) {
23670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23671     return ;
23672   }
23673   {
23674     try {
23675       (arg1)->SetProperty( Actor::Property::ANCHOR_POINT,(Dali::Vector3 const &)*arg2);
23676     } CALL_CATCH_EXCEPTION();
23677   }
23678
23679 }
23680
23681
23682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
23683   void * jresult ;
23684   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23685   Dali::Vector3 result;
23686
23687   if (!jarg1) {
23688     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23689     return 0;
23690   }
23691
23692   arg1 = (Dali::Actor *)jarg1;
23693   {
23694     try {
23695       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
23696     } CALL_CATCH_EXCEPTION(0);
23697   }
23698
23699   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23700   return jresult;
23701 }
23702
23703
23704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
23705   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23706   float arg2 ;
23707   float arg3 ;
23708
23709   if (!jarg1) {
23710     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23711     return ;
23712   }
23713
23714   arg1 = (Dali::Actor *)jarg1;
23715   arg2 = (float)jarg2;
23716   arg3 = (float)jarg3;
23717   {
23718     try {
23719       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector2(arg2,arg3) );
23720     } CALL_CATCH_EXCEPTION();
23721   }
23722
23723 }
23724
23725
23726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
23727   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23728   float arg2 ;
23729   float arg3 ;
23730   float arg4 ;
23731
23732   if (!jarg1) {
23733     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23734     return ;
23735   }
23736
23737   arg1 = (Dali::Actor *)jarg1;
23738   arg2 = (float)jarg2;
23739   arg3 = (float)jarg3;
23740   arg4 = (float)jarg4;
23741   {
23742     try {
23743       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector3(arg2,arg3,arg4) );
23744     } CALL_CATCH_EXCEPTION();
23745   }
23746
23747 }
23748
23749
23750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
23751   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23752   Dali::Vector2 *arg2 = 0 ;
23753
23754   if (!jarg1) {
23755     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23756     return ;
23757   }
23758
23759   arg1 = (Dali::Actor *)jarg1;
23760   arg2 = (Dali::Vector2 *)jarg2;
23761   if (!arg2) {
23762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
23763     return ;
23764   }
23765   {
23766     try {
23767       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector2 const &)*arg2);
23768     } CALL_CATCH_EXCEPTION();
23769   }
23770
23771 }
23772
23773
23774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
23775   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23776   Dali::Vector3 *arg2 = 0 ;
23777
23778   if (!jarg1) {
23779     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23780     return ;
23781   }
23782
23783   arg1 = (Dali::Actor *)jarg1;
23784   arg2 = (Dali::Vector3 *)jarg2;
23785   if (!arg2) {
23786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23787     return ;
23788   }
23789   {
23790     try {
23791       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector3 const &)*arg2);
23792     } CALL_CATCH_EXCEPTION();
23793   }
23794
23795 }
23796
23797
23798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
23799   void * jresult ;
23800   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23801   Dali::Vector3 result;
23802
23803   if (!jarg1) {
23804     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23805     return 0;
23806   }
23807
23808   arg1 = (Dali::Actor *)jarg1;
23809   {
23810     try {
23811       result = ((Dali::Actor const *)arg1)->GetTargetSize();
23812     } CALL_CATCH_EXCEPTION(0);
23813   }
23814
23815   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23816   return jresult;
23817 }
23818
23819
23820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
23821   void * jresult ;
23822   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23823   Dali::Vector3 result;
23824
23825   if (!jarg1) {
23826     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23827     return 0;
23828   }
23829
23830   arg1 = (Dali::Actor *)jarg1;
23831   {
23832     try {
23833       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
23834     } CALL_CATCH_EXCEPTION(0);
23835   }
23836
23837   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23838   return jresult;
23839 }
23840
23841
23842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
23843   void * jresult ;
23844   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23845   Dali::Vector3 result;
23846
23847   if (!jarg1) {
23848     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23849     return 0;
23850   }
23851
23852   arg1 = (Dali::Actor *)jarg1;
23853   {
23854     try {
23855       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
23856     } CALL_CATCH_EXCEPTION(0);
23857   }
23858
23859   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23860   return jresult;
23861 }
23862
23863
23864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
23865   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23866   float arg2 ;
23867   float arg3 ;
23868
23869   if (!jarg1) {
23870     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23871     return ;
23872   }
23873
23874   arg1 = (Dali::Actor *)jarg1;
23875   arg2 = (float)jarg2;
23876   arg3 = (float)jarg3;
23877   {
23878     try {
23879       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector2( arg2, arg3 ) );
23880     } CALL_CATCH_EXCEPTION();
23881   }
23882
23883 }
23884
23885
23886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
23887   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23888   float arg2 ;
23889   float arg3 ;
23890   float arg4 ;
23891
23892   if (!jarg1) {
23893     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23894     return ;
23895   }
23896
23897   arg1 = (Dali::Actor *)jarg1;
23898   arg2 = (float)jarg2;
23899   arg3 = (float)jarg3;
23900   arg4 = (float)jarg4;
23901   {
23902     try {
23903       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector3( arg2, arg3, arg4 ) );
23904     } CALL_CATCH_EXCEPTION();
23905   }
23906
23907 }
23908
23909
23910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
23911   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23912   Dali::Vector3 *arg2 = 0 ;
23913
23914   if (!jarg1) {
23915     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23916     return ;
23917   }
23918
23919   arg1 = (Dali::Actor *)jarg1;
23920   arg2 = (Dali::Vector3 *)jarg2;
23921   if (!arg2) {
23922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23923     return ;
23924   }
23925   {
23926     try {
23927       (arg1)->SetProperty( Actor::Property::POSITION, (Dali::Vector3 const &)*arg2 );
23928     } CALL_CATCH_EXCEPTION();
23929   }
23930
23931 }
23932
23933
23934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
23935   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23936   float arg2 ;
23937
23938   if (!jarg1) {
23939     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23940     return ;
23941   }
23942
23943   arg1 = (Dali::Actor *)jarg1;
23944   arg2 = (float)jarg2;
23945   {
23946     try {
23947       (arg1)->SetProperty( Actor::Property::POSITION_X, (arg2) );
23948     } CALL_CATCH_EXCEPTION();
23949   }
23950
23951 }
23952
23953
23954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
23955   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23956   float arg2 ;
23957
23958   if (!jarg1) {
23959     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23960     return ;
23961   }
23962
23963   arg1 = (Dali::Actor *)jarg1;
23964   arg2 = (float)jarg2;
23965   {
23966     try {
23967       (arg1)->SetProperty( Actor::Property::POSITION_Y, arg2 );
23968     } CALL_CATCH_EXCEPTION();
23969   }
23970
23971 }
23972
23973
23974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
23975   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23976   float arg2 ;
23977
23978   if (!jarg1) {
23979     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23980     return ;
23981   }
23982
23983   arg1 = (Dali::Actor *)jarg1;
23984   arg2 = (float)jarg2;
23985   {
23986     try {
23987       (arg1)->SetProperty( Actor::Property::POSITION_Z, arg2 );
23988     } CALL_CATCH_EXCEPTION();
23989   }
23990
23991 }
23992
23993
23994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
23995   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23996   Dali::Vector3 *arg2 = 0 ;
23997
23998   if (!jarg1) {
23999     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24000     return ;
24001   }
24002
24003   arg1 = (Dali::Actor *)jarg1;
24004   arg2 = (Dali::Vector3 *)jarg2;
24005   if (!arg2) {
24006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
24007     return ;
24008   }
24009   {
24010     try {
24011       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
24012     } CALL_CATCH_EXCEPTION();
24013   }
24014
24015 }
24016
24017
24018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
24019   void * jresult ;
24020   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24021   Dali::Vector3 result;
24022
24023   if (!jarg1) {
24024     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24025     return 0;
24026   }
24027
24028   arg1 = (Dali::Actor *)jarg1;
24029   {
24030     try {
24031       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
24032     } CALL_CATCH_EXCEPTION(0);
24033   }
24034
24035   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
24036   return jresult;
24037 }
24038
24039
24040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
24041   void * jresult ;
24042   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24043   Dali::Vector3 result;
24044
24045   if (!jarg1) {
24046     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24047     return 0;
24048   }
24049
24050   arg1 = (Dali::Actor *)jarg1;
24051   {
24052     try {
24053       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION );
24054     } CALL_CATCH_EXCEPTION(0);
24055   }
24056
24057   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
24058   return jresult;
24059 }
24060
24061
24062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, bool jarg2) {
24063   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24064   bool arg2 ;
24065
24066   if (!jarg1) {
24067     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24068     return ;
24069   }
24070
24071   arg1 = (Dali::Actor *)jarg1;
24072   arg2 = jarg2 ? true : false;
24073   {
24074     try {
24075       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
24076     } CALL_CATCH_EXCEPTION();
24077   }
24078
24079 }
24080
24081
24082 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
24083   bool jresult ;
24084   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24085   bool result;
24086
24087   if (!jarg1) {
24088     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24089     return 0;
24090   }
24091
24092   arg1 = (Dali::Actor *)jarg1;
24093   {
24094     try {
24095       result = (bool)((Dali::Actor const *)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
24096     } CALL_CATCH_EXCEPTION(0);
24097   }
24098
24099   jresult = result;
24100   return jresult;
24101 }
24102
24103
24104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
24105   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24106   Dali::Degree *arg2 = 0 ;
24107   Dali::Vector3 *arg3 = 0 ;
24108
24109   if (!jarg1) {
24110     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24111     return ;
24112   }
24113
24114   arg1 = (Dali::Actor *)jarg1;
24115   arg2 = (Dali::Degree *)jarg2;
24116   if (!arg2) {
24117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
24118     return ;
24119   }
24120   arg3 = (Dali::Vector3 *)jarg3;
24121   if (!arg3) {
24122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
24123     return ;
24124   }
24125   {
24126     try {
24127       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
24128     } CALL_CATCH_EXCEPTION();
24129   }
24130
24131 }
24132
24133
24134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
24135   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24136   Dali::Radian *arg2 = 0 ;
24137   Dali::Vector3 *arg3 = 0 ;
24138
24139   if (!jarg1) {
24140     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24141     return ;
24142   }
24143
24144   arg1 = (Dali::Actor *)jarg1;
24145   arg2 = (Dali::Radian *)jarg2;
24146   if (!arg2) {
24147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
24148     return ;
24149   }
24150   arg3 = (Dali::Vector3 *)jarg3;
24151   if (!arg3) {
24152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
24153     return ;
24154   }
24155   {
24156     try {
24157       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
24158     } CALL_CATCH_EXCEPTION();
24159   }
24160
24161 }
24162
24163
24164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
24165   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24166   Dali::Quaternion *arg2 = 0 ;
24167
24168   if (!jarg1) {
24169     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24170     return ;
24171   }
24172
24173   arg1 = (Dali::Actor *)jarg1;
24174   arg2 = (Dali::Quaternion *)jarg2;
24175   if (!arg2) {
24176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
24177     return ;
24178   }
24179   {
24180     try {
24181       (arg1)->SetProperty( Actor::Property::ORIENTATION, (Dali::Quaternion const &)*arg2 );
24182     } CALL_CATCH_EXCEPTION();
24183   }
24184
24185 }
24186
24187
24188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
24189   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24190   Dali::Degree *arg2 = 0 ;
24191   Dali::Vector3 *arg3 = 0 ;
24192
24193   if (!jarg1) {
24194     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24195     return ;
24196   }
24197
24198   arg1 = (Dali::Actor *)jarg1;
24199   arg2 = (Dali::Degree *)jarg2;
24200   if (!arg2) {
24201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
24202     return ;
24203   }
24204   arg3 = (Dali::Vector3 *)jarg3;
24205   if (!arg3) {
24206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
24207     return ;
24208   }
24209   {
24210     try {
24211       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
24212     } CALL_CATCH_EXCEPTION();
24213   }
24214
24215 }
24216
24217
24218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
24219   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24220   Dali::Radian *arg2 = 0 ;
24221   Dali::Vector3 *arg3 = 0 ;
24222
24223   if (!jarg1) {
24224     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24225     return ;
24226   }
24227
24228   arg1 = (Dali::Actor *)jarg1;
24229   arg2 = (Dali::Radian *)jarg2;
24230   if (!arg2) {
24231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
24232     return ;
24233   }
24234   arg3 = (Dali::Vector3 *)jarg3;
24235   if (!arg3) {
24236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
24237     return ;
24238   }
24239   {
24240     try {
24241       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
24242     } CALL_CATCH_EXCEPTION();
24243   }
24244
24245 }
24246
24247
24248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
24249   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24250   Dali::Quaternion *arg2 = 0 ;
24251
24252   if (!jarg1) {
24253     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24254     return ;
24255   }
24256
24257   arg1 = (Dali::Actor *)jarg1;
24258   arg2 = (Dali::Quaternion *)jarg2;
24259   if (!arg2) {
24260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
24261     return ;
24262   }
24263   {
24264     try {
24265       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
24266     } CALL_CATCH_EXCEPTION();
24267   }
24268
24269 }
24270
24271
24272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
24273   void * jresult ;
24274   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24275   Dali::Quaternion result;
24276
24277   if (!jarg1) {
24278     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24279     return 0;
24280   }
24281
24282   arg1 = (Dali::Actor *)jarg1;
24283   {
24284     try {
24285       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION );
24286     } CALL_CATCH_EXCEPTION(0);
24287   }
24288
24289   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
24290   return jresult;
24291 }
24292
24293
24294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, bool jarg2) {
24295   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24296   bool arg2 ;
24297
24298   if (!jarg1) {
24299     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24300     return ;
24301   }
24302
24303   arg1 = (Dali::Actor *)jarg1;
24304   arg2 = jarg2 ? true : false;
24305   {
24306     try {
24307       (arg1)->SetProperty( Actor::Property::INHERIT_ORIENTATION,arg2);
24308     } CALL_CATCH_EXCEPTION();
24309   }
24310
24311 }
24312
24313
24314 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
24315   bool jresult ;
24316   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24317   bool result;
24318
24319   if (!jarg1) {
24320     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24321     return 0;
24322   }
24323
24324   arg1 = (Dali::Actor *)jarg1;
24325   {
24326     try {
24327       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION );
24328     } CALL_CATCH_EXCEPTION(0);
24329   }
24330
24331   jresult = result;
24332   return jresult;
24333 }
24334
24335
24336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
24337   void * jresult ;
24338   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24339   Dali::Quaternion result;
24340
24341   if (!jarg1) {
24342     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24343     return 0;
24344   }
24345
24346   arg1 = (Dali::Actor *)jarg1;
24347   {
24348     try {
24349       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION );
24350     } CALL_CATCH_EXCEPTION(0);
24351   }
24352
24353   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
24354   return jresult;
24355 }
24356
24357
24358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
24359   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24360   float arg2 ;
24361
24362   if (!jarg1) {
24363     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24364     return ;
24365   }
24366
24367   arg1 = (Dali::Actor *)jarg1;
24368   arg2 = (float)jarg2;
24369   {
24370     try {
24371       (arg1)->SetProperty( Actor::Property::SCALE, arg2);
24372     } CALL_CATCH_EXCEPTION();
24373   }
24374
24375 }
24376
24377
24378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
24379   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24380   float arg2 ;
24381   float arg3 ;
24382   float arg4 ;
24383
24384   if (!jarg1) {
24385     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24386     return ;
24387   }
24388
24389   arg1 = (Dali::Actor *)jarg1;
24390   arg2 = (float)jarg2;
24391   arg3 = (float)jarg3;
24392   arg4 = (float)jarg4;
24393   {
24394     try {
24395       (arg1)->SetProperty( Actor::Property::SCALE, Vector3( arg2, arg3, arg4 ) );
24396     } CALL_CATCH_EXCEPTION();
24397   }
24398
24399 }
24400
24401
24402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
24403   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24404   Dali::Vector3 *arg2 = 0 ;
24405
24406   if (!jarg1) {
24407     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24408     return ;
24409   }
24410
24411   arg1 = (Dali::Actor *)jarg1;
24412   arg2 = (Dali::Vector3 *)jarg2;
24413   if (!arg2) {
24414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
24415     return ;
24416   }
24417   {
24418     try {
24419       (arg1)->SetProperty( Actor::Property::SCALE, (Dali::Vector3 const &)*arg2 );
24420     } CALL_CATCH_EXCEPTION();
24421   }
24422
24423 }
24424
24425
24426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
24427   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24428   Dali::Vector3 *arg2 = 0 ;
24429
24430   if (!jarg1) {
24431     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24432     return ;
24433   }
24434
24435   arg1 = (Dali::Actor *)jarg1;
24436   arg2 = (Dali::Vector3 *)jarg2;
24437   if (!arg2) {
24438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
24439     return ;
24440   }
24441   {
24442     try {
24443       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
24444     } CALL_CATCH_EXCEPTION();
24445   }
24446
24447 }
24448
24449
24450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
24451   void * jresult ;
24452   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24453   Dali::Vector3 result;
24454
24455   if (!jarg1) {
24456     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24457     return 0;
24458   }
24459
24460   arg1 = (Dali::Actor *)jarg1;
24461   {
24462     try {
24463       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
24464     } CALL_CATCH_EXCEPTION(0);
24465   }
24466
24467   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
24468   return jresult;
24469 }
24470
24471
24472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
24473   void * jresult ;
24474   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24475   Dali::Vector3 result;
24476
24477   if (!jarg1) {
24478     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24479     return 0;
24480   }
24481
24482   arg1 = (Dali::Actor *)jarg1;
24483   {
24484     try {
24485       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE );
24486     } CALL_CATCH_EXCEPTION(0);
24487   }
24488
24489   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
24490   return jresult;
24491 }
24492
24493
24494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, bool jarg2) {
24495   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24496   bool arg2 ;
24497
24498   if (!jarg1) {
24499     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24500     return ;
24501   }
24502
24503   arg1 = (Dali::Actor *)jarg1;
24504   arg2 = jarg2 ? true : false;
24505   {
24506     try {
24507       (arg1)->SetProperty( Actor::Property::INHERIT_SCALE,arg2);
24508     } CALL_CATCH_EXCEPTION();
24509   }
24510
24511 }
24512
24513
24514 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
24515   bool jresult ;
24516   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24517   bool result;
24518
24519   if (!jarg1) {
24520     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24521     return 0;
24522   }
24523
24524   arg1 = (Dali::Actor *)jarg1;
24525   {
24526     try {
24527       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_SCALE );
24528     } CALL_CATCH_EXCEPTION(0);
24529   }
24530
24531   jresult = result;
24532   return jresult;
24533 }
24534
24535
24536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
24537   void * jresult ;
24538   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24539   Dali::Matrix result;
24540
24541   if (!jarg1) {
24542     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24543     return 0;
24544   }
24545
24546   arg1 = (Dali::Actor *)jarg1;
24547   {
24548     try {
24549       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
24550     } CALL_CATCH_EXCEPTION(0);
24551   }
24552
24553   jresult = new Dali::Matrix((const Dali::Matrix &)result);
24554   return jresult;
24555 }
24556
24557
24558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, bool jarg2) {
24559   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24560   bool arg2 ;
24561
24562   if (!jarg1) {
24563     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24564     return ;
24565   }
24566
24567   arg1 = (Dali::Actor *)jarg1;
24568   arg2 = jarg2 ? true : false;
24569   {
24570     try {
24571       (arg1)->SetProperty( Actor::Property::VISIBLE,arg2);
24572     } CALL_CATCH_EXCEPTION();
24573   }
24574
24575 }
24576
24577
24578 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
24579   bool jresult ;
24580   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24581   bool result;
24582
24583   if (!jarg1) {
24584     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24585     return 0;
24586   }
24587
24588   arg1 = (Dali::Actor *)jarg1;
24589   {
24590     try {
24591       result = (bool)((Dali::Actor const *)arg1)->GetCurrentProperty< bool >( Actor::Property::VISIBLE );
24592     } CALL_CATCH_EXCEPTION(0);
24593   }
24594
24595   jresult = result;
24596   return jresult;
24597 }
24598
24599
24600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
24601   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24602   float arg2 ;
24603
24604   if (!jarg1) {
24605     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24606     return ;
24607   }
24608
24609   arg1 = (Dali::Actor *)jarg1;
24610   arg2 = (float)jarg2;
24611   {
24612     try {
24613       (arg1)->SetProperty( Actor::Property::OPACITY,arg2);
24614     } CALL_CATCH_EXCEPTION();
24615   }
24616
24617 }
24618
24619
24620 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
24621   float jresult ;
24622   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24623   float result;
24624
24625   if (!jarg1) {
24626     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24627     return 0;
24628   }
24629
24630   arg1 = (Dali::Actor *)jarg1;
24631   {
24632     try {
24633       result = (float)((Dali::Actor const *)arg1)->GetCurrentProperty< float >( Actor::Property::OPACITY );
24634     } CALL_CATCH_EXCEPTION(0);
24635   }
24636
24637   jresult = result;
24638   return jresult;
24639 }
24640
24641
24642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
24643   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24644   Dali::Vector4 *arg2 = 0 ;
24645
24646   if (!jarg1) {
24647     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24648     return ;
24649   }
24650
24651   arg1 = (Dali::Actor *)jarg1;
24652   arg2 = (Dali::Vector4 *)jarg2;
24653   if (!arg2) {
24654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
24655     return ;
24656   }
24657   {
24658     try {
24659       (arg1)->SetProperty( Actor::Property::COLOR,(Dali::Vector4 const &)*arg2);
24660     } CALL_CATCH_EXCEPTION();
24661   }
24662
24663 }
24664
24665
24666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
24667   void * jresult ;
24668   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24669   Dali::Vector4 result;
24670
24671   if (!jarg1) {
24672     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24673     return 0;
24674   }
24675
24676   arg1 = (Dali::Actor *)jarg1;
24677   {
24678     try {
24679       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::COLOR );
24680     } CALL_CATCH_EXCEPTION(0);
24681   }
24682
24683   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
24684   return jresult;
24685 }
24686
24687
24688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
24689   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24690   Dali::ColorMode arg2 ;
24691
24692   if (!jarg1) {
24693     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24694     return ;
24695   }
24696
24697   arg1 = (Dali::Actor *)jarg1;
24698   arg2 = (Dali::ColorMode)jarg2;
24699   {
24700     try {
24701       (arg1)->SetProperty( Actor::Property::COLOR_MODE,arg2);
24702     } CALL_CATCH_EXCEPTION();
24703   }
24704
24705 }
24706
24707
24708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
24709   int jresult ;
24710   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24711   Dali::ColorMode result;
24712
24713   if (!jarg1) {
24714     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24715     return 0;
24716   }
24717
24718   arg1 = (Dali::Actor *)jarg1;
24719   {
24720     try {
24721       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetProperty< ColorMode >( Actor::Property::COLOR_MODE );
24722     } CALL_CATCH_EXCEPTION(0);
24723   }
24724
24725   jresult = (int)result;
24726   return jresult;
24727 }
24728
24729
24730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
24731   void * jresult ;
24732   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24733   Dali::Vector4 result;
24734
24735   if (!jarg1) {
24736     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24737     return 0;
24738   }
24739
24740   arg1 = (Dali::Actor *)jarg1;
24741   {
24742     try {
24743       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR );
24744     } CALL_CATCH_EXCEPTION(0);
24745   }
24746
24747   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
24748   return jresult;
24749 }
24750
24751
24752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
24753   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24754   Dali::DrawMode::Type arg2 ;
24755
24756   if (!jarg1) {
24757     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24758     return ;
24759   }
24760
24761   arg1 = (Dali::Actor *)jarg1;
24762   arg2 = (Dali::DrawMode::Type)jarg2;
24763   {
24764     try {
24765       (arg1)->SetProperty( Actor::Property::DRAW_MODE,arg2);
24766     } CALL_CATCH_EXCEPTION();
24767   }
24768
24769 }
24770
24771
24772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
24773   int jresult ;
24774   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24775   Dali::DrawMode::Type result;
24776
24777   if (!jarg1) {
24778     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24779     return 0;
24780   }
24781
24782   arg1 = (Dali::Actor *)jarg1;
24783   {
24784     try {
24785       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE );
24786     } CALL_CATCH_EXCEPTION(0);
24787   }
24788
24789   jresult = (int)result;
24790   return jresult;
24791 }
24792
24793
24794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, bool jarg2) {
24795   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24796   bool arg2 ;
24797
24798   if (!jarg1) {
24799     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24800     return ;
24801   }
24802
24803   arg1 = (Dali::Actor *)jarg1;
24804   arg2 = jarg2 ? true : false;
24805   {
24806     try {
24807       (arg1)->SetProperty( Actor::Property::SENSITIVE,arg2);
24808     } CALL_CATCH_EXCEPTION();
24809   }
24810
24811 }
24812
24813
24814 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
24815   bool jresult ;
24816   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24817   bool result;
24818
24819   if (!jarg1) {
24820     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24821     return 0;
24822   }
24823
24824   arg1 = (Dali::Actor *)jarg1;
24825   {
24826     try {
24827       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::SENSITIVE );
24828     } CALL_CATCH_EXCEPTION(0);
24829   }
24830
24831   jresult = result;
24832   return jresult;
24833 }
24834
24835
24836 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
24837   bool jresult ;
24838   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24839   float *arg2 = 0 ;
24840   float *arg3 = 0 ;
24841   float arg4 ;
24842   float arg5 ;
24843   bool result;
24844
24845   if (!jarg1) {
24846     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24847     return 0;
24848   }
24849
24850   arg1 = (Dali::Actor *)jarg1;
24851   arg2 = (float *)jarg2;
24852   arg3 = (float *)jarg3;
24853   arg4 = (float)jarg4;
24854   arg5 = (float)jarg5;
24855   {
24856     try {
24857       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
24858     } CALL_CATCH_EXCEPTION(0);
24859   }
24860
24861   jresult = result;
24862   return jresult;
24863 }
24864
24865
24866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, bool jarg2) {
24867   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24868   bool arg2 ;
24869
24870   if (!jarg1) {
24871     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24872     return ;
24873   }
24874
24875   arg1 = (Dali::Actor *)jarg1;
24876   arg2 = jarg2 ? true : false;
24877   {
24878     try {
24879       (arg1)->SetProperty( Actor::Property::LEAVE_REQUIRED,arg2);
24880     } CALL_CATCH_EXCEPTION();
24881   }
24882
24883 }
24884
24885
24886 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
24887   bool jresult ;
24888   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24889   bool result;
24890
24891   if (!jarg1) {
24892     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24893     return 0;
24894   }
24895
24896   arg1 = (Dali::Actor *)jarg1;
24897   {
24898     try {
24899       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::LEAVE_REQUIRED );
24900     } CALL_CATCH_EXCEPTION(0);
24901   }
24902
24903   jresult = result;
24904   return jresult;
24905 }
24906
24907
24908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, bool jarg2) {
24909   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24910   bool arg2 ;
24911
24912   if (!jarg1) {
24913     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24914     return ;
24915   }
24916
24917   arg1 = (Dali::Actor *)jarg1;
24918   arg2 = jarg2 ? true : false;
24919   {
24920     try {
24921       (arg1)->SetProperty( Actor::Property::KEYBOARD_FOCUSABLE, arg2 );
24922     } CALL_CATCH_EXCEPTION();
24923   }
24924
24925 }
24926
24927
24928 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
24929   bool jresult ;
24930   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24931   bool result;
24932
24933   if (!jarg1) {
24934     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24935     return 0;
24936   }
24937
24938   arg1 = (Dali::Actor *)jarg1;
24939   {
24940     try {
24941       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE );
24942     } CALL_CATCH_EXCEPTION(0);
24943   }
24944
24945   jresult = result;
24946   return jresult;
24947 }
24948
24949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusableChildren(void * actor, bool keyboardFocusableChildren) {
24950   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24951
24952   if (!actor) {
24953     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!");
24954     return ;
24955   }
24956
24957   arg1 = (Dali::Actor *)actor;
24958   {
24959     try {
24960       (arg1)->SetProperty( DevelActor::Property::KEYBOARD_FOCUSABLE_CHILDREN, keyboardFocusableChildren );
24961     } CALL_CATCH_EXCEPTION();
24962   }
24963 }
24964
24965
24966 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_AreChildrenKeyBoardFocusable(void * actor) {
24967   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24968   bool result;
24969
24970   if (!actor) {
24971     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!");
24972     return 0;
24973   }
24974
24975   arg1 = (Dali::Actor *)actor;
24976   {
24977     try {
24978       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( DevelActor::Property::KEYBOARD_FOCUSABLE_CHILDREN );
24979     } CALL_CATCH_EXCEPTION(0);
24980   }
24981   return result;
24982 }
24983
24984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetTouchFocusable(void * jarg1, bool jarg2) {
24985   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24986   bool arg2 ;
24987
24988   if (!jarg1) {
24989     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24990     return ;
24991   }
24992
24993   arg1 = (Dali::Actor *)jarg1;
24994   arg2 = jarg2 ? true : false;
24995   {
24996     try {
24997       (arg1)->SetProperty( DevelActor::Property::TOUCH_FOCUSABLE, arg2 );
24998     } CALL_CATCH_EXCEPTION();
24999   }
25000
25001 }
25002
25003
25004 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsTouchFocusable(void * jarg1) {
25005   bool jresult ;
25006   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25007   bool result;
25008
25009   if (!jarg1) {
25010     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25011     return 0;
25012   }
25013
25014   arg1 = (Dali::Actor *)jarg1;
25015   {
25016     try {
25017       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( DevelActor::Property::TOUCH_FOCUSABLE );
25018     } CALL_CATCH_EXCEPTION(0);
25019   }
25020
25021   jresult = result;
25022   return jresult;
25023 }
25024
25025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
25026   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25027   Dali::ResizePolicy::Type arg2 ;
25028   Dali::Dimension::Type arg3 ;
25029
25030   if (!jarg1) {
25031     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25032     return ;
25033   }
25034
25035   arg1 = (Dali::Actor *)jarg1;
25036   arg2 = (Dali::ResizePolicy::Type)jarg2;
25037   arg3 = (Dali::Dimension::Type)jarg3;
25038   {
25039     try {
25040       (arg1)->SetResizePolicy(arg2,arg3);
25041     } CALL_CATCH_EXCEPTION();
25042   }
25043
25044 }
25045
25046
25047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
25048   int jresult ;
25049   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25050   Dali::Dimension::Type arg2 ;
25051   Dali::ResizePolicy::Type result;
25052
25053   if (!jarg1) {
25054     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25055     return 0;
25056   }
25057
25058   arg1 = (Dali::Actor *)jarg1;
25059   arg2 = (Dali::Dimension::Type)jarg2;
25060   {
25061     try {
25062       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
25063     } CALL_CATCH_EXCEPTION(0);
25064   }
25065
25066   jresult = (int)result;
25067   return jresult;
25068 }
25069
25070
25071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
25072   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25073   Dali::SizeScalePolicy::Type arg2 ;
25074
25075   if (!jarg1) {
25076     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25077     return ;
25078   }
25079
25080   arg1 = (Dali::Actor *)jarg1;
25081   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
25082   {
25083     try {
25084       (arg1)->SetProperty( Actor::Property::SIZE_SCALE_POLICY,arg2);
25085     } CALL_CATCH_EXCEPTION();
25086   }
25087
25088 }
25089
25090
25091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
25092   int jresult ;
25093   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25094   Dali::SizeScalePolicy::Type result;
25095
25096   if (!jarg1) {
25097     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25098     return 0;
25099   }
25100
25101   arg1 = (Dali::Actor *)jarg1;
25102   {
25103     try {
25104       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY );
25105     } CALL_CATCH_EXCEPTION(0);
25106   }
25107
25108   jresult = (int)result;
25109   return jresult;
25110 }
25111
25112
25113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
25114   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25115   Dali::Vector3 *arg2 = 0 ;
25116
25117   if (!jarg1) {
25118     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25119     return ;
25120   }
25121
25122   arg1 = (Dali::Actor *)jarg1;
25123   arg2 = (Dali::Vector3 *)jarg2;
25124   if (!arg2) {
25125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25126     return ;
25127   }
25128   {
25129     try {
25130       (arg1)->SetProperty( Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const &)*arg2);
25131     } CALL_CATCH_EXCEPTION();
25132   }
25133
25134 }
25135
25136
25137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
25138   void * jresult ;
25139   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25140   Dali::Vector3 result;
25141
25142   if (!jarg1) {
25143     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25144     return 0;
25145   }
25146
25147   arg1 = (Dali::Actor *)jarg1;
25148   {
25149     try {
25150       result = ((Dali::Actor const *)arg1)->GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR );
25151     } CALL_CATCH_EXCEPTION(0);
25152   }
25153
25154   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
25155   return jresult;
25156 }
25157
25158
25159 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
25160   float jresult ;
25161   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25162   float arg2 ;
25163   float result;
25164
25165   if (!jarg1) {
25166     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25167     return 0;
25168   }
25169
25170   arg1 = (Dali::Actor *)jarg1;
25171   arg2 = (float)jarg2;
25172   {
25173     try {
25174       result = (float)(arg1)->GetHeightForWidth(arg2);
25175     } CALL_CATCH_EXCEPTION(0);
25176   }
25177
25178   jresult = result;
25179   return jresult;
25180 }
25181
25182
25183 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
25184   float jresult ;
25185   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25186   float arg2 ;
25187   float result;
25188
25189   if (!jarg1) {
25190     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25191     return 0;
25192   }
25193
25194   arg1 = (Dali::Actor *)jarg1;
25195   arg2 = (float)jarg2;
25196   {
25197     try {
25198       result = (float)(arg1)->GetWidthForHeight(arg2);
25199     } CALL_CATCH_EXCEPTION(0);
25200   }
25201
25202   jresult = result;
25203   return jresult;
25204 }
25205
25206
25207 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
25208   float jresult ;
25209   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25210   Dali::Dimension::Type arg2 ;
25211   float result;
25212
25213   if (!jarg1) {
25214     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25215     return 0;
25216   }
25217
25218   arg1 = (Dali::Actor *)jarg1;
25219   arg2 = (Dali::Dimension::Type)jarg2;
25220   {
25221     try {
25222       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
25223     } CALL_CATCH_EXCEPTION(0);
25224   }
25225
25226   jresult = result;
25227   return jresult;
25228 }
25229
25230
25231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
25232   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25233   Dali::Padding *arg2 = 0 ;
25234
25235   if (!jarg1) {
25236     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25237     return ;
25238   }
25239
25240   arg1 = (Dali::Actor *)jarg1;
25241   arg2 = (Dali::Padding *)jarg2;
25242   if (!arg2) {
25243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
25244     return ;
25245   }
25246   {
25247     try {
25248       (arg1)->SetProperty( Actor::Property::PADDING, (Dali::Padding const &)*arg2);
25249     } CALL_CATCH_EXCEPTION();
25250   }
25251
25252 }
25253
25254
25255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
25256   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25257   Dali::Padding *arg2 = 0 ;
25258
25259   if (!jarg1) {
25260     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25261     return ;
25262   }
25263
25264   arg1 = (Dali::Actor *)jarg1;
25265   arg2 = (Dali::Padding *)jarg2;
25266   if (!arg2) {
25267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
25268     return ;
25269   }
25270   {
25271     try {
25272       *arg2 = ((Dali::Actor const *)arg1)->GetProperty<Vector4>( Actor::Property::PADDING );
25273     } CALL_CATCH_EXCEPTION();
25274   }
25275
25276 }
25277
25278
25279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
25280   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25281   Dali::Vector2 *arg2 = 0 ;
25282
25283   if (!jarg1) {
25284     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25285     return ;
25286   }
25287
25288   arg1 = (Dali::Actor *)jarg1;
25289   arg2 = (Dali::Vector2 *)jarg2;
25290   if (!arg2) {
25291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
25292     return ;
25293   }
25294   {
25295     try {
25296       (arg1)->SetProperty( Actor::Property::MINIMUM_SIZE,(Dali::Vector2 const &)*arg2);
25297     } CALL_CATCH_EXCEPTION();
25298   }
25299
25300 }
25301
25302
25303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
25304   void * jresult ;
25305   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25306   Dali::Vector2 result;
25307
25308   if (!jarg1) {
25309     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25310     return 0;
25311   }
25312
25313   arg1 = (Dali::Actor *)jarg1;
25314   {
25315     try {
25316       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
25317     } CALL_CATCH_EXCEPTION(0);
25318   }
25319
25320   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25321   return jresult;
25322 }
25323
25324
25325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
25326   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25327   Dali::Vector2 *arg2 = 0 ;
25328
25329   if (!jarg1) {
25330     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25331     return ;
25332   }
25333
25334   arg1 = (Dali::Actor *)jarg1;
25335   arg2 = (Dali::Vector2 *)jarg2;
25336   if (!arg2) {
25337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
25338     return ;
25339   }
25340   {
25341     try {
25342       (arg1)->SetProperty( Actor::Property::MAXIMUM_SIZE,(Dali::Vector2 const &)*arg2);
25343     } CALL_CATCH_EXCEPTION();
25344   }
25345
25346 }
25347
25348
25349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
25350   void * jresult ;
25351   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25352   Dali::Vector2 result;
25353
25354   if (!jarg1) {
25355     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25356     return 0;
25357   }
25358
25359   arg1 = (Dali::Actor *)jarg1;
25360   {
25361     try {
25362       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
25363     } CALL_CATCH_EXCEPTION(0);
25364   }
25365
25366   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25367   return jresult;
25368 }
25369
25370
25371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
25372   int jresult ;
25373   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25374   int result;
25375
25376   if (!jarg1) {
25377     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25378     return 0;
25379   }
25380
25381   arg1 = (Dali::Actor *)jarg1;
25382   {
25383     try {
25384       result = (int)(arg1)->GetProperty< int >( Actor::Property::HIERARCHY_DEPTH );
25385       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
25386     } CALL_CATCH_EXCEPTION(0);
25387   }
25388
25389   jresult = result;
25390   return jresult;
25391 }
25392
25393
25394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
25395   unsigned int jresult ;
25396   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25397   Dali::Renderer *arg2 = 0 ;
25398   unsigned int result;
25399
25400   if (!jarg1) {
25401     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25402     return 0;
25403   }
25404
25405   arg1 = (Dali::Actor *)jarg1;
25406   arg2 = (Dali::Renderer *)jarg2;
25407   if (!arg2) {
25408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
25409     return 0;
25410   }
25411   {
25412     try {
25413       result = (unsigned int)(arg1)->AddRenderer(*arg2);
25414     } CALL_CATCH_EXCEPTION(0);
25415   }
25416
25417   jresult = result;
25418   return jresult;
25419 }
25420
25421
25422 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
25423   unsigned int jresult ;
25424   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25425   unsigned int result;
25426
25427   if (!jarg1) {
25428     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25429     return 0;
25430   }
25431
25432   arg1 = (Dali::Actor *)jarg1;
25433   {
25434     try {
25435       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
25436     } CALL_CATCH_EXCEPTION(0);
25437   }
25438
25439   jresult = result;
25440   return jresult;
25441 }
25442
25443
25444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
25445   void * jresult ;
25446   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25447   unsigned int arg2 ;
25448   Dali::Renderer result;
25449
25450   if (!jarg1) {
25451     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25452     return 0;
25453   }
25454
25455   arg1 = (Dali::Actor *)jarg1;
25456   arg2 = (unsigned int)jarg2;
25457   {
25458     try {
25459       result = (arg1)->GetRendererAt(arg2);
25460     } CALL_CATCH_EXCEPTION(0);
25461   }
25462
25463   jresult = new Dali::Renderer((const Dali::Renderer &)result);
25464   return jresult;
25465 }
25466
25467
25468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
25469   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25470   Dali::Renderer *arg2 = 0 ;
25471
25472   if (!jarg1) {
25473     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25474     return ;
25475   }
25476
25477   arg1 = (Dali::Actor *)jarg1;
25478   arg2 = (Dali::Renderer *)jarg2;
25479   if (!arg2) {
25480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
25481     return ;
25482   }
25483   {
25484     try {
25485       (arg1)->RemoveRenderer(*arg2);
25486     } CALL_CATCH_EXCEPTION();
25487   }
25488
25489 }
25490
25491
25492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
25493   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25494   unsigned int arg2 ;
25495
25496   if (!jarg1) {
25497     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25498     return ;
25499   }
25500
25501   arg1 = (Dali::Actor *)jarg1;
25502   arg2 = (unsigned int)jarg2;
25503   {
25504     try {
25505       (arg1)->RemoveRenderer(arg2);
25506     } CALL_CATCH_EXCEPTION();
25507   }
25508
25509 }
25510
25511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HitTestResultSignal(void * jarg1) {
25512   void * jresult ;
25513   Dali::Actor arg1 ;
25514   Dali::Actor *argp1 = (Dali::Actor *) 0 ;
25515   Dali::Actor::TouchEventSignalType *result = 0 ;
25516
25517
25518   argp1 = (Dali::Actor *)jarg1;
25519   if (!argp1) {
25520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25521     return 0;
25522   }
25523   arg1 = *argp1;
25524   {
25525     try {
25526       result = (Dali::Actor::TouchEventSignalType *) &Dali::DevelActor::HitTestResultSignal(arg1);
25527     } CALL_CATCH_EXCEPTION(0);
25528   }
25529
25530   jresult = (void *)result;
25531   return jresult;
25532 }
25533
25534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_InterceptTouchSignal(void * jarg1) {
25535   void * jresult ;
25536   Dali::Actor arg1 ;
25537   Dali::Actor *argp1 = (Dali::Actor *) 0 ;
25538   Dali::Actor::TouchEventSignalType *result = 0 ;
25539
25540
25541   argp1 = (Dali::Actor *)jarg1;
25542   if (!argp1) {
25543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25544     return 0;
25545   }
25546   arg1 = *argp1;
25547   {
25548     try {
25549       result = (Dali::Actor::TouchEventSignalType *) &Dali::DevelActor::InterceptTouchedSignal(arg1);
25550     } CALL_CATCH_EXCEPTION(0);
25551   }
25552
25553   jresult = (void *)result;
25554   return jresult;
25555 }
25556
25557
25558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
25559   void * jresult ;
25560   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25561   Dali::Actor::TouchEventSignalType *result = 0 ;
25562
25563   if (!jarg1) {
25564     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25565     return 0;
25566   }
25567
25568   arg1 = (Dali::Actor *)jarg1;
25569   {
25570     try {
25571       result = (Dali::Actor::TouchEventSignalType *) &(arg1)->TouchedSignal();
25572     } CALL_CATCH_EXCEPTION(0);
25573   }
25574
25575   jresult = (void *)result;
25576   return jresult;
25577 }
25578
25579
25580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
25581   void * jresult ;
25582   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25583   Dali::Actor::HoverSignalType *result = 0 ;
25584
25585   if (!jarg1) {
25586     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25587     return 0;
25588   }
25589
25590   arg1 = (Dali::Actor *)jarg1;
25591   {
25592     try {
25593       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
25594     } CALL_CATCH_EXCEPTION(0);
25595   }
25596
25597   jresult = (void *)result;
25598   return jresult;
25599 }
25600
25601
25602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
25603   void * jresult ;
25604   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25605   Dali::Actor::WheelEventSignalType *result = 0 ;
25606
25607   if (!jarg1) {
25608     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25609     return 0;
25610   }
25611
25612   arg1 = (Dali::Actor *)jarg1;
25613   {
25614     try {
25615       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
25616     } CALL_CATCH_EXCEPTION(0);
25617   }
25618
25619   jresult = (void *)result;
25620   return jresult;
25621 }
25622
25623
25624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnSceneSignal(void * jarg1) {
25625   void * jresult ;
25626   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25627   Dali::Actor::OnSceneSignalType *result = 0 ;
25628
25629   if (!jarg1) {
25630     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25631     return 0;
25632   }
25633
25634   arg1 = (Dali::Actor *)jarg1;
25635   {
25636     try {
25637       result = (Dali::Actor::OnSceneSignalType *) &(arg1)->OnSceneSignal();
25638     } CALL_CATCH_EXCEPTION(0);
25639   }
25640
25641   jresult = (void *)result;
25642   return jresult;
25643 }
25644
25645
25646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffSceneSignal(void * jarg1) {
25647   void * jresult ;
25648   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25649   Dali::Actor::OffSceneSignalType *result = 0 ;
25650
25651   if (!jarg1) {
25652     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25653     return 0;
25654   }
25655
25656   arg1 = (Dali::Actor *)jarg1;
25657   {
25658     try {
25659       result = (Dali::Actor::OffSceneSignalType *) &(arg1)->OffSceneSignal();
25660     } CALL_CATCH_EXCEPTION(0);
25661   }
25662
25663   jresult = (void *)result;
25664   return jresult;
25665 }
25666
25667
25668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
25669   void * jresult ;
25670   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25671   Dali::Actor::OnRelayoutSignalType *result = 0 ;
25672
25673   if (!jarg1) {
25674     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25675     return 0;
25676   }
25677
25678   arg1 = (Dali::Actor *)jarg1;
25679   {
25680     try {
25681       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
25682     } CALL_CATCH_EXCEPTION(0);
25683   }
25684
25685   jresult = (void *)result;
25686   return jresult;
25687 }
25688
25689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetNeedGesturePropagation(void * jarg1, bool jarg2) {
25690   Dali::Actor arg1 ;
25691   bool arg2;
25692   Dali::Actor *argp1 = (Dali::Actor *) 0 ;
25693
25694
25695   argp1 = (Dali::Actor *)jarg1;
25696   if (!argp1) {
25697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25698     return;
25699   }
25700   arg1 = *argp1;
25701   arg2 = jarg2;
25702   {
25703     try {
25704       Dali::DevelActor::SetNeedGesturePropagation(arg1, arg2);
25705     } CALL_CATCH_EXCEPTION();
25706   }
25707   return;
25708 }
25709
25710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_CalculateScreenExtents(void * actor) {
25711   Dali::Actor arg1 ;
25712   Dali::Actor *argp1 = (Dali::Actor *) 0 ;
25713   Dali::Rect<float> result;
25714
25715   argp1 = (Dali::Actor *)actor;
25716   if (!argp1) {
25717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25718     return 0;
25719   }
25720   arg1 = *argp1;
25721   {
25722     try {
25723       result = Dali::DevelActor::CalculateScreenExtents(arg1);
25724     } CALL_CATCH_EXCEPTION(0);
25725   }
25726
25727   // Note: The float type Rectangle class is not ready yet.
25728   //      Therefore, it transmits data in Vector4 class.
25729   //      This type should later be changed to the appropriate data type.
25730   return new Dali::Vector4(result.x, result.y, result.width, result.height);
25731 }
25732
25733
25734 SWIGEXPORT void SWIGSTDCALL CSharp_DevelActor_Property_SetTouchAreaOffset(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
25735   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25736   arg1 = (Dali::Actor *)jarg1;
25737   Rect<int> arg2 = Rect(jarg2, jarg3, jarg4, jarg5);
25738   {
25739     try {
25740       (arg1)->SetProperty( Dali::DevelActor::Property::TOUCH_AREA_OFFSET, arg2 );
25741     } CALL_CATCH_EXCEPTION();
25742   }
25743 }
25744
25745 SWIGEXPORT void SWIGSTDCALL CSharp_DevelActor_Property_GetTouchAreaOffset(void * jarg1, int* jarg2, int* jarg3, int* jarg4, int* jarg5) {
25746   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25747   arg1 = (Dali::Actor *)jarg1;
25748
25749   Rect<int32_t> result;
25750   {
25751     try {
25752       result = (arg1)->GetProperty<Rect<int32_t>>( Dali::DevelActor::Property::TOUCH_AREA_OFFSET);
25753       *jarg2 = result.left;
25754       *jarg3 = result.right;
25755       *jarg4 = result.bottom;
25756       *jarg5 = result.top;
25757     } CALL_CATCH_EXCEPTION();
25758   }
25759 }
25760
25761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
25762   Dali::Actor *arg1 = 0 ;
25763
25764   arg1 = (Dali::Actor *)jarg1;
25765   if (!arg1) {
25766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
25767     return ;
25768   }
25769   {
25770     try {
25771       Dali::UnparentAndReset(*arg1);
25772     } CALL_CATCH_EXCEPTION();
25773   }
25774
25775 }
25776
25777
25778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
25779   int jresult ;
25780   int result;
25781
25782   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
25783   jresult = (int)result;
25784   return jresult;
25785 }
25786
25787
25788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
25789   int jresult ;
25790   int result;
25791
25792   result = (int)Dali::Layer::Property::CLIPPING_BOX;
25793   jresult = (int)result;
25794   return jresult;
25795 }
25796
25797
25798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
25799   int jresult ;
25800   int result;
25801
25802   result = (int)Dali::Layer::Property::BEHAVIOR;
25803   jresult = (int)result;
25804   return jresult;
25805 }
25806
25807
25808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
25809   void * jresult ;
25810   Dali::Layer::Property *result = 0 ;
25811
25812   {
25813     try {
25814       result = (Dali::Layer::Property *)new Dali::Layer::Property();
25815     } CALL_CATCH_EXCEPTION(0);
25816   }
25817
25818   jresult = (void *)result;
25819   return jresult;
25820 }
25821
25822
25823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
25824   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
25825
25826   arg1 = (Dali::Layer::Property *)jarg1;
25827   {
25828     try {
25829       delete arg1;
25830     } CALL_CATCH_EXCEPTION();
25831   }
25832
25833 }
25834
25835
25836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
25837   void * jresult ;
25838   Dali::Layer *result = 0 ;
25839
25840   {
25841     try {
25842       result = (Dali::Layer *)new Dali::Layer();
25843     } CALL_CATCH_EXCEPTION(0);
25844   }
25845
25846   jresult = (void *)result;
25847   return jresult;
25848 }
25849
25850
25851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
25852   void * jresult ;
25853   Dali::Layer result;
25854
25855   {
25856     try {
25857       result = Dali::Layer::New();
25858     } CALL_CATCH_EXCEPTION(0);
25859   }
25860
25861   jresult = new Dali::Layer((const Dali::Layer &)result);
25862   return jresult;
25863 }
25864
25865
25866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
25867   void * jresult ;
25868   Dali::BaseHandle arg1 ;
25869   Dali::BaseHandle *argp1 ;
25870   Dali::Layer result;
25871
25872   argp1 = (Dali::BaseHandle *)jarg1;
25873   if (!argp1) {
25874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25875     return 0;
25876   }
25877   arg1 = *argp1;
25878   {
25879     try {
25880       result = Dali::Layer::DownCast(arg1);
25881     } CALL_CATCH_EXCEPTION(0);
25882   }
25883
25884   jresult = new Dali::Layer((const Dali::Layer &)result);
25885   return jresult;
25886 }
25887
25888
25889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
25890   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25891
25892   arg1 = (Dali::Layer *)jarg1;
25893   {
25894     try {
25895       delete arg1;
25896     } CALL_CATCH_EXCEPTION();
25897   }
25898
25899 }
25900
25901
25902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
25903   void * jresult ;
25904   Dali::Layer *arg1 = 0 ;
25905   Dali::Layer *result = 0 ;
25906
25907   arg1 = (Dali::Layer *)jarg1;
25908   if (!arg1) {
25909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
25910     return 0;
25911   }
25912   {
25913     try {
25914       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
25915     } CALL_CATCH_EXCEPTION(0);
25916   }
25917
25918   jresult = (void *)result;
25919   return jresult;
25920 }
25921
25922
25923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
25924   void * jresult ;
25925   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25926   Dali::Layer *arg2 = 0 ;
25927   Dali::Layer *result = 0 ;
25928
25929   arg1 = (Dali::Layer *)jarg1;
25930   arg2 = (Dali::Layer *)jarg2;
25931   if (!arg2) {
25932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
25933     return 0;
25934   }
25935   {
25936     try {
25937       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
25938     } CALL_CATCH_EXCEPTION(0);
25939   }
25940
25941   jresult = (void *)result;
25942   return jresult;
25943 }
25944
25945
25946 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
25947   unsigned int jresult ;
25948   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25949   unsigned int result;
25950
25951   arg1 = (Dali::Layer *)jarg1;
25952   {
25953     try {
25954       result = (unsigned int)((Dali::Layer const *)arg1)->GetProperty< int >( Layer::Property::DEPTH );
25955     } CALL_CATCH_EXCEPTION(0);
25956   }
25957
25958   jresult = result;
25959   return jresult;
25960 }
25961
25962
25963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
25964   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25965
25966   arg1 = (Dali::Layer *)jarg1;
25967   {
25968     try {
25969       (arg1)->Raise();
25970     } CALL_CATCH_EXCEPTION();
25971   }
25972
25973 }
25974
25975
25976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
25977   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25978
25979   arg1 = (Dali::Layer *)jarg1;
25980   {
25981     try {
25982       (arg1)->Lower();
25983     } CALL_CATCH_EXCEPTION();
25984   }
25985
25986 }
25987
25988
25989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
25990   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25991   Dali::Layer arg2 ;
25992   Dali::Layer *argp2 ;
25993
25994   arg1 = (Dali::Layer *)jarg1;
25995   argp2 = (Dali::Layer *)jarg2;
25996   if (!argp2) {
25997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
25998     return ;
25999   }
26000   arg2 = *argp2;
26001   {
26002     try {
26003       (arg1)->RaiseAbove(arg2);
26004     } CALL_CATCH_EXCEPTION();
26005   }
26006
26007 }
26008
26009
26010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
26011   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26012   Dali::Layer arg2 ;
26013   Dali::Layer *argp2 ;
26014
26015   arg1 = (Dali::Layer *)jarg1;
26016   argp2 = (Dali::Layer *)jarg2;
26017   if (!argp2) {
26018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
26019     return ;
26020   }
26021   arg2 = *argp2;
26022   {
26023     try {
26024       (arg1)->LowerBelow(arg2);
26025     } CALL_CATCH_EXCEPTION();
26026   }
26027
26028 }
26029
26030
26031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
26032   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26033
26034   arg1 = (Dali::Layer *)jarg1;
26035   {
26036     try {
26037       (arg1)->RaiseToTop();
26038     } CALL_CATCH_EXCEPTION();
26039   }
26040
26041 }
26042
26043
26044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
26045   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26046
26047   arg1 = (Dali::Layer *)jarg1;
26048   {
26049     try {
26050       (arg1)->LowerToBottom();
26051     } CALL_CATCH_EXCEPTION();
26052   }
26053
26054 }
26055
26056
26057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
26058   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26059   Dali::Layer arg2 ;
26060   Dali::Layer *argp2 ;
26061
26062   arg1 = (Dali::Layer *)jarg1;
26063   argp2 = (Dali::Layer *)jarg2;
26064   if (!argp2) {
26065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
26066     return ;
26067   }
26068   arg2 = *argp2;
26069   {
26070     try {
26071       (arg1)->MoveAbove(arg2);
26072     } CALL_CATCH_EXCEPTION();
26073   }
26074
26075 }
26076
26077
26078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
26079   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26080   Dali::Layer arg2 ;
26081   Dali::Layer *argp2 ;
26082
26083   arg1 = (Dali::Layer *)jarg1;
26084   argp2 = (Dali::Layer *)jarg2;
26085   if (!argp2) {
26086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
26087     return ;
26088   }
26089   arg2 = *argp2;
26090   {
26091     try {
26092       (arg1)->MoveBelow(arg2);
26093     } CALL_CATCH_EXCEPTION();
26094   }
26095
26096 }
26097
26098
26099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
26100   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26101   Dali::Layer::Behavior arg2 ;
26102
26103   arg1 = (Dali::Layer *)jarg1;
26104   arg2 = (Dali::Layer::Behavior)jarg2;
26105   {
26106     try {
26107       (arg1)->SetProperty( Layer::Property::BEHAVIOR, arg2 );
26108     } CALL_CATCH_EXCEPTION();
26109   }
26110
26111 }
26112
26113
26114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
26115   int jresult ;
26116   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26117   Dali::Layer::Behavior result;
26118
26119   arg1 = (Dali::Layer *)jarg1;
26120   {
26121     try {
26122       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetProperty<Dali::Layer::Behavior>( Dali::Layer::Property::BEHAVIOR );
26123     } CALL_CATCH_EXCEPTION(0);
26124   }
26125
26126   jresult = (int)result;
26127   return jresult;
26128 }
26129
26130
26131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, bool jarg2) {
26132   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26133   bool arg2 ;
26134
26135   arg1 = (Dali::Layer *)jarg1;
26136   arg2 = jarg2 ? true : false;
26137   {
26138     try {
26139       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_ENABLE, arg2 );
26140     } CALL_CATCH_EXCEPTION();
26141   }
26142
26143 }
26144
26145
26146 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
26147   bool jresult ;
26148   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26149   bool result;
26150
26151   arg1 = (Dali::Layer *)jarg1;
26152   {
26153     try {
26154       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Dali::Layer::Property::CLIPPING_ENABLE );
26155     } CALL_CATCH_EXCEPTION(0);
26156   }
26157
26158   jresult = result;
26159   return jresult;
26160 }
26161
26162
26163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
26164   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26165   int arg2 ;
26166   int arg3 ;
26167   int arg4 ;
26168   int arg5 ;
26169
26170   arg1 = (Dali::Layer *)jarg1;
26171   arg2 = (int)jarg2;
26172   arg3 = (int)jarg3;
26173   arg4 = (int)jarg4;
26174   arg5 = (int)jarg5;
26175   {
26176     try {
26177       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, Rect<int32_t>( arg2,arg3,arg4,arg5 ) );
26178     } CALL_CATCH_EXCEPTION();
26179   }
26180
26181 }
26182
26183
26184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
26185   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26186   Dali::ClippingBox arg2 ;
26187   Dali::ClippingBox *argp2 ;
26188
26189   arg1 = (Dali::Layer *)jarg1;
26190   argp2 = (Dali::ClippingBox *)jarg2;
26191   if (!argp2) {
26192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
26193     return ;
26194   }
26195   arg2 = *argp2;
26196   {
26197     try {
26198       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, arg2 );
26199     } CALL_CATCH_EXCEPTION();
26200   }
26201
26202 }
26203
26204
26205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
26206   void * jresult ;
26207   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26208   Dali::ClippingBox result;
26209
26210   arg1 = (Dali::Layer *)jarg1;
26211   {
26212     try {
26213       result = ((Dali::Layer const *)arg1)->GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX );
26214     } CALL_CATCH_EXCEPTION(0);
26215   }
26216
26217   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
26218   return jresult;
26219 }
26220
26221
26222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, bool jarg2) {
26223   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26224   bool arg2 ;
26225
26226   arg1 = (Dali::Layer *)jarg1;
26227   arg2 = jarg2 ? true : false;
26228   {
26229     try {
26230       (arg1)->SetProperty( Layer::Property::DEPTH_TEST, !arg2 );
26231     } CALL_CATCH_EXCEPTION();
26232   }
26233
26234 }
26235
26236
26237 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
26238   bool jresult ;
26239   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26240   bool result;
26241
26242   arg1 = (Dali::Layer *)jarg1;
26243   {
26244     try {
26245       result = !(bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::DEPTH_TEST );
26246     } CALL_CATCH_EXCEPTION(0);
26247   }
26248
26249   jresult = result;
26250   return jresult;
26251 }
26252
26253
26254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
26255   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26256   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
26257
26258   arg1 = (Dali::Layer *)jarg1;
26259   arg2 = (Dali::Layer::SortFunctionType)jarg2;
26260   {
26261     try {
26262       (arg1)->SetSortFunction(arg2);
26263     } CALL_CATCH_EXCEPTION();
26264   }
26265
26266 }
26267
26268
26269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, bool jarg2) {
26270   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26271   bool arg2 ;
26272
26273   arg1 = (Dali::Layer *)jarg1;
26274   arg2 = jarg2 ? true : false;
26275   {
26276     try {
26277       (arg1)->SetProperty( Layer::Property::CONSUMES_TOUCH, arg2 );
26278     } CALL_CATCH_EXCEPTION();
26279   }
26280
26281 }
26282
26283
26284 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
26285   bool jresult ;
26286   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26287   bool result;
26288
26289   arg1 = (Dali::Layer *)jarg1;
26290   {
26291     try {
26292       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_TOUCH );
26293     } CALL_CATCH_EXCEPTION(0);
26294   }
26295
26296   jresult = result;
26297   return jresult;
26298 }
26299
26300
26301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, bool jarg2) {
26302   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26303   bool arg2 ;
26304
26305   arg1 = (Dali::Layer *)jarg1;
26306   arg2 = jarg2 ? true : false;
26307   {
26308     try {
26309       (arg1)->SetProperty( Layer::Property::CONSUMES_HOVER, arg2 );
26310     } CALL_CATCH_EXCEPTION();
26311   }
26312
26313 }
26314
26315
26316 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
26317   bool jresult ;
26318   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26319   bool result;
26320
26321   arg1 = (Dali::Layer *)jarg1;
26322   {
26323     try {
26324       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_HOVER );
26325     } CALL_CATCH_EXCEPTION(0);
26326   }
26327
26328   jresult = result;
26329   return jresult;
26330 }
26331
26332
26333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
26334   void * jresult ;
26335   Dali::Stage result;
26336
26337   {
26338     try {
26339       result = Dali::Stage::GetCurrent();
26340     } CALL_CATCH_EXCEPTION(0);
26341   }
26342
26343   jresult = new Dali::Stage((const Dali::Stage &)result);
26344   return jresult;
26345 }
26346
26347
26348 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
26349   bool jresult ;
26350   bool result;
26351
26352   {
26353     try {
26354       result = (bool)Dali::Stage::IsInstalled();
26355     } CALL_CATCH_EXCEPTION(0);
26356   }
26357
26358   jresult = result;
26359   return jresult;
26360 }
26361
26362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
26363   void * jresult ;
26364   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
26365   Dali::RenderTaskList result;
26366
26367   arg1 = (Dali::Stage *)jarg1;
26368   {
26369     try {
26370       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
26371     } CALL_CATCH_EXCEPTION(0);
26372   }
26373
26374   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
26375   return jresult;
26376 }
26377
26378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
26379   void * jresult ;
26380   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
26381   Dali::Vector2 result;
26382
26383   arg1 = (Dali::Stage *)jarg1;
26384   {
26385     try {
26386       result = ((Dali::Stage const *)arg1)->GetDpi();
26387     } CALL_CATCH_EXCEPTION(0);
26388   }
26389
26390   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
26391   return jresult;
26392 }
26393
26394
26395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
26396   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
26397   float arg2 ;
26398
26399   arg1 = (Dali::Stage *)jarg1;
26400   arg2 = (float)jarg2;
26401   {
26402     try {
26403       (arg1)->KeepRendering(arg2);
26404     } CALL_CATCH_EXCEPTION();
26405   }
26406
26407 }
26408
26409
26410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
26411   void * jresult ;
26412   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
26413   Dali::Stage::KeyEventSignalType *result = 0 ;
26414
26415   arg1 = (Dali::Stage *)jarg1;
26416   {
26417     try {
26418       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
26419     } CALL_CATCH_EXCEPTION(0);
26420   }
26421
26422   jresult = (void *)result;
26423   return jresult;
26424 }
26425
26426
26427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
26428   void * jresult ;
26429   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
26430   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
26431
26432   arg1 = (Dali::Stage *)jarg1;
26433   {
26434     try {
26435       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
26436     } CALL_CATCH_EXCEPTION(0);
26437   }
26438
26439   jresult = (void *)result;
26440   return jresult;
26441 }
26442
26443
26444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
26445   void * jresult ;
26446   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
26447   Dali::Stage::TouchEventSignalType *result = 0 ;
26448
26449   arg1 = (Dali::Stage *)jarg1;
26450   {
26451     try {
26452       result = (Dali::Stage::TouchEventSignalType *) &(arg1)->TouchedSignal();
26453     } CALL_CATCH_EXCEPTION(0);
26454   }
26455
26456   jresult = (void *)result;
26457   return jresult;
26458 }
26459
26460
26461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
26462   void * jresult ;
26463   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
26464   Dali::Stage::WheelEventSignalType *result = 0 ;
26465
26466   arg1 = (Dali::Stage *)jarg1;
26467   {
26468     try {
26469       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
26470     } CALL_CATCH_EXCEPTION(0);
26471   }
26472
26473   jresult = (void *)result;
26474   return jresult;
26475 }
26476
26477
26478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
26479   void * jresult ;
26480   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
26481   Dali::Stage::ContextStatusSignal *result = 0 ;
26482
26483   arg1 = (Dali::Stage *)jarg1;
26484   {
26485     try {
26486       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
26487     } CALL_CATCH_EXCEPTION(0);
26488   }
26489
26490   jresult = (void *)result;
26491   return jresult;
26492 }
26493
26494
26495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
26496   void * jresult ;
26497   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
26498   Dali::Stage::ContextStatusSignal *result = 0 ;
26499
26500   arg1 = (Dali::Stage *)jarg1;
26501   {
26502     try {
26503       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
26504     } CALL_CATCH_EXCEPTION(0);
26505   }
26506
26507   jresult = (void *)result;
26508   return jresult;
26509 }
26510
26511
26512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
26513   void * jresult ;
26514   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
26515   Dali::Stage::SceneCreatedSignalType *result = 0 ;
26516
26517   arg1 = (Dali::Stage *)jarg1;
26518   {
26519     try {
26520       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
26521     } CALL_CATCH_EXCEPTION(0);
26522   }
26523
26524   jresult = (void *)result;
26525   return jresult;
26526 }
26527
26528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
26529   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
26530   Dali::DevelStage::Rendering arg2 ;
26531
26532   arg1 = (Dali::Stage *)jarg1;
26533   arg2 = (Dali::DevelStage::Rendering)jarg2;
26534   {
26535     try {
26536       DevelStage::SetRenderingBehavior(*arg1,arg2);
26537     } CALL_CATCH_EXCEPTION();
26538   }
26539
26540 }
26541
26542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
26543
26544   int jresult ;
26545   int result ;
26546   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
26547
26548   arg1 = (Dali::Stage *)jarg1;
26549   {
26550     try {
26551       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
26552     } CALL_CATCH_EXCEPTION(0);
26553   }
26554
26555   jresult = result;
26556   return jresult;
26557 }
26558
26559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
26560   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
26561
26562   arg1 = (Dali::RelayoutContainer *)jarg1;
26563   {
26564     try {
26565       delete arg1;
26566     } CALL_CATCH_EXCEPTION();
26567   }
26568
26569 }
26570
26571
26572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
26573   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
26574   Dali::Actor *arg2 = 0 ;
26575   Dali::Vector2 *arg3 = 0 ;
26576
26577   arg1 = (Dali::RelayoutContainer *)jarg1;
26578   arg2 = (Dali::Actor *)jarg2;
26579   if (!arg2) {
26580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
26581     return ;
26582   }
26583   arg3 = (Dali::Vector2 *)jarg3;
26584   if (!arg3) {
26585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
26586     return ;
26587   }
26588   {
26589     try {
26590       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
26591     } CALL_CATCH_EXCEPTION();
26592   }
26593
26594 }
26595
26596
26597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
26598   void * jresult ;
26599   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26600   Dali::CustomActor result;
26601
26602   arg1 = (Dali::CustomActorImpl *)jarg1;
26603   {
26604     try {
26605       result = ((Dali::CustomActorImpl const *)arg1)->Self();
26606     } CALL_CATCH_EXCEPTION(0);
26607   }
26608
26609   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
26610   return jresult;
26611 }
26612
26613
26614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneConnection(void * jarg1, int jarg2) {
26615   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26616   int arg2 ;
26617
26618   arg1 = (Dali::CustomActorImpl *)jarg1;
26619   arg2 = (int)jarg2;
26620   {
26621     try {
26622       (arg1)->OnSceneConnection(arg2);
26623     } CALL_CATCH_EXCEPTION();
26624   }
26625
26626 }
26627
26628
26629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneDisconnection(void * jarg1) {
26630   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26631
26632   arg1 = (Dali::CustomActorImpl *)jarg1;
26633   {
26634     try {
26635       (arg1)->OnSceneDisconnection();
26636     } CALL_CATCH_EXCEPTION();
26637   }
26638
26639 }
26640
26641
26642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
26643   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26644   Dali::Actor *arg2 = 0 ;
26645
26646   arg1 = (Dali::CustomActorImpl *)jarg1;
26647   arg2 = (Dali::Actor *)jarg2;
26648   if (!arg2) {
26649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
26650     return ;
26651   }
26652   {
26653     try {
26654       (arg1)->OnChildAdd(*arg2);
26655     } CALL_CATCH_EXCEPTION();
26656   }
26657
26658 }
26659
26660
26661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
26662   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26663   Dali::Actor *arg2 = 0 ;
26664
26665   arg1 = (Dali::CustomActorImpl *)jarg1;
26666   arg2 = (Dali::Actor *)jarg2;
26667   if (!arg2) {
26668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
26669     return ;
26670   }
26671   {
26672     try {
26673       (arg1)->OnChildRemove(*arg2);
26674     } CALL_CATCH_EXCEPTION();
26675   }
26676
26677 }
26678
26679
26680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
26681   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26682   Dali::Property::Index arg2 ;
26683   Dali::Property::Value arg3 ;
26684   Dali::Property::Value *argp3 ;
26685
26686   arg1 = (Dali::CustomActorImpl *)jarg1;
26687   arg2 = (Dali::Property::Index)jarg2;
26688   argp3 = (Dali::Property::Value *)jarg3;
26689   if (!argp3) {
26690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
26691     return ;
26692   }
26693   arg3 = *argp3;
26694   {
26695     try {
26696       (arg1)->OnPropertySet(arg2,arg3);
26697     } CALL_CATCH_EXCEPTION();
26698   }
26699
26700 }
26701
26702
26703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
26704   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26705   Dali::Vector3 *arg2 = 0 ;
26706
26707   arg1 = (Dali::CustomActorImpl *)jarg1;
26708   arg2 = (Dali::Vector3 *)jarg2;
26709   if (!arg2) {
26710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
26711     return ;
26712   }
26713   {
26714     try {
26715       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
26716     } CALL_CATCH_EXCEPTION();
26717   }
26718
26719 }
26720
26721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
26722   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26723   Dali::Animation *arg2 = 0 ;
26724   Dali::Vector3 *arg3 = 0 ;
26725
26726   arg1 = (Dali::CustomActorImpl *)jarg1;
26727   arg2 = (Dali::Animation *)jarg2;
26728   if (!arg2) {
26729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
26730     return ;
26731   }
26732   arg3 = (Dali::Vector3 *)jarg3;
26733   if (!arg3) {
26734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
26735     return ;
26736   }
26737   {
26738     try {
26739       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
26740     } CALL_CATCH_EXCEPTION();
26741   }
26742 }
26743
26744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
26745   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26746   Dali::Vector2 *arg2 = 0 ;
26747   Dali::RelayoutContainer *arg3 = 0 ;
26748
26749   arg1 = (Dali::CustomActorImpl *)jarg1;
26750   arg2 = (Dali::Vector2 *)jarg2;
26751   if (!arg2) {
26752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
26753     return ;
26754   }
26755   arg3 = (Dali::RelayoutContainer *)jarg3;
26756   if (!arg3) {
26757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
26758     return ;
26759   }
26760   {
26761     try {
26762       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
26763     } CALL_CATCH_EXCEPTION();
26764   }
26765
26766 }
26767
26768
26769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
26770   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26771   Dali::ResizePolicy::Type arg2 ;
26772   Dali::Dimension::Type arg3 ;
26773
26774   arg1 = (Dali::CustomActorImpl *)jarg1;
26775   arg2 = (Dali::ResizePolicy::Type)jarg2;
26776   arg3 = (Dali::Dimension::Type)jarg3;
26777   {
26778     try {
26779       (arg1)->OnSetResizePolicy(arg2,arg3);
26780     } CALL_CATCH_EXCEPTION();
26781   }
26782
26783 }
26784
26785
26786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
26787   void * jresult ;
26788   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26789   Dali::Vector3 result;
26790
26791   arg1 = (Dali::CustomActorImpl *)jarg1;
26792   {
26793     try {
26794       result = (arg1)->GetNaturalSize();
26795     } CALL_CATCH_EXCEPTION(0);
26796   }
26797
26798   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
26799   return jresult;
26800 }
26801
26802
26803 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
26804   float jresult ;
26805   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26806   Dali::Actor *arg2 = 0 ;
26807   Dali::Dimension::Type arg3 ;
26808   float result;
26809
26810   arg1 = (Dali::CustomActorImpl *)jarg1;
26811   arg2 = (Dali::Actor *)jarg2;
26812   if (!arg2) {
26813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
26814     return 0;
26815   }
26816   arg3 = (Dali::Dimension::Type)jarg3;
26817   {
26818     try {
26819       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
26820     } CALL_CATCH_EXCEPTION(0);
26821   }
26822
26823   jresult = result;
26824   return jresult;
26825 }
26826
26827
26828 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
26829   float jresult ;
26830   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26831   float arg2 ;
26832   float result;
26833
26834   arg1 = (Dali::CustomActorImpl *)jarg1;
26835   arg2 = (float)jarg2;
26836   {
26837     try {
26838       result = (float)(arg1)->GetHeightForWidth(arg2);
26839     } CALL_CATCH_EXCEPTION(0);
26840   }
26841
26842   jresult = result;
26843   return jresult;
26844 }
26845
26846
26847 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
26848   float jresult ;
26849   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26850   float arg2 ;
26851   float result;
26852
26853   arg1 = (Dali::CustomActorImpl *)jarg1;
26854   arg2 = (float)jarg2;
26855   {
26856     try {
26857       result = (float)(arg1)->GetWidthForHeight(arg2);
26858     } CALL_CATCH_EXCEPTION(0);
26859   }
26860
26861   jresult = result;
26862   return jresult;
26863 }
26864
26865
26866 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
26867   bool jresult ;
26868   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26869   Dali::Dimension::Type arg2 ;
26870   bool result;
26871
26872   arg1 = (Dali::CustomActorImpl *)jarg1;
26873   arg2 = (Dali::Dimension::Type)jarg2;
26874   {
26875     try {
26876       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
26877     } CALL_CATCH_EXCEPTION(0);
26878   }
26879
26880   jresult = result;
26881   return jresult;
26882 }
26883
26884
26885 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
26886   bool jresult ;
26887   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26888   bool result;
26889
26890   arg1 = (Dali::CustomActorImpl *)jarg1;
26891   {
26892     try {
26893       result = (bool)(arg1)->RelayoutDependentOnChildren();
26894     } CALL_CATCH_EXCEPTION(0);
26895   }
26896
26897   jresult = result;
26898   return jresult;
26899 }
26900
26901
26902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
26903   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26904   Dali::Dimension::Type arg2 ;
26905
26906   arg1 = (Dali::CustomActorImpl *)jarg1;
26907   arg2 = (Dali::Dimension::Type)jarg2;
26908   {
26909     try {
26910       (arg1)->OnCalculateRelayoutSize(arg2);
26911     } CALL_CATCH_EXCEPTION();
26912   }
26913
26914 }
26915
26916
26917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
26918   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26919   float arg2 ;
26920   Dali::Dimension::Type arg3 ;
26921
26922   arg1 = (Dali::CustomActorImpl *)jarg1;
26923   arg2 = (float)jarg2;
26924   arg3 = (Dali::Dimension::Type)jarg3;
26925   {
26926     try {
26927       (arg1)->OnLayoutNegotiated(arg2,arg3);
26928     } CALL_CATCH_EXCEPTION();
26929   }
26930
26931 }
26932
26933 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
26934   bool jresult ;
26935   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26936   bool result;
26937
26938   arg1 = (Dali::CustomActorImpl *)jarg1;
26939   {
26940     try {
26941       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
26942     } CALL_CATCH_EXCEPTION(0);
26943   }
26944
26945   jresult = result;
26946   return jresult;
26947 }
26948
26949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
26950   void * jresult ;
26951   Dali::CustomActor *result = 0 ;
26952
26953   {
26954     try {
26955       result = (Dali::CustomActor *)new Dali::CustomActor();
26956     } CALL_CATCH_EXCEPTION(0);
26957   }
26958
26959   jresult = (void *)result;
26960   return jresult;
26961 }
26962
26963
26964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
26965   void * jresult ;
26966   Dali::BaseHandle arg1 ;
26967   Dali::BaseHandle *argp1 ;
26968   Dali::CustomActor result;
26969
26970   argp1 = (Dali::BaseHandle *)jarg1;
26971   if (!argp1) {
26972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26973     return 0;
26974   }
26975   arg1 = *argp1;
26976   {
26977     try {
26978       result = Dali::CustomActor::DownCast(arg1);
26979     } CALL_CATCH_EXCEPTION(0);
26980   }
26981
26982   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
26983   return jresult;
26984 }
26985
26986
26987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
26988   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
26989
26990   arg1 = (Dali::CustomActor *)jarg1;
26991   {
26992     try {
26993       delete arg1;
26994     } CALL_CATCH_EXCEPTION();
26995   }
26996
26997 }
26998
26999
27000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
27001   void * jresult ;
27002   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
27003   Dali::CustomActorImpl *result = 0 ;
27004
27005   arg1 = (Dali::CustomActor *)jarg1;
27006   {
27007     try {
27008       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
27009     } CALL_CATCH_EXCEPTION(0);
27010   }
27011
27012   jresult = (void *)result;
27013   return jresult;
27014 }
27015
27016
27017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
27018   void * jresult ;
27019   Dali::CustomActorImpl *arg1 = 0 ;
27020   Dali::CustomActor *result = 0 ;
27021
27022   arg1 = (Dali::CustomActorImpl *)jarg1;
27023   if (!arg1) {
27024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
27025     return 0;
27026   }
27027   {
27028     try {
27029       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
27030     } CALL_CATCH_EXCEPTION(0);
27031   }
27032
27033   jresult = (void *)result;
27034   return jresult;
27035 }
27036
27037
27038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
27039   void * jresult ;
27040   Dali::CustomActor *arg1 = 0 ;
27041   Dali::CustomActor *result = 0 ;
27042
27043   arg1 = (Dali::CustomActor *)jarg1;
27044   if (!arg1) {
27045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
27046     return 0;
27047   }
27048   {
27049     try {
27050       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
27051     } CALL_CATCH_EXCEPTION(0);
27052   }
27053
27054   jresult = (void *)result;
27055   return jresult;
27056 }
27057
27058
27059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
27060   void * jresult ;
27061   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
27062   Dali::CustomActor *arg2 = 0 ;
27063   Dali::CustomActor *result = 0 ;
27064
27065   arg1 = (Dali::CustomActor *)jarg1;
27066   arg2 = (Dali::CustomActor *)jarg2;
27067   if (!arg2) {
27068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
27069     return 0;
27070   }
27071   {
27072     try {
27073       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
27074     } CALL_CATCH_EXCEPTION(0);
27075   }
27076
27077   jresult = (void *)result;
27078   return jresult;
27079 }
27080
27081
27082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
27083   int jresult ;
27084   int result;
27085
27086   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
27087   jresult = (int)result;
27088   return jresult;
27089 }
27090
27091
27092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
27093   int jresult ;
27094   int result;
27095
27096   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
27097   jresult = (int)result;
27098   return jresult;
27099 }
27100
27101
27102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
27103   int jresult ;
27104   int result;
27105
27106   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
27107   jresult = (int)result;
27108   return jresult;
27109 }
27110
27111
27112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
27113   int jresult ;
27114   int result;
27115
27116   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
27117   jresult = (int)result;
27118   return jresult;
27119 }
27120
27121
27122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
27123   int jresult ;
27124   int result;
27125
27126   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
27127   jresult = (int)result;
27128   return jresult;
27129 }
27130
27131
27132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
27133   int jresult ;
27134   int result;
27135
27136   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
27137   jresult = (int)result;
27138   return jresult;
27139 }
27140
27141
27142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
27143   int jresult ;
27144   int result;
27145
27146   result = (int)Dali::PanGestureDetector::Property::PANNING;
27147   jresult = (int)result;
27148   return jresult;
27149 }
27150
27151
27152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
27153   void * jresult ;
27154   Dali::PanGestureDetector::Property *result = 0 ;
27155
27156   {
27157     try {
27158       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
27159     } CALL_CATCH_EXCEPTION(0);
27160   }
27161
27162   jresult = (void *)result;
27163   return jresult;
27164 }
27165
27166
27167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
27168   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
27169
27170   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
27171   {
27172     try {
27173       delete arg1;
27174     } CALL_CATCH_EXCEPTION();
27175   }
27176
27177 }
27178
27179
27180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
27181   void * jresult ;
27182   Dali::Radian *result = 0 ;
27183
27184   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
27185   jresult = (void *)result;
27186   return jresult;
27187 }
27188
27189
27190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
27191   void * jresult ;
27192   Dali::Radian *result = 0 ;
27193
27194   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
27195   jresult = (void *)result;
27196   return jresult;
27197 }
27198
27199
27200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
27201   void * jresult ;
27202   Dali::Radian *result = 0 ;
27203
27204   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
27205   jresult = (void *)result;
27206   return jresult;
27207 }
27208
27209
27210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
27211   void * jresult ;
27212   Dali::Radian *result = 0 ;
27213
27214   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
27215   jresult = (void *)result;
27216   return jresult;
27217 }
27218
27219
27220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
27221   void * jresult ;
27222   Dali::Radian *result = 0 ;
27223
27224   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
27225   jresult = (void *)result;
27226   return jresult;
27227 }
27228
27229
27230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
27231   void * jresult ;
27232   Dali::Radian *result = 0 ;
27233
27234   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
27235   jresult = (void *)result;
27236   return jresult;
27237 }
27238
27239
27240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
27241   void * jresult ;
27242   Dali::Radian *result = 0 ;
27243
27244   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
27245   jresult = (void *)result;
27246   return jresult;
27247 }
27248
27249
27250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
27251   void * jresult ;
27252   Dali::PanGestureDetector *result = 0 ;
27253
27254   {
27255     try {
27256       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
27257     } CALL_CATCH_EXCEPTION(0);
27258   }
27259
27260   jresult = (void *)result;
27261   return jresult;
27262 }
27263
27264
27265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
27266   void * jresult ;
27267   Dali::PanGestureDetector result;
27268
27269   {
27270     try {
27271       result = Dali::PanGestureDetector::New();
27272     } CALL_CATCH_EXCEPTION(0);
27273   }
27274
27275   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
27276   return jresult;
27277 }
27278
27279
27280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
27281   void * jresult ;
27282   Dali::BaseHandle arg1 ;
27283   Dali::BaseHandle *argp1 ;
27284   Dali::PanGestureDetector result;
27285
27286   argp1 = (Dali::BaseHandle *)jarg1;
27287   if (!argp1) {
27288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27289     return 0;
27290   }
27291   arg1 = *argp1;
27292   {
27293     try {
27294       result = Dali::PanGestureDetector::DownCast(arg1);
27295     } CALL_CATCH_EXCEPTION(0);
27296   }
27297
27298   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
27299   return jresult;
27300 }
27301
27302
27303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
27304   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27305
27306   arg1 = (Dali::PanGestureDetector *)jarg1;
27307   {
27308     try {
27309       delete arg1;
27310     } CALL_CATCH_EXCEPTION();
27311   }
27312
27313 }
27314
27315
27316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
27317   void * jresult ;
27318   Dali::PanGestureDetector *arg1 = 0 ;
27319   Dali::PanGestureDetector *result = 0 ;
27320
27321   arg1 = (Dali::PanGestureDetector *)jarg1;
27322   if (!arg1) {
27323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
27324     return 0;
27325   }
27326   {
27327     try {
27328       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
27329     } CALL_CATCH_EXCEPTION(0);
27330   }
27331
27332   jresult = (void *)result;
27333   return jresult;
27334 }
27335
27336
27337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
27338   void * jresult ;
27339   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27340   Dali::PanGestureDetector *arg2 = 0 ;
27341   Dali::PanGestureDetector *result = 0 ;
27342
27343   arg1 = (Dali::PanGestureDetector *)jarg1;
27344   arg2 = (Dali::PanGestureDetector *)jarg2;
27345   if (!arg2) {
27346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
27347     return 0;
27348   }
27349   {
27350     try {
27351       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
27352     } CALL_CATCH_EXCEPTION(0);
27353   }
27354
27355   jresult = (void *)result;
27356   return jresult;
27357 }
27358
27359
27360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
27361   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27362   unsigned int arg2 ;
27363
27364   arg1 = (Dali::PanGestureDetector *)jarg1;
27365   arg2 = (unsigned int)jarg2;
27366   {
27367     try {
27368       (arg1)->SetMinimumTouchesRequired(arg2);
27369     } CALL_CATCH_EXCEPTION();
27370   }
27371
27372 }
27373
27374
27375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
27376   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27377   unsigned int arg2 ;
27378
27379   arg1 = (Dali::PanGestureDetector *)jarg1;
27380   arg2 = (unsigned int)jarg2;
27381   {
27382     try {
27383       (arg1)->SetMaximumTouchesRequired(arg2);
27384     } CALL_CATCH_EXCEPTION();
27385   }
27386
27387 }
27388
27389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumMotionEventAge(void * jarg1, unsigned int jarg2) {
27390   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27391   uint32_t arg2 ;
27392
27393   arg1 = (Dali::PanGestureDetector *)jarg1;
27394   arg2 = (uint32_t)jarg2;
27395   {
27396     try {
27397       (arg1)->SetMaximumMotionEventAge(arg2);
27398     } CALL_CATCH_EXCEPTION();
27399   }
27400
27401 }
27402
27403
27404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
27405   unsigned int jresult ;
27406   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27407   unsigned int result;
27408
27409   arg1 = (Dali::PanGestureDetector *)jarg1;
27410   {
27411     try {
27412       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
27413     } CALL_CATCH_EXCEPTION(0);
27414   }
27415
27416   jresult = result;
27417   return jresult;
27418 }
27419
27420
27421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
27422   unsigned int jresult ;
27423   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27424   unsigned int result;
27425
27426   arg1 = (Dali::PanGestureDetector *)jarg1;
27427   {
27428     try {
27429       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
27430     } CALL_CATCH_EXCEPTION(0);
27431   }
27432
27433   jresult = result;
27434   return jresult;
27435 }
27436
27437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumMotionEventAge(void * jarg1) {
27438   unsigned int jresult ;
27439   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27440   uint32_t result;
27441
27442   arg1 = (Dali::PanGestureDetector *)jarg1;
27443   {
27444     try {
27445       result = (uint32_t)((Dali::PanGestureDetector const *)arg1)->GetMaximumMotionEventAge();
27446     } CALL_CATCH_EXCEPTION(0);
27447   }
27448
27449   jresult = result;
27450   return jresult;
27451 }
27452
27453
27454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
27455   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27456   Dali::Radian arg2 ;
27457   Dali::Radian arg3 ;
27458   Dali::Radian *argp2 ;
27459   Dali::Radian *argp3 ;
27460
27461   arg1 = (Dali::PanGestureDetector *)jarg1;
27462   argp2 = (Dali::Radian *)jarg2;
27463   if (!argp2) {
27464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
27465     return ;
27466   }
27467   arg2 = *argp2;
27468   argp3 = (Dali::Radian *)jarg3;
27469   if (!argp3) {
27470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
27471     return ;
27472   }
27473   arg3 = *argp3;
27474   {
27475     try {
27476       (arg1)->AddAngle(arg2,arg3);
27477     } CALL_CATCH_EXCEPTION();
27478   }
27479
27480 }
27481
27482
27483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
27484   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27485   Dali::Radian arg2 ;
27486   Dali::Radian *argp2 ;
27487
27488   arg1 = (Dali::PanGestureDetector *)jarg1;
27489   argp2 = (Dali::Radian *)jarg2;
27490   if (!argp2) {
27491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
27492     return ;
27493   }
27494   arg2 = *argp2;
27495   {
27496     try {
27497       (arg1)->AddAngle(arg2);
27498     } CALL_CATCH_EXCEPTION();
27499   }
27500
27501 }
27502
27503
27504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
27505   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27506   Dali::Radian arg2 ;
27507   Dali::Radian arg3 ;
27508   Dali::Radian *argp2 ;
27509   Dali::Radian *argp3 ;
27510
27511   arg1 = (Dali::PanGestureDetector *)jarg1;
27512   argp2 = (Dali::Radian *)jarg2;
27513   if (!argp2) {
27514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
27515     return ;
27516   }
27517   arg2 = *argp2;
27518   argp3 = (Dali::Radian *)jarg3;
27519   if (!argp3) {
27520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
27521     return ;
27522   }
27523   arg3 = *argp3;
27524   {
27525     try {
27526       (arg1)->AddDirection(arg2,arg3);
27527     } CALL_CATCH_EXCEPTION();
27528   }
27529
27530 }
27531
27532
27533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
27534   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27535   Dali::Radian arg2 ;
27536   Dali::Radian *argp2 ;
27537
27538   arg1 = (Dali::PanGestureDetector *)jarg1;
27539   argp2 = (Dali::Radian *)jarg2;
27540   if (!argp2) {
27541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
27542     return ;
27543   }
27544   arg2 = *argp2;
27545   {
27546     try {
27547       (arg1)->AddDirection(arg2);
27548     } CALL_CATCH_EXCEPTION();
27549   }
27550
27551 }
27552
27553
27554 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
27555   unsigned long jresult ;
27556   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27557   size_t result;
27558
27559   arg1 = (Dali::PanGestureDetector *)jarg1;
27560   {
27561     try {
27562       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
27563     } CALL_CATCH_EXCEPTION(0);
27564   }
27565
27566   jresult = (unsigned long)result;
27567   return jresult;
27568 }
27569
27570
27571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
27572   void * jresult ;
27573   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27574   size_t arg2 ;
27575   Dali::PanGestureDetector::AngleThresholdPair result;
27576
27577   arg1 = (Dali::PanGestureDetector *)jarg1;
27578   arg2 = (size_t)jarg2;
27579   {
27580     try {
27581       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
27582     } CALL_CATCH_EXCEPTION(0);
27583   }
27584
27585   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
27586   return jresult;
27587 }
27588
27589
27590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
27591   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27592
27593   arg1 = (Dali::PanGestureDetector *)jarg1;
27594   {
27595     try {
27596       (arg1)->ClearAngles();
27597     } CALL_CATCH_EXCEPTION();
27598   }
27599
27600 }
27601
27602
27603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
27604   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27605   Dali::Radian arg2 ;
27606   Dali::Radian *argp2 ;
27607
27608   arg1 = (Dali::PanGestureDetector *)jarg1;
27609   argp2 = (Dali::Radian *)jarg2;
27610   if (!argp2) {
27611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
27612     return ;
27613   }
27614   arg2 = *argp2;
27615   {
27616     try {
27617       (arg1)->RemoveAngle(arg2);
27618     } CALL_CATCH_EXCEPTION();
27619   }
27620
27621 }
27622
27623
27624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
27625   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27626   Dali::Radian arg2 ;
27627   Dali::Radian *argp2 ;
27628
27629   arg1 = (Dali::PanGestureDetector *)jarg1;
27630   argp2 = (Dali::Radian *)jarg2;
27631   if (!argp2) {
27632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
27633     return ;
27634   }
27635   arg2 = *argp2;
27636   {
27637     try {
27638       (arg1)->RemoveDirection(arg2);
27639     } CALL_CATCH_EXCEPTION();
27640   }
27641
27642 }
27643
27644
27645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
27646   void * jresult ;
27647   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27648   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
27649
27650   arg1 = (Dali::PanGestureDetector *)jarg1;
27651   {
27652     try {
27653       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27654     } CALL_CATCH_EXCEPTION(0);
27655   }
27656
27657   jresult = (void *)result;
27658   return jresult;
27659 }
27660
27661
27662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
27663   Dali::PanGesture *arg1 = 0 ;
27664
27665   arg1 = (Dali::PanGesture *)jarg1;
27666   if (!arg1) {
27667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
27668     return ;
27669   }
27670   {
27671     try {
27672       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
27673     } CALL_CATCH_EXCEPTION();
27674   }
27675
27676 }
27677
27678
27679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
27680   void * jresult ;
27681   Dali::PanGesture *result = 0 ;
27682
27683   {
27684     try {
27685       result = (Dali::PanGesture *)new Dali::PanGesture();
27686     } CALL_CATCH_EXCEPTION(0);
27687   }
27688
27689   jresult = (void *)result;
27690   return jresult;
27691 }
27692
27693
27694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_New(int jarg1) {
27695   void * jresult ;
27696   Dali::GestureState arg1 ;
27697   Dali::PanGesture result;
27698
27699   arg1 = (Dali::GestureState)jarg1;
27700   {
27701     try {
27702       result = DevelPanGesture::New(arg1);
27703     } CALL_CATCH_EXCEPTION(0);
27704   }
27705
27706   jresult = new Dali::PanGesture((const Dali::PanGesture &)result);
27707   return jresult;
27708 }
27709
27710
27711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
27712   void * jresult ;
27713   Dali::PanGesture *arg1 = 0 ;
27714   Dali::PanGesture *result = 0 ;
27715
27716   arg1 = (Dali::PanGesture *)jarg1;
27717   if (!arg1) {
27718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
27719     return 0;
27720   }
27721   {
27722     try {
27723       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
27724     } CALL_CATCH_EXCEPTION(0);
27725   }
27726
27727   jresult = (void *)result;
27728   return jresult;
27729 }
27730
27731
27732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
27733   void * jresult ;
27734   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27735   Dali::PanGesture *arg2 = 0 ;
27736   Dali::PanGesture *result = 0 ;
27737
27738   arg1 = (Dali::PanGesture *)jarg1;
27739   arg2 = (Dali::PanGesture *)jarg2;
27740   if (!arg2) {
27741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
27742     return 0;
27743   }
27744   {
27745     try {
27746       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
27747     } CALL_CATCH_EXCEPTION(0);
27748   }
27749
27750   jresult = (void *)result;
27751   return jresult;
27752 }
27753
27754
27755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
27756   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27757
27758   arg1 = (Dali::PanGesture *)jarg1;
27759   {
27760     try {
27761       delete arg1;
27762     } CALL_CATCH_EXCEPTION();
27763   }
27764
27765 }
27766
27767
27768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
27769   void * jresult ;
27770   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27771   Dali::Vector2 result;
27772
27773   arg1 = (Dali::PanGesture *)jarg1;
27774   {
27775     try {
27776       result = ((Dali::PanGesture const *)arg1)->GetVelocity();
27777     } catch (std::out_of_range& e) {
27778       {
27779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27780       };
27781     } catch (std::exception& e) {
27782       {
27783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27784       };
27785     } catch (Dali::DaliException e) {
27786       {
27787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27788       };
27789     } catch (...) {
27790       {
27791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27792       };
27793     }
27794   }
27795   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
27796   return jresult;
27797 }
27798
27799
27800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
27801   void * jresult ;
27802   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27803   Dali::Vector2 result;
27804
27805   arg1 = (Dali::PanGesture *)jarg1;
27806   {
27807     try {
27808       result = ((Dali::PanGesture const *)arg1)->GetDisplacement();
27809     } catch (std::out_of_range& e) {
27810       {
27811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27812       };
27813     } catch (std::exception& e) {
27814       {
27815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27816       };
27817     } catch (Dali::DaliException e) {
27818       {
27819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27820       };
27821     } catch (...) {
27822       {
27823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27824       };
27825     }
27826   }
27827   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
27828   return jresult;
27829 }
27830
27831
27832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
27833   void * jresult ;
27834   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27835   Dali::Vector2 result;
27836
27837   arg1 = (Dali::PanGesture *)jarg1;
27838   {
27839     try {
27840       result = ((Dali::PanGesture const *)arg1)->GetPosition();
27841     } catch (std::out_of_range& e) {
27842       {
27843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27844       };
27845     } catch (std::exception& e) {
27846       {
27847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27848       };
27849     } catch (Dali::DaliException e) {
27850       {
27851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27852       };
27853     } catch (...) {
27854       {
27855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27856       };
27857     }
27858   }
27859   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
27860   return jresult;
27861 }
27862
27863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
27864   void * jresult ;
27865   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27866   Dali::Vector2 result;
27867
27868   arg1 = (Dali::PanGesture *)jarg1;
27869   {
27870     try {
27871       result = ((Dali::PanGesture const *)arg1)->GetScreenVelocity();
27872     } catch (std::out_of_range& e) {
27873       {
27874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27875       };
27876     } catch (std::exception& e) {
27877       {
27878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27879       };
27880     } catch (Dali::DaliException e) {
27881       {
27882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27883       };
27884     } catch (...) {
27885       {
27886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27887       };
27888     }
27889   }
27890   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
27891   return jresult;
27892 }
27893
27894
27895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
27896   void * jresult ;
27897   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27898   Dali::Vector2 result;
27899
27900   arg1 = (Dali::PanGesture *)jarg1;
27901   {
27902     try {
27903       result = ((Dali::PanGesture const *)arg1)->GetScreenDisplacement();
27904     } catch (std::out_of_range& e) {
27905       {
27906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27907       };
27908     } catch (std::exception& e) {
27909       {
27910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27911       };
27912     } catch (Dali::DaliException e) {
27913       {
27914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27915       };
27916     } catch (...) {
27917       {
27918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27919       };
27920     }
27921   }
27922   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
27923   return jresult;
27924 }
27925
27926
27927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
27928   void * jresult ;
27929   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27930   Dali::Vector2 result;
27931
27932   arg1 = (Dali::PanGesture *)jarg1;
27933   {
27934     try {
27935       result = ((Dali::PanGesture const *)arg1)->GetScreenPosition();
27936     } catch (std::out_of_range& e) {
27937       {
27938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27939       };
27940     } catch (std::exception& e) {
27941       {
27942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27943       };
27944     } catch (Dali::DaliException e) {
27945       {
27946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27947       };
27948     } catch (...) {
27949       {
27950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27951       };
27952     }
27953   }
27954   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
27955   return jresult;
27956 }
27957
27958
27959 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
27960   unsigned int jresult ;
27961   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27962   unsigned int result;
27963
27964   arg1 = (Dali::PanGesture *)jarg1;
27965   result = (unsigned int) ((arg1)->GetNumberOfTouches());
27966   jresult = result;
27967   return jresult;
27968 }
27969
27970
27971 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
27972   float jresult ;
27973   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27974   float result;
27975
27976   arg1 = (Dali::PanGesture *)jarg1;
27977   {
27978     try {
27979       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
27980     } CALL_CATCH_EXCEPTION(0);
27981   }
27982
27983   jresult = result;
27984   return jresult;
27985 }
27986
27987
27988 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
27989   float jresult ;
27990   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27991   float result;
27992
27993   arg1 = (Dali::PanGesture *)jarg1;
27994   {
27995     try {
27996       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
27997     } CALL_CATCH_EXCEPTION(0);
27998   }
27999
28000   jresult = result;
28001   return jresult;
28002 }
28003
28004
28005 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
28006   float jresult ;
28007   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
28008   float result;
28009
28010   arg1 = (Dali::PanGesture *)jarg1;
28011   {
28012     try {
28013       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
28014     } CALL_CATCH_EXCEPTION(0);
28015   }
28016
28017   jresult = result;
28018   return jresult;
28019 }
28020
28021
28022 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
28023   float jresult ;
28024   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
28025   float result;
28026
28027   arg1 = (Dali::PanGesture *)jarg1;
28028   {
28029     try {
28030       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
28031     } CALL_CATCH_EXCEPTION(0);
28032   }
28033
28034   jresult = result;
28035   return jresult;
28036 }
28037
28038
28039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
28040   void * jresult ;
28041   Dali::PinchGestureDetector *result = 0 ;
28042
28043   {
28044     try {
28045       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
28046     } CALL_CATCH_EXCEPTION(0);
28047   }
28048
28049   jresult = (void *)result;
28050   return jresult;
28051 }
28052
28053
28054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
28055   void * jresult ;
28056   Dali::PinchGestureDetector result;
28057
28058   {
28059     try {
28060       result = Dali::PinchGestureDetector::New();
28061     } CALL_CATCH_EXCEPTION(0);
28062   }
28063
28064   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
28065   return jresult;
28066 }
28067
28068
28069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
28070   void * jresult ;
28071   Dali::BaseHandle arg1 ;
28072   Dali::BaseHandle *argp1 ;
28073   Dali::PinchGestureDetector result;
28074
28075   argp1 = (Dali::BaseHandle *)jarg1;
28076   if (!argp1) {
28077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28078     return 0;
28079   }
28080   arg1 = *argp1;
28081   {
28082     try {
28083       result = Dali::PinchGestureDetector::DownCast(arg1);
28084     } CALL_CATCH_EXCEPTION(0);
28085   }
28086
28087   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
28088   return jresult;
28089 }
28090
28091
28092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
28093   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
28094
28095   arg1 = (Dali::PinchGestureDetector *)jarg1;
28096   {
28097     try {
28098       delete arg1;
28099     } CALL_CATCH_EXCEPTION();
28100   }
28101
28102 }
28103
28104
28105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
28106   void * jresult ;
28107   Dali::PinchGestureDetector *arg1 = 0 ;
28108   Dali::PinchGestureDetector *result = 0 ;
28109
28110   arg1 = (Dali::PinchGestureDetector *)jarg1;
28111   if (!arg1) {
28112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
28113     return 0;
28114   }
28115   {
28116     try {
28117       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
28118     } CALL_CATCH_EXCEPTION(0);
28119   }
28120
28121   jresult = (void *)result;
28122   return jresult;
28123 }
28124
28125
28126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
28127   void * jresult ;
28128   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
28129   Dali::PinchGestureDetector *arg2 = 0 ;
28130   Dali::PinchGestureDetector *result = 0 ;
28131
28132   arg1 = (Dali::PinchGestureDetector *)jarg1;
28133   arg2 = (Dali::PinchGestureDetector *)jarg2;
28134   if (!arg2) {
28135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
28136     return 0;
28137   }
28138   {
28139     try {
28140       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
28141     } CALL_CATCH_EXCEPTION(0);
28142   }
28143
28144   jresult = (void *)result;
28145   return jresult;
28146 }
28147
28148
28149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
28150   void * jresult ;
28151   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
28152   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
28153
28154   arg1 = (Dali::PinchGestureDetector *)jarg1;
28155   {
28156     try {
28157       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
28158     } CALL_CATCH_EXCEPTION(0);
28159   }
28160
28161   jresult = (void *)result;
28162   return jresult;
28163 }
28164
28165
28166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0() {
28167   void * jresult ;
28168   Dali::PinchGesture *result = 0 ;
28169
28170   {
28171     try {
28172       result = (Dali::PinchGesture *)new Dali::PinchGesture();
28173     } CALL_CATCH_EXCEPTION(0);
28174   }
28175
28176   jresult = (void *)result;
28177   return jresult;
28178 }
28179
28180
28181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_New(int jarg1) {
28182   void * jresult ;
28183   Dali::GestureState arg1 ;
28184   Dali::PinchGesture result;
28185
28186   arg1 = (Dali::GestureState)jarg1;
28187   {
28188     try {
28189       result = DevelPinchGesture::New(arg1);
28190     } CALL_CATCH_EXCEPTION(0);
28191   }
28192
28193   jresult = new Dali::PinchGesture((const Dali::PinchGesture &)result);
28194   return jresult;
28195 }
28196
28197
28198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
28199   void * jresult ;
28200   Dali::PinchGesture *arg1 = 0 ;
28201   Dali::PinchGesture *result = 0 ;
28202
28203   arg1 = (Dali::PinchGesture *)jarg1;
28204   if (!arg1) {
28205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
28206     return 0;
28207   }
28208   {
28209     try {
28210       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
28211     } CALL_CATCH_EXCEPTION(0);
28212   }
28213
28214   jresult = (void *)result;
28215   return jresult;
28216 }
28217
28218
28219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
28220   void * jresult ;
28221   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
28222   Dali::PinchGesture *arg2 = 0 ;
28223   Dali::PinchGesture *result = 0 ;
28224
28225   arg1 = (Dali::PinchGesture *)jarg1;
28226   arg2 = (Dali::PinchGesture *)jarg2;
28227   if (!arg2) {
28228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
28229     return 0;
28230   }
28231   {
28232     try {
28233       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
28234     } CALL_CATCH_EXCEPTION(0);
28235   }
28236
28237   jresult = (void *)result;
28238   return jresult;
28239 }
28240
28241
28242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
28243   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
28244
28245   arg1 = (Dali::PinchGesture *)jarg1;
28246   {
28247     try {
28248       delete arg1;
28249     } CALL_CATCH_EXCEPTION();
28250   }
28251
28252 }
28253
28254
28255 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
28256   float jresult ;
28257   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
28258   float result;
28259
28260   arg1 = (Dali::PinchGesture *)jarg1;
28261   result = (float) ((arg1)->GetScale());
28262   jresult = result;
28263   return jresult;
28264 }
28265
28266
28267 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
28268   float jresult ;
28269   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
28270   float result;
28271
28272   arg1 = (Dali::PinchGesture *)jarg1;
28273   result = (float) ((arg1)->GetSpeed());
28274   jresult = result;
28275   return jresult;
28276 }
28277
28278
28279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
28280   void * jresult ;
28281   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
28282   Dali::Vector2 result;
28283
28284   arg1 = (Dali::PinchGesture *)jarg1;
28285   {
28286     try {
28287       result = ((Dali::PinchGesture const *)arg1)->GetScreenCenterPoint();
28288     } catch (std::out_of_range& e) {
28289       {
28290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28291       };
28292     } catch (std::exception& e) {
28293       {
28294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28295       };
28296     } catch (Dali::DaliException e) {
28297       {
28298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28299       };
28300     } catch (...) {
28301       {
28302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28303       };
28304     }
28305   }
28306   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28307   return jresult;
28308 }
28309
28310
28311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
28312   void * jresult ;
28313   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
28314   Dali::Vector2 result;
28315
28316   arg1 = (Dali::PinchGesture *)jarg1;
28317   {
28318     try {
28319       result = ((Dali::PinchGesture const *)arg1)->GetLocalCenterPoint();
28320     } catch (std::out_of_range& e) {
28321       {
28322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28323       };
28324     } catch (std::exception& e) {
28325       {
28326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28327       };
28328     } catch (Dali::DaliException e) {
28329       {
28330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28331       };
28332     } catch (...) {
28333       {
28334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28335       };
28336     }
28337   }
28338   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28339   return jresult;
28340 }
28341
28342
28343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
28344   void * jresult ;
28345   Dali::TapGestureDetector *result = 0 ;
28346
28347   {
28348     try {
28349       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
28350     } CALL_CATCH_EXCEPTION(0);
28351   }
28352
28353   jresult = (void *)result;
28354   return jresult;
28355 }
28356
28357
28358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
28359   void * jresult ;
28360   Dali::TapGestureDetector result;
28361
28362   {
28363     try {
28364       result = Dali::TapGestureDetector::New();
28365     } CALL_CATCH_EXCEPTION(0);
28366   }
28367
28368   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
28369   return jresult;
28370 }
28371
28372
28373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
28374   void * jresult ;
28375   unsigned int arg1 ;
28376   Dali::TapGestureDetector result;
28377
28378   arg1 = (unsigned int)jarg1;
28379   {
28380     try {
28381       result = Dali::TapGestureDetector::New(arg1);
28382     } CALL_CATCH_EXCEPTION(0);
28383   }
28384
28385   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
28386   return jresult;
28387 }
28388
28389
28390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
28391   void * jresult ;
28392   Dali::BaseHandle arg1 ;
28393   Dali::BaseHandle *argp1 ;
28394   Dali::TapGestureDetector result;
28395
28396   argp1 = (Dali::BaseHandle *)jarg1;
28397   if (!argp1) {
28398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28399     return 0;
28400   }
28401   arg1 = *argp1;
28402   {
28403     try {
28404       result = Dali::TapGestureDetector::DownCast(arg1);
28405     } CALL_CATCH_EXCEPTION(0);
28406   }
28407
28408   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
28409   return jresult;
28410 }
28411
28412
28413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
28414   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
28415
28416   arg1 = (Dali::TapGestureDetector *)jarg1;
28417   {
28418     try {
28419       delete arg1;
28420     } CALL_CATCH_EXCEPTION();
28421   }
28422
28423 }
28424
28425
28426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
28427   void * jresult ;
28428   Dali::TapGestureDetector *arg1 = 0 ;
28429   Dali::TapGestureDetector *result = 0 ;
28430
28431   arg1 = (Dali::TapGestureDetector *)jarg1;
28432   if (!arg1) {
28433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
28434     return 0;
28435   }
28436   {
28437     try {
28438       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
28439     } CALL_CATCH_EXCEPTION(0);
28440   }
28441
28442   jresult = (void *)result;
28443   return jresult;
28444 }
28445
28446
28447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
28448   void * jresult ;
28449   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
28450   Dali::TapGestureDetector *arg2 = 0 ;
28451   Dali::TapGestureDetector *result = 0 ;
28452
28453   arg1 = (Dali::TapGestureDetector *)jarg1;
28454   arg2 = (Dali::TapGestureDetector *)jarg2;
28455   if (!arg2) {
28456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
28457     return 0;
28458   }
28459   {
28460     try {
28461       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
28462     } CALL_CATCH_EXCEPTION(0);
28463   }
28464
28465   jresult = (void *)result;
28466   return jresult;
28467 }
28468
28469
28470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
28471   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
28472   unsigned int arg2 ;
28473
28474   arg1 = (Dali::TapGestureDetector *)jarg1;
28475   arg2 = (unsigned int)jarg2;
28476   {
28477     try {
28478       (arg1)->SetMinimumTapsRequired(arg2);
28479     } CALL_CATCH_EXCEPTION();
28480   }
28481
28482 }
28483
28484
28485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
28486   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
28487   unsigned int arg2 ;
28488
28489   arg1 = (Dali::TapGestureDetector *)jarg1;
28490   arg2 = (unsigned int)jarg2;
28491   {
28492     try {
28493       (arg1)->SetMaximumTapsRequired(arg2);
28494     } CALL_CATCH_EXCEPTION();
28495   }
28496
28497 }
28498
28499
28500 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
28501   unsigned int jresult ;
28502   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
28503   unsigned int result;
28504
28505   arg1 = (Dali::TapGestureDetector *)jarg1;
28506   {
28507     try {
28508       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
28509     } CALL_CATCH_EXCEPTION(0);
28510   }
28511
28512   jresult = result;
28513   return jresult;
28514 }
28515
28516
28517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
28518   unsigned int jresult ;
28519   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
28520   unsigned int result;
28521
28522   arg1 = (Dali::TapGestureDetector *)jarg1;
28523   {
28524     try {
28525       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
28526     } CALL_CATCH_EXCEPTION(0);
28527   }
28528
28529   jresult = result;
28530   return jresult;
28531 }
28532
28533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_ReceiveAllTapEvents(void * tapGestureDetector, bool isReceive) {
28534   Dali::TapGestureDetector *detector = (Dali::TapGestureDetector *) 0 ;
28535
28536   detector = (Dali::TapGestureDetector *)tapGestureDetector;
28537   if (!detector) {
28538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
28539     return;
28540   }
28541   {
28542     try {
28543       (detector)->ReceiveAllTapEvents(isReceive);
28544     } CALL_CATCH_EXCEPTION();
28545   }
28546
28547 }
28548
28549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
28550   void * jresult ;
28551   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
28552   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
28553
28554   arg1 = (Dali::TapGestureDetector *)jarg1;
28555   {
28556     try {
28557       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
28558     } CALL_CATCH_EXCEPTION(0);
28559   }
28560
28561   jresult = (void *)result;
28562   return jresult;
28563 }
28564
28565
28566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
28567   void * jresult ;
28568   Dali::TapGesture *result = 0 ;
28569
28570   {
28571     try {
28572       result = (Dali::TapGesture *)new Dali::TapGesture();
28573     } CALL_CATCH_EXCEPTION(0);
28574   }
28575
28576   jresult = (void *)result;
28577   return jresult;
28578 }
28579
28580
28581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_New(int jarg1) {
28582   void * jresult ;
28583   Dali::GestureState arg1 ;
28584   Dali::TapGesture result;
28585
28586   arg1 = (Dali::GestureState)jarg1;
28587   {
28588     try {
28589       result = DevelTapGesture::New(arg1);
28590     } CALL_CATCH_EXCEPTION(0);
28591   }
28592
28593   jresult = new Dali::TapGesture((const Dali::TapGesture &)result);
28594   return jresult;
28595 }
28596
28597
28598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
28599   void * jresult ;
28600   Dali::TapGesture *arg1 = 0 ;
28601   Dali::TapGesture *result = 0 ;
28602
28603   arg1 = (Dali::TapGesture *)jarg1;
28604   if (!arg1) {
28605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
28606     return 0;
28607   }
28608   {
28609     try {
28610       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
28611     } CALL_CATCH_EXCEPTION(0);
28612   }
28613
28614   jresult = (void *)result;
28615   return jresult;
28616 }
28617
28618
28619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
28620   void * jresult ;
28621   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
28622   Dali::TapGesture *arg2 = 0 ;
28623   Dali::TapGesture *result = 0 ;
28624
28625   arg1 = (Dali::TapGesture *)jarg1;
28626   arg2 = (Dali::TapGesture *)jarg2;
28627   if (!arg2) {
28628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
28629     return 0;
28630   }
28631   {
28632     try {
28633       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
28634     } CALL_CATCH_EXCEPTION(0);
28635   }
28636
28637   jresult = (void *)result;
28638   return jresult;
28639 }
28640
28641
28642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
28643   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
28644
28645   arg1 = (Dali::TapGesture *)jarg1;
28646   {
28647     try {
28648       delete arg1;
28649     } CALL_CATCH_EXCEPTION();
28650   }
28651
28652 }
28653
28654
28655 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
28656   unsigned int jresult ;
28657   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
28658   unsigned int result;
28659
28660   arg1 = (Dali::TapGesture *)jarg1;
28661   result = (unsigned int) ((arg1)->GetNumberOfTaps());
28662   jresult = result;
28663   return jresult;
28664 }
28665
28666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
28667   unsigned int jresult ;
28668   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
28669   unsigned int result;
28670
28671   arg1 = (Dali::TapGesture *)jarg1;
28672   result = (unsigned int) ((arg1)->GetNumberOfTouches());
28673   jresult = result;
28674   return jresult;
28675 }
28676
28677
28678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
28679   void * jresult ;
28680   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
28681   Dali::Vector2 result;
28682
28683   arg1 = (Dali::TapGesture *)jarg1;
28684   {
28685     try {
28686       result = ((Dali::TapGesture const *)arg1)->GetScreenPoint();
28687     } catch (std::out_of_range& e) {
28688       {
28689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28690       };
28691     } catch (std::exception& e) {
28692       {
28693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28694       };
28695     } catch (Dali::DaliException e) {
28696       {
28697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28698       };
28699     } catch (...) {
28700       {
28701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28702       };
28703     }
28704   }
28705   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28706   return jresult;
28707 }
28708
28709
28710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
28711   void * jresult ;
28712   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
28713   Dali::Vector2 result;
28714
28715   arg1 = (Dali::TapGesture *)jarg1;
28716   {
28717     try {
28718       result = ((Dali::TapGesture const *)arg1)->GetLocalPoint();
28719     } catch (std::out_of_range& e) {
28720       {
28721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28722       };
28723     } catch (std::exception& e) {
28724       {
28725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28726       };
28727     } catch (Dali::DaliException e) {
28728       {
28729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28730       };
28731     } catch (...) {
28732       {
28733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28734       };
28735     }
28736   }
28737   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28738   return jresult;
28739 }
28740
28741
28742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
28743   void * jresult ;
28744   Dali::AlphaFunction *result = 0 ;
28745
28746   {
28747     try {
28748       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
28749     } CALL_CATCH_EXCEPTION(0);
28750   }
28751
28752   jresult = (void *)result;
28753   return jresult;
28754 }
28755
28756
28757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
28758   void * jresult ;
28759   Dali::AlphaFunction::BuiltinFunction arg1 ;
28760   Dali::AlphaFunction *result = 0 ;
28761
28762   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
28763   {
28764     try {
28765       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
28766     } CALL_CATCH_EXCEPTION(0);
28767   }
28768
28769   jresult = (void *)result;
28770   return jresult;
28771 }
28772
28773
28774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
28775   void * jresult ;
28776   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
28777   Dali::AlphaFunction *result = 0 ;
28778
28779   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
28780   {
28781     try {
28782       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
28783     } CALL_CATCH_EXCEPTION(0);
28784   }
28785
28786   jresult = (void *)result;
28787   return jresult;
28788 }
28789
28790
28791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
28792   void * jresult ;
28793   Dali::Vector2 *arg1 = 0 ;
28794   Dali::Vector2 *arg2 = 0 ;
28795   Dali::AlphaFunction *result = 0 ;
28796
28797   arg1 = (Dali::Vector2 *)jarg1;
28798   if (!arg1) {
28799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
28800     return 0;
28801   }
28802   arg2 = (Dali::Vector2 *)jarg2;
28803   if (!arg2) {
28804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
28805     return 0;
28806   }
28807   {
28808     try {
28809       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
28810     } CALL_CATCH_EXCEPTION(0);
28811   }
28812
28813   jresult = (void *)result;
28814   return jresult;
28815 }
28816
28817
28818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
28819   void * jresult ;
28820   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
28821   Dali::Vector4 result;
28822
28823   arg1 = (Dali::AlphaFunction *)jarg1;
28824   {
28825     try {
28826       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
28827     } CALL_CATCH_EXCEPTION(0);
28828   }
28829
28830   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
28831   return jresult;
28832 }
28833
28834
28835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
28836   void * jresult ;
28837   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
28838   Dali::AlphaFunctionPrototype result;
28839
28840   arg1 = (Dali::AlphaFunction *)jarg1;
28841   {
28842     try {
28843       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
28844     } CALL_CATCH_EXCEPTION(0);
28845   }
28846
28847   jresult = (void *)result;
28848   return jresult;
28849 }
28850
28851
28852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
28853   int jresult ;
28854   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
28855   Dali::AlphaFunction::BuiltinFunction result;
28856
28857   arg1 = (Dali::AlphaFunction *)jarg1;
28858   {
28859     try {
28860       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
28861     } CALL_CATCH_EXCEPTION(0);
28862   }
28863
28864   jresult = (int)result;
28865   return jresult;
28866 }
28867
28868
28869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
28870   int jresult ;
28871   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
28872   Dali::AlphaFunction::Mode result;
28873
28874   arg1 = (Dali::AlphaFunction *)jarg1;
28875   {
28876     try {
28877       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
28878     } CALL_CATCH_EXCEPTION(0);
28879   }
28880
28881   jresult = (int)result;
28882   return jresult;
28883 }
28884
28885
28886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
28887   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
28888
28889   arg1 = (Dali::AlphaFunction *)jarg1;
28890   {
28891     try {
28892       delete arg1;
28893     } CALL_CATCH_EXCEPTION();
28894   }
28895
28896 }
28897
28898
28899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
28900   void * jresult ;
28901   Dali::KeyFrames result;
28902
28903   {
28904     try {
28905       result = Dali::KeyFrames::New();
28906     } CALL_CATCH_EXCEPTION(0);
28907   }
28908
28909   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
28910   return jresult;
28911 }
28912
28913
28914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
28915   void * jresult ;
28916   Dali::BaseHandle arg1 ;
28917   Dali::BaseHandle *argp1 ;
28918   Dali::KeyFrames result;
28919
28920   argp1 = (Dali::BaseHandle *)jarg1;
28921   if (!argp1) {
28922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28923     return 0;
28924   }
28925   arg1 = *argp1;
28926   {
28927     try {
28928       result = Dali::KeyFrames::DownCast(arg1);
28929     } CALL_CATCH_EXCEPTION(0);
28930   }
28931
28932   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
28933   return jresult;
28934 }
28935
28936
28937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
28938   void * jresult ;
28939   Dali::KeyFrames *result = 0 ;
28940
28941   {
28942     try {
28943       result = (Dali::KeyFrames *)new Dali::KeyFrames();
28944     } CALL_CATCH_EXCEPTION(0);
28945   }
28946
28947   jresult = (void *)result;
28948   return jresult;
28949 }
28950
28951
28952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
28953   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
28954
28955   arg1 = (Dali::KeyFrames *)jarg1;
28956   {
28957     try {
28958       delete arg1;
28959     } CALL_CATCH_EXCEPTION();
28960   }
28961
28962 }
28963
28964
28965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
28966   void * jresult ;
28967   Dali::KeyFrames *arg1 = 0 ;
28968   Dali::KeyFrames *result = 0 ;
28969
28970   arg1 = (Dali::KeyFrames *)jarg1;
28971   if (!arg1) {
28972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
28973     return 0;
28974   }
28975   {
28976     try {
28977       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
28978     } CALL_CATCH_EXCEPTION(0);
28979   }
28980
28981   jresult = (void *)result;
28982   return jresult;
28983 }
28984
28985
28986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
28987   void * jresult ;
28988   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
28989   Dali::KeyFrames *arg2 = 0 ;
28990   Dali::KeyFrames *result = 0 ;
28991
28992   arg1 = (Dali::KeyFrames *)jarg1;
28993   arg2 = (Dali::KeyFrames *)jarg2;
28994   if (!arg2) {
28995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
28996     return 0;
28997   }
28998   {
28999     try {
29000       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
29001     } CALL_CATCH_EXCEPTION(0);
29002   }
29003
29004   jresult = (void *)result;
29005   return jresult;
29006 }
29007
29008
29009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
29010   int jresult ;
29011   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
29012   Dali::Property::Type result;
29013
29014   arg1 = (Dali::KeyFrames *)jarg1;
29015   {
29016     try {
29017       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
29018     } CALL_CATCH_EXCEPTION(0);
29019   }
29020
29021   jresult = (int)result;
29022   return jresult;
29023 }
29024
29025
29026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
29027   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
29028   float arg2 ;
29029   Dali::Property::Value arg3 ;
29030   Dali::Property::Value *argp3 ;
29031
29032   arg1 = (Dali::KeyFrames *)jarg1;
29033   arg2 = (float)jarg2;
29034   argp3 = (Dali::Property::Value *)jarg3;
29035   if (!argp3) {
29036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
29037     return ;
29038   }
29039   arg3 = *argp3;
29040   {
29041     try {
29042       (arg1)->Add(arg2,arg3);
29043     } CALL_CATCH_EXCEPTION();
29044   }
29045
29046 }
29047
29048
29049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
29050   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
29051   float arg2 ;
29052   Dali::Property::Value arg3 ;
29053   Dali::AlphaFunction arg4 ;
29054   Dali::Property::Value *argp3 ;
29055   Dali::AlphaFunction *argp4 ;
29056
29057   arg1 = (Dali::KeyFrames *)jarg1;
29058   arg2 = (float)jarg2;
29059   argp3 = (Dali::Property::Value *)jarg3;
29060   if (!argp3) {
29061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
29062     return ;
29063   }
29064   arg3 = *argp3;
29065   argp4 = (Dali::AlphaFunction *)jarg4;
29066   if (!argp4) {
29067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
29068     return ;
29069   }
29070   arg4 = *argp4;
29071   {
29072     try {
29073       (arg1)->Add(arg2,arg3,arg4);
29074     } CALL_CATCH_EXCEPTION();
29075   }
29076
29077 }
29078
29079 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyFrames_GetKeyFrameCount(void* keyFrames)
29080 {
29081   unsigned int jresult;
29082   {
29083     try {
29084       jresult = Dali::DevelKeyFrames::GetKeyFrameCount(*((Dali::KeyFrames*)keyFrames));
29085     } CALL_CATCH_EXCEPTION(0);
29086   }
29087   return jresult;
29088 }
29089
29090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_GetKeyFrame(void* keyFrames, unsigned int index, float* time, void* value)
29091 {
29092   if (!value) {
29093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
29094     return ;
29095   }
29096   try {
29097     Dali::DevelKeyFrames::GetKeyFrame(*((Dali::KeyFrames*)keyFrames), (size_t)index, *time, *((Property::Value*)value));
29098   } CALL_CATCH_EXCEPTION();
29099 }
29100
29101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_SetKeyFrameValue(void* keyFrames, unsigned int index, void* value)
29102 {
29103   if (!value) {
29104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
29105     return ;
29106   }
29107   try {
29108     Dali::DevelKeyFrames::SetKeyFrameValue(*((Dali::KeyFrames*)keyFrames), (size_t)index, *((const Property::Value*)value));
29109   } CALL_CATCH_EXCEPTION();
29110 }
29111
29112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
29113   int jresult ;
29114   int result;
29115
29116   result = (int)Dali::Path::Property::POINTS;
29117   jresult = (int)result;
29118   return jresult;
29119 }
29120
29121
29122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
29123   int jresult ;
29124   int result;
29125
29126   result = (int)Dali::Path::Property::CONTROL_POINTS;
29127   jresult = (int)result;
29128   return jresult;
29129 }
29130
29131
29132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
29133   void * jresult ;
29134   Dali::Path::Property *result = 0 ;
29135
29136   {
29137     try {
29138       result = (Dali::Path::Property *)new Dali::Path::Property();
29139     } CALL_CATCH_EXCEPTION(0);
29140   }
29141
29142   jresult = (void *)result;
29143   return jresult;
29144 }
29145
29146
29147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
29148   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
29149
29150   arg1 = (Dali::Path::Property *)jarg1;
29151   {
29152     try {
29153       delete arg1;
29154     } CALL_CATCH_EXCEPTION();
29155   }
29156
29157 }
29158
29159
29160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
29161   void * jresult ;
29162   Dali::Path result;
29163
29164   {
29165     try {
29166       result = Dali::Path::New();
29167     } CALL_CATCH_EXCEPTION(0);
29168   }
29169
29170   jresult = new Dali::Path((const Dali::Path &)result);
29171   return jresult;
29172 }
29173
29174
29175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
29176   void * jresult ;
29177   Dali::BaseHandle arg1 ;
29178   Dali::BaseHandle *argp1 ;
29179   Dali::Path result;
29180
29181   argp1 = (Dali::BaseHandle *)jarg1;
29182   if (!argp1) {
29183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29184     return 0;
29185   }
29186   arg1 = *argp1;
29187   {
29188     try {
29189       result = Dali::Path::DownCast(arg1);
29190     } CALL_CATCH_EXCEPTION(0);
29191   }
29192
29193   jresult = new Dali::Path((const Dali::Path &)result);
29194   return jresult;
29195 }
29196
29197
29198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
29199   void * jresult ;
29200   Dali::Path *result = 0 ;
29201
29202   {
29203     try {
29204       result = (Dali::Path *)new Dali::Path();
29205     } CALL_CATCH_EXCEPTION(0);
29206   }
29207
29208   jresult = (void *)result;
29209   return jresult;
29210 }
29211
29212
29213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
29214   Dali::Path *arg1 = (Dali::Path *) 0 ;
29215
29216   arg1 = (Dali::Path *)jarg1;
29217   {
29218     try {
29219       delete arg1;
29220     } CALL_CATCH_EXCEPTION();
29221   }
29222
29223 }
29224
29225
29226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
29227   void * jresult ;
29228   Dali::Path *arg1 = 0 ;
29229   Dali::Path *result = 0 ;
29230
29231   arg1 = (Dali::Path *)jarg1;
29232   if (!arg1) {
29233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
29234     return 0;
29235   }
29236   {
29237     try {
29238       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
29239     } CALL_CATCH_EXCEPTION(0);
29240   }
29241
29242   jresult = (void *)result;
29243   return jresult;
29244 }
29245
29246
29247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
29248   void * jresult ;
29249   Dali::Path *arg1 = (Dali::Path *) 0 ;
29250   Dali::Path *arg2 = 0 ;
29251   Dali::Path *result = 0 ;
29252
29253   arg1 = (Dali::Path *)jarg1;
29254   arg2 = (Dali::Path *)jarg2;
29255   if (!arg2) {
29256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
29257     return 0;
29258   }
29259   {
29260     try {
29261       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
29262     } CALL_CATCH_EXCEPTION(0);
29263   }
29264
29265   jresult = (void *)result;
29266   return jresult;
29267 }
29268
29269
29270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
29271   Dali::Path *arg1 = (Dali::Path *) 0 ;
29272   Dali::Vector3 *arg2 = 0 ;
29273
29274   arg1 = (Dali::Path *)jarg1;
29275   arg2 = (Dali::Vector3 *)jarg2;
29276   if (!arg2) {
29277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29278     return ;
29279   }
29280   {
29281     try {
29282       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
29283     } CALL_CATCH_EXCEPTION();
29284   }
29285
29286 }
29287
29288
29289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
29290   Dali::Path *arg1 = (Dali::Path *) 0 ;
29291   Dali::Vector3 *arg2 = 0 ;
29292
29293   arg1 = (Dali::Path *)jarg1;
29294   arg2 = (Dali::Vector3 *)jarg2;
29295   if (!arg2) {
29296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29297     return ;
29298   }
29299   {
29300     try {
29301       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
29302     } CALL_CATCH_EXCEPTION();
29303   }
29304
29305 }
29306
29307
29308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
29309   Dali::Path *arg1 = (Dali::Path *) 0 ;
29310   float arg2 ;
29311
29312   arg1 = (Dali::Path *)jarg1;
29313   arg2 = (float)jarg2;
29314   {
29315     try {
29316       (arg1)->GenerateControlPoints(arg2);
29317     } CALL_CATCH_EXCEPTION();
29318   }
29319
29320 }
29321
29322
29323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
29324   Dali::Path *arg1 = (Dali::Path *) 0 ;
29325   float arg2 ;
29326   Dali::Vector3 *arg3 = 0 ;
29327   Dali::Vector3 *arg4 = 0 ;
29328
29329   arg1 = (Dali::Path *)jarg1;
29330   arg2 = (float)jarg2;
29331   arg3 = (Dali::Vector3 *)jarg3;
29332   if (!arg3) {
29333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
29334     return ;
29335   }
29336   arg4 = (Dali::Vector3 *)jarg4;
29337   if (!arg4) {
29338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
29339     return ;
29340   }
29341   {
29342     try {
29343       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
29344     } CALL_CATCH_EXCEPTION();
29345   }
29346
29347 }
29348
29349
29350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
29351   void * jresult ;
29352   Dali::Path *arg1 = (Dali::Path *) 0 ;
29353   size_t arg2 ;
29354   Dali::Vector3 *result = 0 ;
29355
29356   arg1 = (Dali::Path *)jarg1;
29357   arg2 = (size_t)jarg2;
29358   {
29359     try {
29360       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
29361     } CALL_CATCH_EXCEPTION(0);
29362   }
29363
29364   jresult = (void *)result;
29365   return jresult;
29366 }
29367
29368
29369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
29370   void * jresult ;
29371   Dali::Path *arg1 = (Dali::Path *) 0 ;
29372   size_t arg2 ;
29373   Dali::Vector3 *result = 0 ;
29374
29375   arg1 = (Dali::Path *)jarg1;
29376   arg2 = (size_t)jarg2;
29377   {
29378     try {
29379       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
29380     } CALL_CATCH_EXCEPTION(0);
29381   }
29382
29383   jresult = (void *)result;
29384   return jresult;
29385 }
29386
29387
29388 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
29389   unsigned long jresult ;
29390   Dali::Path *arg1 = (Dali::Path *) 0 ;
29391   size_t result;
29392
29393   arg1 = (Dali::Path *)jarg1;
29394   {
29395     try {
29396       result = ((Dali::Path const *)arg1)->GetPointCount();
29397     } CALL_CATCH_EXCEPTION(0);
29398   }
29399
29400   jresult = (unsigned long)result;
29401   return jresult;
29402 }
29403
29404
29405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
29406   void * jresult ;
29407   float arg1 ;
29408   Dali::TimePeriod *result = 0 ;
29409
29410   arg1 = (float)jarg1;
29411   {
29412     try {
29413       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
29414     } CALL_CATCH_EXCEPTION(0);
29415   }
29416
29417   jresult = (void *)result;
29418   return jresult;
29419 }
29420
29421
29422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
29423   void * jresult ;
29424   float arg1 ;
29425   float arg2 ;
29426   Dali::TimePeriod *result = 0 ;
29427
29428   arg1 = (float)jarg1;
29429   arg2 = (float)jarg2;
29430   {
29431     try {
29432       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
29433     } CALL_CATCH_EXCEPTION(0);
29434   }
29435
29436   jresult = (void *)result;
29437   return jresult;
29438 }
29439
29440
29441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
29442   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
29443
29444   arg1 = (Dali::TimePeriod *)jarg1;
29445   {
29446     try {
29447       delete arg1;
29448     } CALL_CATCH_EXCEPTION();
29449   }
29450
29451 }
29452
29453
29454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
29455   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
29456   float arg2 ;
29457
29458   arg1 = (Dali::TimePeriod *)jarg1;
29459   arg2 = (float)jarg2;
29460   if (arg1) (arg1)->delaySeconds = arg2;
29461 }
29462
29463
29464 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
29465   float jresult ;
29466   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
29467   float result;
29468
29469   arg1 = (Dali::TimePeriod *)jarg1;
29470   result = (float) ((arg1)->delaySeconds);
29471   jresult = result;
29472   return jresult;
29473 }
29474
29475
29476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
29477   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
29478   float arg2 ;
29479
29480   arg1 = (Dali::TimePeriod *)jarg1;
29481   arg2 = (float)jarg2;
29482   if (arg1) (arg1)->durationSeconds = arg2;
29483 }
29484
29485
29486 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
29487   float jresult ;
29488   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
29489   float result;
29490
29491   arg1 = (Dali::TimePeriod *)jarg1;
29492   result = (float) ((arg1)->durationSeconds);
29493   jresult = result;
29494   return jresult;
29495 }
29496
29497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
29498   int jresult ;
29499   int result;
29500
29501   result = (int)Dali::LinearConstrainer::Property::VALUE;
29502   jresult = (int)result;
29503   return jresult;
29504 }
29505
29506
29507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
29508   int jresult ;
29509   int result;
29510
29511   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
29512   jresult = (int)result;
29513   return jresult;
29514 }
29515
29516
29517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
29518   void * jresult ;
29519   Dali::LinearConstrainer::Property *result = 0 ;
29520
29521   {
29522     try {
29523       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
29524     } CALL_CATCH_EXCEPTION(0);
29525   }
29526
29527   jresult = (void *)result;
29528   return jresult;
29529 }
29530
29531
29532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
29533   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
29534
29535   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
29536   {
29537     try {
29538       delete arg1;
29539     } CALL_CATCH_EXCEPTION();
29540   }
29541
29542 }
29543
29544
29545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
29546   void * jresult ;
29547   Dali::LinearConstrainer result;
29548
29549   {
29550     try {
29551       result = Dali::LinearConstrainer::New();
29552     } CALL_CATCH_EXCEPTION(0);
29553   }
29554
29555   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
29556   return jresult;
29557 }
29558
29559
29560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
29561   void * jresult ;
29562   Dali::BaseHandle arg1 ;
29563   Dali::BaseHandle *argp1 ;
29564   Dali::LinearConstrainer result;
29565
29566   argp1 = (Dali::BaseHandle *)jarg1;
29567   if (!argp1) {
29568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29569     return 0;
29570   }
29571   arg1 = *argp1;
29572   {
29573     try {
29574       result = Dali::LinearConstrainer::DownCast(arg1);
29575     } CALL_CATCH_EXCEPTION(0);
29576   }
29577
29578   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
29579   return jresult;
29580 }
29581
29582
29583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
29584   void * jresult ;
29585   Dali::LinearConstrainer *result = 0 ;
29586
29587   {
29588     try {
29589       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
29590     } CALL_CATCH_EXCEPTION(0);
29591   }
29592
29593   jresult = (void *)result;
29594   return jresult;
29595 }
29596
29597
29598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
29599   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
29600
29601   arg1 = (Dali::LinearConstrainer *)jarg1;
29602   {
29603     try {
29604       delete arg1;
29605     } CALL_CATCH_EXCEPTION();
29606   }
29607
29608 }
29609
29610
29611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
29612   void * jresult ;
29613   Dali::LinearConstrainer *arg1 = 0 ;
29614   Dali::LinearConstrainer *result = 0 ;
29615
29616   arg1 = (Dali::LinearConstrainer *)jarg1;
29617   if (!arg1) {
29618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
29619     return 0;
29620   }
29621   {
29622     try {
29623       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
29624     } CALL_CATCH_EXCEPTION(0);
29625   }
29626
29627   jresult = (void *)result;
29628   return jresult;
29629 }
29630
29631
29632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
29633   void * jresult ;
29634   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
29635   Dali::LinearConstrainer *arg2 = 0 ;
29636   Dali::LinearConstrainer *result = 0 ;
29637
29638   arg1 = (Dali::LinearConstrainer *)jarg1;
29639   arg2 = (Dali::LinearConstrainer *)jarg2;
29640   if (!arg2) {
29641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
29642     return 0;
29643   }
29644   {
29645     try {
29646       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
29647     } CALL_CATCH_EXCEPTION(0);
29648   }
29649
29650   jresult = (void *)result;
29651   return jresult;
29652 }
29653
29654
29655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
29656   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
29657   SwigValueWrapper< Dali::Property > arg2 ;
29658   SwigValueWrapper< Dali::Property > arg3 ;
29659   Dali::Vector2 *arg4 = 0 ;
29660   Dali::Vector2 *arg5 = 0 ;
29661   Dali::Property *argp2 ;
29662   Dali::Property *argp3 ;
29663
29664   arg1 = (Dali::LinearConstrainer *)jarg1;
29665   argp2 = (Dali::Property *)jarg2;
29666   if (!argp2) {
29667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
29668     return ;
29669   }
29670   arg2 = *argp2;
29671   argp3 = (Dali::Property *)jarg3;
29672   if (!argp3) {
29673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
29674     return ;
29675   }
29676   arg3 = *argp3;
29677   arg4 = (Dali::Vector2 *)jarg4;
29678   if (!arg4) {
29679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29680     return ;
29681   }
29682   arg5 = (Dali::Vector2 *)jarg5;
29683   if (!arg5) {
29684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29685     return ;
29686   }
29687   {
29688     try {
29689       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
29690     } CALL_CATCH_EXCEPTION();
29691   }
29692
29693 }
29694
29695
29696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
29697   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
29698   SwigValueWrapper< Dali::Property > arg2 ;
29699   SwigValueWrapper< Dali::Property > arg3 ;
29700   Dali::Vector2 *arg4 = 0 ;
29701   Dali::Property *argp2 ;
29702   Dali::Property *argp3 ;
29703
29704   arg1 = (Dali::LinearConstrainer *)jarg1;
29705   argp2 = (Dali::Property *)jarg2;
29706   if (!argp2) {
29707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
29708     return ;
29709   }
29710   arg2 = *argp2;
29711   argp3 = (Dali::Property *)jarg3;
29712   if (!argp3) {
29713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
29714     return ;
29715   }
29716   arg3 = *argp3;
29717   arg4 = (Dali::Vector2 *)jarg4;
29718   if (!arg4) {
29719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29720     return ;
29721   }
29722   {
29723     try {
29724       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
29725     } CALL_CATCH_EXCEPTION();
29726   }
29727
29728 }
29729
29730
29731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
29732   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
29733   Dali::Handle *arg2 = 0 ;
29734
29735   arg1 = (Dali::LinearConstrainer *)jarg1;
29736   arg2 = (Dali::Handle *)jarg2;
29737   if (!arg2) {
29738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
29739     return ;
29740   }
29741   {
29742     try {
29743       (arg1)->Remove(*arg2);
29744     } CALL_CATCH_EXCEPTION();
29745   }
29746
29747 }
29748
29749
29750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
29751   int jresult ;
29752   int result;
29753
29754   result = (int)Dali::PathConstrainer::Property::FORWARD;
29755   jresult = (int)result;
29756   return jresult;
29757 }
29758
29759
29760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
29761   int jresult ;
29762   int result;
29763
29764   result = (int)Dali::PathConstrainer::Property::POINTS;
29765   jresult = (int)result;
29766   return jresult;
29767 }
29768
29769
29770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
29771   int jresult ;
29772   int result;
29773
29774   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
29775   jresult = (int)result;
29776   return jresult;
29777 }
29778
29779
29780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
29781   void * jresult ;
29782   Dali::PathConstrainer::Property *result = 0 ;
29783
29784   {
29785     try {
29786       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
29787     } CALL_CATCH_EXCEPTION(0);
29788   }
29789
29790   jresult = (void *)result;
29791   return jresult;
29792 }
29793
29794
29795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
29796   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
29797
29798   arg1 = (Dali::PathConstrainer::Property *)jarg1;
29799   {
29800     try {
29801       delete arg1;
29802     } CALL_CATCH_EXCEPTION();
29803   }
29804
29805 }
29806
29807
29808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
29809   void * jresult ;
29810   Dali::PathConstrainer result;
29811
29812   {
29813     try {
29814       result = Dali::PathConstrainer::New();
29815     } CALL_CATCH_EXCEPTION(0);
29816   }
29817
29818   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
29819   return jresult;
29820 }
29821
29822
29823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
29824   void * jresult ;
29825   Dali::BaseHandle arg1 ;
29826   Dali::BaseHandle *argp1 ;
29827   Dali::PathConstrainer result;
29828
29829   argp1 = (Dali::BaseHandle *)jarg1;
29830   if (!argp1) {
29831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29832     return 0;
29833   }
29834   arg1 = *argp1;
29835   {
29836     try {
29837       result = Dali::PathConstrainer::DownCast(arg1);
29838     } CALL_CATCH_EXCEPTION(0);
29839   }
29840
29841   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
29842   return jresult;
29843 }
29844
29845
29846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
29847   void * jresult ;
29848   Dali::PathConstrainer *result = 0 ;
29849
29850   {
29851     try {
29852       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
29853     } CALL_CATCH_EXCEPTION(0);
29854   }
29855
29856   jresult = (void *)result;
29857   return jresult;
29858 }
29859
29860
29861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
29862   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
29863
29864   arg1 = (Dali::PathConstrainer *)jarg1;
29865   {
29866     try {
29867       delete arg1;
29868     } CALL_CATCH_EXCEPTION();
29869   }
29870
29871 }
29872
29873
29874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
29875   void * jresult ;
29876   Dali::PathConstrainer *arg1 = 0 ;
29877   Dali::PathConstrainer *result = 0 ;
29878
29879   arg1 = (Dali::PathConstrainer *)jarg1;
29880   if (!arg1) {
29881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
29882     return 0;
29883   }
29884   {
29885     try {
29886       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
29887     } CALL_CATCH_EXCEPTION(0);
29888   }
29889
29890   jresult = (void *)result;
29891   return jresult;
29892 }
29893
29894
29895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
29896   void * jresult ;
29897   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
29898   Dali::PathConstrainer *arg2 = 0 ;
29899   Dali::PathConstrainer *result = 0 ;
29900
29901   arg1 = (Dali::PathConstrainer *)jarg1;
29902   arg2 = (Dali::PathConstrainer *)jarg2;
29903   if (!arg2) {
29904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
29905     return 0;
29906   }
29907   {
29908     try {
29909       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
29910     } CALL_CATCH_EXCEPTION(0);
29911   }
29912
29913   jresult = (void *)result;
29914   return jresult;
29915 }
29916
29917
29918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
29919   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
29920   SwigValueWrapper< Dali::Property > arg2 ;
29921   SwigValueWrapper< Dali::Property > arg3 ;
29922   Dali::Vector2 *arg4 = 0 ;
29923   Dali::Vector2 *arg5 = 0 ;
29924   Dali::Property *argp2 ;
29925   Dali::Property *argp3 ;
29926
29927   arg1 = (Dali::PathConstrainer *)jarg1;
29928   argp2 = (Dali::Property *)jarg2;
29929   if (!argp2) {
29930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
29931     return ;
29932   }
29933   arg2 = *argp2;
29934   argp3 = (Dali::Property *)jarg3;
29935   if (!argp3) {
29936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
29937     return ;
29938   }
29939   arg3 = *argp3;
29940   arg4 = (Dali::Vector2 *)jarg4;
29941   if (!arg4) {
29942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29943     return ;
29944   }
29945   arg5 = (Dali::Vector2 *)jarg5;
29946   if (!arg5) {
29947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29948     return ;
29949   }
29950   {
29951     try {
29952       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
29953     } CALL_CATCH_EXCEPTION();
29954   }
29955
29956 }
29957
29958
29959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
29960   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
29961   SwigValueWrapper< Dali::Property > arg2 ;
29962   SwigValueWrapper< Dali::Property > arg3 ;
29963   Dali::Vector2 *arg4 = 0 ;
29964   Dali::Property *argp2 ;
29965   Dali::Property *argp3 ;
29966
29967   arg1 = (Dali::PathConstrainer *)jarg1;
29968   argp2 = (Dali::Property *)jarg2;
29969   if (!argp2) {
29970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
29971     return ;
29972   }
29973   arg2 = *argp2;
29974   argp3 = (Dali::Property *)jarg3;
29975   if (!argp3) {
29976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
29977     return ;
29978   }
29979   arg3 = *argp3;
29980   arg4 = (Dali::Vector2 *)jarg4;
29981   if (!arg4) {
29982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29983     return ;
29984   }
29985   {
29986     try {
29987       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
29988     } CALL_CATCH_EXCEPTION();
29989   }
29990
29991 }
29992
29993
29994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
29995   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
29996   Dali::Handle *arg2 = 0 ;
29997
29998   arg1 = (Dali::PathConstrainer *)jarg1;
29999   arg2 = (Dali::Handle *)jarg2;
30000   if (!arg2) {
30001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
30002     return ;
30003   }
30004   {
30005     try {
30006       (arg1)->Remove(*arg2);
30007     } CALL_CATCH_EXCEPTION();
30008   }
30009
30010 }
30011
30012
30013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
30014   int jresult ;
30015   Dali::FittingMode::Type result;
30016
30017   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
30018   jresult = (int)result;
30019   return jresult;
30020 }
30021
30022
30023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
30024   int jresult ;
30025   Dali::SamplingMode::Type result;
30026
30027   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
30028   jresult = (int)result;
30029   return jresult;
30030 }
30031
30032
30033 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageInterface_CreateResource(void * jarg1) {
30034   bool jresult ;
30035   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
30036   bool result;
30037
30038   arg1 = (Dali::NativeImageInterface *)jarg1;
30039   {
30040     try {
30041       result = (bool)(arg1)->CreateResource();
30042     } CALL_CATCH_EXCEPTION(0);
30043   }
30044
30045   jresult = result;
30046   return jresult;
30047 }
30048
30049
30050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_DestroyResource(void * jarg1) {
30051   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
30052
30053   arg1 = (Dali::NativeImageInterface *)jarg1;
30054   {
30055     try {
30056       (arg1)->DestroyResource();
30057     } CALL_CATCH_EXCEPTION();
30058   }
30059
30060 }
30061
30062
30063 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
30064   unsigned int jresult ;
30065   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
30066   unsigned int result;
30067
30068   arg1 = (Dali::NativeImageInterface *)jarg1;
30069   {
30070     try {
30071       result = (unsigned int)(arg1)->TargetTexture();
30072     } CALL_CATCH_EXCEPTION(0);
30073   }
30074
30075   jresult = result;
30076   return jresult;
30077 }
30078
30079
30080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
30081   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
30082
30083   arg1 = (Dali::NativeImageInterface *)jarg1;
30084   {
30085     try {
30086       (arg1)->PrepareTexture();
30087     } CALL_CATCH_EXCEPTION();
30088   }
30089
30090 }
30091
30092
30093 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
30094   unsigned int jresult ;
30095   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
30096   unsigned int result;
30097
30098   arg1 = (Dali::NativeImageInterface *)jarg1;
30099   {
30100     try {
30101       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
30102     } CALL_CATCH_EXCEPTION(0);
30103   }
30104
30105   jresult = result;
30106   return jresult;
30107 }
30108
30109
30110 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
30111   unsigned int jresult ;
30112   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
30113   unsigned int result;
30114
30115   arg1 = (Dali::NativeImageInterface *)jarg1;
30116   {
30117     try {
30118       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
30119     } CALL_CATCH_EXCEPTION(0);
30120   }
30121
30122   jresult = result;
30123   return jresult;
30124 }
30125
30126
30127 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
30128   bool jresult ;
30129   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
30130   bool result;
30131
30132   arg1 = (Dali::NativeImageInterface *)jarg1;
30133   {
30134     try {
30135       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
30136     } CALL_CATCH_EXCEPTION(0);
30137   }
30138
30139   jresult = result;
30140   return jresult;
30141 }
30142
30143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
30144   int jresult ;
30145   int result;
30146
30147   result = (int)Dali::CameraActor::Property::TYPE;
30148   jresult = (int)result;
30149   return jresult;
30150 }
30151
30152
30153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
30154   int jresult ;
30155   int result;
30156
30157   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
30158   jresult = (int)result;
30159   return jresult;
30160 }
30161
30162
30163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
30164   int jresult ;
30165   int result;
30166
30167   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
30168   jresult = (int)result;
30169   return jresult;
30170 }
30171
30172
30173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
30174   int jresult ;
30175   int result;
30176
30177   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
30178   jresult = (int)result;
30179   return jresult;
30180 }
30181
30182
30183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
30184   int jresult ;
30185   int result;
30186
30187   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
30188   jresult = (int)result;
30189   return jresult;
30190 }
30191
30192
30193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
30194   int jresult ;
30195   int result;
30196
30197   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
30198   jresult = (int)result;
30199   return jresult;
30200 }
30201
30202
30203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
30204   int jresult ;
30205   int result;
30206
30207   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
30208   jresult = (int)result;
30209   return jresult;
30210 }
30211
30212
30213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
30214   int jresult ;
30215   int result;
30216
30217   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
30218   jresult = (int)result;
30219   return jresult;
30220 }
30221
30222
30223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
30224   int jresult ;
30225   int result;
30226
30227   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
30228   jresult = (int)result;
30229   return jresult;
30230 }
30231
30232
30233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
30234   int jresult ;
30235   int result;
30236
30237   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
30238   jresult = (int)result;
30239   return jresult;
30240 }
30241
30242
30243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
30244   int jresult ;
30245   int result;
30246
30247   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
30248   jresult = (int)result;
30249   return jresult;
30250 }
30251
30252
30253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
30254   int jresult ;
30255   int result;
30256
30257   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
30258   jresult = (int)result;
30259   return jresult;
30260 }
30261
30262
30263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
30264   int jresult ;
30265   int result;
30266
30267   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
30268   jresult = (int)result;
30269   return jresult;
30270 }
30271
30272
30273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
30274   int jresult ;
30275   int result;
30276
30277   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
30278   jresult = (int)result;
30279   return jresult;
30280 }
30281
30282
30283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ORTHOGRAPHIC_SIZE_get() {
30284   int jresult ;
30285   int result;
30286
30287   result = (int)Dali::DevelCameraActor::Property::ORTHOGRAPHIC_SIZE;
30288   jresult = (int)result;
30289   return jresult;
30290 }
30291
30292
30293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_DIRECTION_get() {
30294   int jresult ;
30295   int result;
30296
30297   result = (int)Dali::DevelCameraActor::Property::PROJECTION_DIRECTION;
30298   jresult = (int)result;
30299   return jresult;
30300 }
30301
30302
30303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
30304   void * jresult ;
30305   Dali::CameraActor::Property *result = 0 ;
30306
30307   {
30308     try {
30309       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
30310     } CALL_CATCH_EXCEPTION(0);
30311   }
30312
30313   jresult = (void *)result;
30314   return jresult;
30315 }
30316
30317
30318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
30319   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
30320
30321   arg1 = (Dali::CameraActor::Property *)jarg1;
30322   {
30323     try {
30324       delete arg1;
30325     } CALL_CATCH_EXCEPTION();
30326   }
30327
30328 }
30329
30330
30331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
30332   void * jresult ;
30333   Dali::CameraActor *result = 0 ;
30334
30335   {
30336     try {
30337       result = (Dali::CameraActor *)new Dali::CameraActor();
30338     } CALL_CATCH_EXCEPTION(0);
30339   }
30340
30341   jresult = (void *)result;
30342   return jresult;
30343 }
30344
30345
30346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
30347   void * jresult ;
30348   Dali::CameraActor result;
30349
30350   {
30351     try {
30352       result = Dali::CameraActor::New();
30353     } CALL_CATCH_EXCEPTION(0);
30354   }
30355
30356   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
30357   return jresult;
30358 }
30359
30360
30361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
30362   void * jresult ;
30363   Dali::Size *arg1 = 0 ;
30364   Dali::CameraActor result;
30365
30366   arg1 = (Dali::Size *)jarg1;
30367   if (!arg1) {
30368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
30369     return 0;
30370   }
30371   {
30372     try {
30373       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
30374     } CALL_CATCH_EXCEPTION(0);
30375   }
30376
30377   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
30378   return jresult;
30379 }
30380
30381
30382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New3DCamera() {
30383   void * jresult ;
30384   Dali::CameraActor result;
30385
30386   {
30387     try {
30388       result = Dali::CameraActor::New3DCamera();
30389     } CALL_CATCH_EXCEPTION(0);
30390   }
30391
30392   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
30393   return jresult;
30394 }
30395
30396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
30397   void * jresult ;
30398   Dali::BaseHandle arg1 ;
30399   Dali::BaseHandle *argp1 ;
30400   Dali::CameraActor result;
30401
30402   argp1 = (Dali::BaseHandle *)jarg1;
30403   if (!argp1) {
30404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30405     return 0;
30406   }
30407   arg1 = *argp1;
30408   {
30409     try {
30410       result = Dali::CameraActor::DownCast(arg1);
30411     } CALL_CATCH_EXCEPTION(0);
30412   }
30413
30414   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
30415   return jresult;
30416 }
30417
30418
30419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
30420   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30421
30422   arg1 = (Dali::CameraActor *)jarg1;
30423   {
30424     try {
30425       delete arg1;
30426     } CALL_CATCH_EXCEPTION();
30427   }
30428
30429 }
30430
30431
30432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
30433   void * jresult ;
30434   Dali::CameraActor *arg1 = 0 ;
30435   Dali::CameraActor *result = 0 ;
30436
30437   arg1 = (Dali::CameraActor *)jarg1;
30438   if (!arg1) {
30439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
30440     return 0;
30441   }
30442   {
30443     try {
30444       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
30445     } CALL_CATCH_EXCEPTION(0);
30446   }
30447
30448   jresult = (void *)result;
30449   return jresult;
30450 }
30451
30452
30453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
30454   void * jresult ;
30455   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30456   Dali::CameraActor *arg2 = 0 ;
30457   Dali::CameraActor *result = 0 ;
30458
30459   arg1 = (Dali::CameraActor *)jarg1;
30460   arg2 = (Dali::CameraActor *)jarg2;
30461   if (!arg2) {
30462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
30463     return 0;
30464   }
30465   {
30466     try {
30467       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
30468     } CALL_CATCH_EXCEPTION(0);
30469   }
30470
30471   jresult = (void *)result;
30472   return jresult;
30473 }
30474
30475
30476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
30477   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30478   Dali::Camera::Type arg2 ;
30479
30480   arg1 = (Dali::CameraActor *)jarg1;
30481   arg2 = (Dali::Camera::Type)jarg2;
30482   {
30483     try {
30484       (arg1)->SetType(arg2);
30485     } CALL_CATCH_EXCEPTION();
30486   }
30487
30488 }
30489
30490
30491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
30492   int jresult ;
30493   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30494   Dali::Camera::Type result;
30495
30496   arg1 = (Dali::CameraActor *)jarg1;
30497   {
30498     try {
30499       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
30500     } CALL_CATCH_EXCEPTION(0);
30501   }
30502
30503   jresult = (int)result;
30504   return jresult;
30505 }
30506
30507
30508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
30509   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30510   Dali::Camera::ProjectionMode arg2 ;
30511
30512   arg1 = (Dali::CameraActor *)jarg1;
30513   arg2 = (Dali::Camera::ProjectionMode)jarg2;
30514   {
30515     try {
30516       (arg1)->SetProjectionMode(arg2);
30517     } CALL_CATCH_EXCEPTION();
30518   }
30519
30520 }
30521
30522
30523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
30524   int jresult ;
30525   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30526   Dali::Camera::ProjectionMode result;
30527
30528   arg1 = (Dali::CameraActor *)jarg1;
30529   {
30530     try {
30531       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
30532     } CALL_CATCH_EXCEPTION(0);
30533   }
30534
30535   jresult = (int)result;
30536   return jresult;
30537 }
30538
30539
30540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
30541   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30542   float arg2 ;
30543
30544   arg1 = (Dali::CameraActor *)jarg1;
30545   arg2 = (float)jarg2;
30546   {
30547     try {
30548       (arg1)->SetFieldOfView(arg2);
30549     } CALL_CATCH_EXCEPTION();
30550   }
30551
30552 }
30553
30554
30555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
30556   float jresult ;
30557   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30558   float result;
30559
30560   arg1 = (Dali::CameraActor *)jarg1;
30561   {
30562     try {
30563       result = (float)(arg1)->GetFieldOfView();
30564     } CALL_CATCH_EXCEPTION(0);
30565   }
30566
30567   jresult = result;
30568   return jresult;
30569 }
30570
30571
30572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
30573   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30574   float arg2 ;
30575
30576   arg1 = (Dali::CameraActor *)jarg1;
30577   arg2 = (float)jarg2;
30578   {
30579     try {
30580       (arg1)->SetAspectRatio(arg2);
30581     } CALL_CATCH_EXCEPTION();
30582   }
30583
30584 }
30585
30586
30587 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
30588   float jresult ;
30589   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30590   float result;
30591
30592   arg1 = (Dali::CameraActor *)jarg1;
30593   {
30594     try {
30595       result = (float)(arg1)->GetAspectRatio();
30596     } CALL_CATCH_EXCEPTION(0);
30597   }
30598
30599   jresult = result;
30600   return jresult;
30601 }
30602
30603
30604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
30605   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30606   float arg2 ;
30607
30608   arg1 = (Dali::CameraActor *)jarg1;
30609   arg2 = (float)jarg2;
30610   {
30611     try {
30612       (arg1)->SetNearClippingPlane(arg2);
30613     } CALL_CATCH_EXCEPTION();
30614   }
30615
30616 }
30617
30618
30619 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
30620   float jresult ;
30621   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30622   float result;
30623
30624   arg1 = (Dali::CameraActor *)jarg1;
30625   {
30626     try {
30627       result = (float)(arg1)->GetNearClippingPlane();
30628     } CALL_CATCH_EXCEPTION(0);
30629   }
30630
30631   jresult = result;
30632   return jresult;
30633 }
30634
30635
30636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
30637   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30638   float arg2 ;
30639
30640   arg1 = (Dali::CameraActor *)jarg1;
30641   arg2 = (float)jarg2;
30642   {
30643     try {
30644       (arg1)->SetFarClippingPlane(arg2);
30645     } CALL_CATCH_EXCEPTION();
30646   }
30647
30648 }
30649
30650
30651 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
30652   float jresult ;
30653   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30654   float result;
30655
30656   arg1 = (Dali::CameraActor *)jarg1;
30657   {
30658     try {
30659       result = (float)(arg1)->GetFarClippingPlane();
30660     } CALL_CATCH_EXCEPTION(0);
30661   }
30662
30663   jresult = result;
30664   return jresult;
30665 }
30666
30667
30668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
30669   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30670   Dali::Vector3 *arg2 = 0 ;
30671
30672   arg1 = (Dali::CameraActor *)jarg1;
30673   arg2 = (Dali::Vector3 *)jarg2;
30674   if (!arg2) {
30675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30676     return ;
30677   }
30678   {
30679     try {
30680       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
30681     } CALL_CATCH_EXCEPTION();
30682   }
30683
30684 }
30685
30686
30687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
30688   void * jresult ;
30689   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30690   Dali::Vector3 result;
30691
30692   arg1 = (Dali::CameraActor *)jarg1;
30693   {
30694     try {
30695       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
30696     } CALL_CATCH_EXCEPTION(0);
30697   }
30698
30699   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30700   return jresult;
30701 }
30702
30703
30704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, bool jarg2) {
30705   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30706   bool arg2 ;
30707
30708   arg1 = (Dali::CameraActor *)jarg1;
30709   arg2 = jarg2 ? true : false;
30710   {
30711     try {
30712       (arg1)->SetInvertYAxis(arg2);
30713     } CALL_CATCH_EXCEPTION();
30714   }
30715
30716 }
30717
30718
30719 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
30720   bool jresult ;
30721   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30722   bool result;
30723
30724   arg1 = (Dali::CameraActor *)jarg1;
30725   {
30726     try {
30727       result = (bool)(arg1)->GetInvertYAxis();
30728     } CALL_CATCH_EXCEPTION(0);
30729   }
30730
30731   jresult = result;
30732   return jresult;
30733 }
30734
30735
30736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
30737   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30738   Dali::Size *arg2 = 0 ;
30739
30740   arg1 = (Dali::CameraActor *)jarg1;
30741   arg2 = (Dali::Size *)jarg2;
30742   if (!arg2) {
30743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
30744     return ;
30745   }
30746   {
30747     try {
30748       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
30749     } CALL_CATCH_EXCEPTION();
30750   }
30751
30752 }
30753
30754
30755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
30756   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30757   Dali::Size *arg2 = 0 ;
30758
30759   arg1 = (Dali::CameraActor *)jarg1;
30760   arg2 = (Dali::Size *)jarg2;
30761   if (!arg2) {
30762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
30763     return ;
30764   }
30765   {
30766     try {
30767       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
30768     } CALL_CATCH_EXCEPTION();
30769   }
30770
30771 }
30772
30773
30774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
30775   void * jresult ;
30776   std::pair< std::string,Dali::Property::Value > *result = 0 ;
30777
30778   {
30779     try {
30780       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
30781     } CALL_CATCH_EXCEPTION(0);
30782   }
30783
30784   jresult = (void *)result;
30785   return jresult;
30786 }
30787
30788
30789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
30790   void * jresult ;
30791   std::string arg1 ;
30792   Dali::Property::Value arg2 ;
30793   Dali::Property::Value *argp2 ;
30794   std::pair< std::string,Dali::Property::Value > *result = 0 ;
30795
30796   if (!jarg1) {
30797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30798     return 0;
30799   }
30800   (&arg1)->assign(jarg1);
30801   argp2 = (Dali::Property::Value *)jarg2;
30802   if (!argp2) {
30803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
30804     return 0;
30805   }
30806   arg2 = *argp2;
30807   {
30808     try {
30809       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
30810     } CALL_CATCH_EXCEPTION(0);
30811   }
30812
30813   jresult = (void *)result;
30814   return jresult;
30815 }
30816
30817
30818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
30819   void * jresult ;
30820   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
30821   std::pair< std::string,Dali::Property::Value > *result = 0 ;
30822
30823   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
30824   if (!arg1) {
30825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
30826     return 0;
30827   }
30828   {
30829     try {
30830       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);
30831     } CALL_CATCH_EXCEPTION(0);
30832   }
30833
30834   jresult = (void *)result;
30835   return jresult;
30836 }
30837
30838
30839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
30840   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
30841   std::string *arg2 = 0 ;
30842
30843   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
30844   if (!jarg2) {
30845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30846     return ;
30847   }
30848   std::string arg2_str(jarg2);
30849   arg2 = &arg2_str;
30850   if (arg1) (arg1)->first = *arg2;
30851
30852   //argout typemap for const std::string&
30853
30854 }
30855
30856
30857 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
30858   char * jresult ;
30859   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
30860   std::string *result = 0 ;
30861
30862   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
30863   result = (std::string *) & ((arg1)->first);
30864   jresult = SWIG_csharp_string_callback(result->c_str());
30865   return jresult;
30866 }
30867
30868
30869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
30870   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
30871   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
30872
30873   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
30874   arg2 = (Dali::Property::Value *)jarg2;
30875   if (arg1) (arg1)->second = *arg2;
30876 }
30877
30878
30879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
30880   void * jresult ;
30881   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
30882   Dali::Property::Value *result = 0 ;
30883
30884   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
30885   result = (Dali::Property::Value *)& ((arg1)->second);
30886   jresult = (void *)result;
30887   return jresult;
30888 }
30889
30890
30891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
30892   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
30893
30894   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
30895   {
30896     try {
30897       delete arg1;
30898     } CALL_CATCH_EXCEPTION();
30899   }
30900
30901 }
30902
30903
30904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
30905   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30906
30907   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30908   {
30909     try {
30910       (arg1)->clear();
30911     } CALL_CATCH_EXCEPTION();
30912   }
30913
30914 }
30915
30916
30917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
30918   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30919   Dali::TouchPoint *arg2 = 0 ;
30920
30921   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30922   arg2 = (Dali::TouchPoint *)jarg2;
30923   if (!arg2) {
30924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
30925     return ;
30926   }
30927   {
30928     try {
30929       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
30930     } CALL_CATCH_EXCEPTION();
30931   }
30932
30933 }
30934
30935
30936 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
30937   unsigned long jresult ;
30938   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30939   std::vector< Dali::TouchPoint >::size_type result;
30940
30941   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30942   {
30943     try {
30944       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
30945     } CALL_CATCH_EXCEPTION(0);
30946   }
30947
30948   jresult = (unsigned long)result;
30949   return jresult;
30950 }
30951
30952
30953 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
30954   unsigned long jresult ;
30955   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30956   std::vector< Dali::TouchPoint >::size_type result;
30957
30958   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30959   {
30960     try {
30961       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
30962     } CALL_CATCH_EXCEPTION(0);
30963   }
30964
30965   jresult = (unsigned long)result;
30966   return jresult;
30967 }
30968
30969
30970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
30971   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30972   std::vector< Dali::TouchPoint >::size_type arg2 ;
30973
30974   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30975   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
30976   {
30977     try {
30978       (arg1)->reserve(arg2);
30979     } CALL_CATCH_EXCEPTION();
30980   }
30981
30982 }
30983
30984
30985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
30986   void * jresult ;
30987   std::vector< Dali::TouchPoint > *result = 0 ;
30988
30989   {
30990     try {
30991       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
30992     } CALL_CATCH_EXCEPTION(0);
30993   }
30994
30995   jresult = (void *)result;
30996   return jresult;
30997 }
30998
30999
31000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
31001   void * jresult ;
31002   std::vector< Dali::TouchPoint > *arg1 = 0 ;
31003   std::vector< Dali::TouchPoint > *result = 0 ;
31004
31005   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
31006   if (!arg1) {
31007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
31008     return 0;
31009   }
31010   {
31011     try {
31012       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
31013     } CALL_CATCH_EXCEPTION(0);
31014   }
31015
31016   jresult = (void *)result;
31017   return jresult;
31018 }
31019
31020
31021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
31022   void * jresult ;
31023   int arg1 ;
31024   std::vector< Dali::TouchPoint > *result = 0 ;
31025
31026   arg1 = (int)jarg1;
31027   {
31028     try {
31029       try {
31030         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
31031       }
31032       catch(std::out_of_range &_e) {
31033         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
31034         return 0;
31035       }
31036
31037     } CALL_CATCH_EXCEPTION(0);
31038   }
31039
31040   jresult = (void *)result;
31041   return jresult;
31042 }
31043
31044
31045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
31046   void * jresult ;
31047   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
31048   int arg2 ;
31049   SwigValueWrapper< Dali::TouchPoint > result;
31050
31051   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
31052   arg2 = (int)jarg2;
31053   {
31054     try {
31055       try {
31056         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
31057       }
31058       catch(std::out_of_range &_e) {
31059         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
31060         return 0;
31061       }
31062
31063     } CALL_CATCH_EXCEPTION(0);
31064   }
31065
31066   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
31067   return jresult;
31068 }
31069
31070
31071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
31072   void * jresult ;
31073   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
31074   int arg2 ;
31075   Dali::TouchPoint *result = 0 ;
31076
31077   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
31078   arg2 = (int)jarg2;
31079   {
31080     try {
31081       try {
31082         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
31083       }
31084       catch(std::out_of_range &_e) {
31085         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
31086         return 0;
31087       }
31088
31089     } CALL_CATCH_EXCEPTION(0);
31090   }
31091
31092   jresult = (void *)result;
31093   return jresult;
31094 }
31095
31096
31097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
31098   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
31099   int arg2 ;
31100   Dali::TouchPoint *arg3 = 0 ;
31101
31102   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
31103   arg2 = (int)jarg2;
31104   arg3 = (Dali::TouchPoint *)jarg3;
31105   if (!arg3) {
31106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
31107     return ;
31108   }
31109   {
31110     try {
31111       try {
31112         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
31113       }
31114       catch(std::out_of_range &_e) {
31115         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
31116         return ;
31117       }
31118
31119     } CALL_CATCH_EXCEPTION();
31120   }
31121
31122 }
31123
31124
31125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
31126   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
31127   std::vector< Dali::TouchPoint > *arg2 = 0 ;
31128
31129   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
31130   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
31131   if (!arg2) {
31132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
31133     return ;
31134   }
31135   {
31136     try {
31137       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
31138     } CALL_CATCH_EXCEPTION();
31139   }
31140
31141 }
31142
31143
31144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
31145   void * jresult ;
31146   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
31147   int arg2 ;
31148   int arg3 ;
31149   std::vector< Dali::TouchPoint > *result = 0 ;
31150
31151   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
31152   arg2 = (int)jarg2;
31153   arg3 = (int)jarg3;
31154   {
31155     try {
31156       try {
31157         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
31158       }
31159       catch(std::out_of_range &_e) {
31160         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
31161         return 0;
31162       }
31163       catch(std::invalid_argument &_e) {
31164         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
31165         return 0;
31166       }
31167
31168     } CALL_CATCH_EXCEPTION(0);
31169   }
31170
31171   jresult = (void *)result;
31172   return jresult;
31173 }
31174
31175
31176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
31177   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
31178   int arg2 ;
31179   Dali::TouchPoint *arg3 = 0 ;
31180
31181   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
31182   arg2 = (int)jarg2;
31183   arg3 = (Dali::TouchPoint *)jarg3;
31184   if (!arg3) {
31185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
31186     return ;
31187   }
31188   {
31189     try {
31190       try {
31191         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
31192       }
31193       catch(std::out_of_range &_e) {
31194         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
31195         return ;
31196       }
31197
31198     } CALL_CATCH_EXCEPTION();
31199   }
31200
31201 }
31202
31203
31204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
31205   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
31206   int arg2 ;
31207   std::vector< Dali::TouchPoint > *arg3 = 0 ;
31208
31209   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
31210   arg2 = (int)jarg2;
31211   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
31212   if (!arg3) {
31213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
31214     return ;
31215   }
31216   {
31217     try {
31218       try {
31219         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
31220       }
31221       catch(std::out_of_range &_e) {
31222         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
31223         return ;
31224       }
31225
31226     } CALL_CATCH_EXCEPTION();
31227   }
31228
31229 }
31230
31231
31232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
31233   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
31234   int arg2 ;
31235
31236   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
31237   arg2 = (int)jarg2;
31238   {
31239     try {
31240       try {
31241         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
31242       }
31243       catch(std::out_of_range &_e) {
31244         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
31245         return ;
31246       }
31247
31248     } CALL_CATCH_EXCEPTION();
31249   }
31250
31251 }
31252
31253
31254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
31255   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
31256   int arg2 ;
31257   int arg3 ;
31258
31259   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
31260   arg2 = (int)jarg2;
31261   arg3 = (int)jarg3;
31262   {
31263     try {
31264       try {
31265         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
31266       }
31267       catch(std::out_of_range &_e) {
31268         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
31269         return ;
31270       }
31271       catch(std::invalid_argument &_e) {
31272         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
31273         return ;
31274       }
31275
31276     } CALL_CATCH_EXCEPTION();
31277   }
31278
31279 }
31280
31281
31282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
31283   void * jresult ;
31284   Dali::TouchPoint *arg1 = 0 ;
31285   int arg2 ;
31286   std::vector< Dali::TouchPoint > *result = 0 ;
31287
31288   arg1 = (Dali::TouchPoint *)jarg1;
31289   if (!arg1) {
31290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
31291     return 0;
31292   }
31293   arg2 = (int)jarg2;
31294   {
31295     try {
31296       try {
31297         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
31298       }
31299       catch(std::out_of_range &_e) {
31300         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
31301         return 0;
31302       }
31303
31304     } CALL_CATCH_EXCEPTION(0);
31305   }
31306
31307   jresult = (void *)result;
31308   return jresult;
31309 }
31310
31311
31312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
31313   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
31314
31315   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
31316   {
31317     try {
31318       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
31319     } CALL_CATCH_EXCEPTION();
31320   }
31321
31322 }
31323
31324
31325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
31326   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
31327   int arg2 ;
31328   int arg3 ;
31329
31330   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
31331   arg2 = (int)jarg2;
31332   arg3 = (int)jarg3;
31333   {
31334     try {
31335       try {
31336         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
31337       }
31338       catch(std::out_of_range &_e) {
31339         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
31340         return ;
31341       }
31342       catch(std::invalid_argument &_e) {
31343         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
31344         return ;
31345       }
31346
31347     } CALL_CATCH_EXCEPTION();
31348   }
31349
31350 }
31351
31352
31353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
31354   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
31355   int arg2 ;
31356   std::vector< Dali::TouchPoint > *arg3 = 0 ;
31357
31358   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
31359   arg2 = (int)jarg2;
31360   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
31361   if (!arg3) {
31362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
31363     return ;
31364   }
31365   {
31366     try {
31367       try {
31368         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
31369       }
31370       catch(std::out_of_range &_e) {
31371         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
31372         return ;
31373       }
31374
31375     } CALL_CATCH_EXCEPTION();
31376   }
31377
31378 }
31379
31380
31381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
31382   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
31383
31384   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
31385   {
31386     try {
31387       delete arg1;
31388     } CALL_CATCH_EXCEPTION();
31389   }
31390
31391 }
31392
31393
31394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
31395   void * jresult ;
31396   Dali::Rect< int > *result = 0 ;
31397
31398   {
31399     try {
31400       result = (Dali::Rect< int > *)new Dali::Rect< int >();
31401     } CALL_CATCH_EXCEPTION(0);
31402   }
31403
31404   jresult = (void *)result;
31405   return jresult;
31406 }
31407
31408
31409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
31410   void * jresult ;
31411   int arg1 ;
31412   int arg2 ;
31413   int arg3 ;
31414   int arg4 ;
31415   Dali::Rect< int > *result = 0 ;
31416
31417   arg1 = (int)jarg1;
31418   arg2 = (int)jarg2;
31419   arg3 = (int)jarg3;
31420   arg4 = (int)jarg4;
31421   {
31422     try {
31423       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
31424     } CALL_CATCH_EXCEPTION(0);
31425   }
31426
31427   jresult = (void *)result;
31428   return jresult;
31429 }
31430
31431
31432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
31433   void * jresult ;
31434   Dali::Rect< int > *arg1 = 0 ;
31435   Dali::Rect< int > *result = 0 ;
31436
31437   arg1 = (Dali::Rect< int > *)jarg1;
31438   if (!arg1) {
31439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
31440     return 0;
31441   }
31442   {
31443     try {
31444       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
31445     } CALL_CATCH_EXCEPTION(0);
31446   }
31447
31448   jresult = (void *)result;
31449   return jresult;
31450 }
31451
31452
31453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
31454   void * jresult ;
31455   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31456   Dali::Rect< int > *arg2 = 0 ;
31457   Dali::Rect< int > *result = 0 ;
31458
31459   arg1 = (Dali::Rect< int > *)jarg1;
31460   arg2 = (Dali::Rect< int > *)jarg2;
31461   if (!arg2) {
31462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
31463     return 0;
31464   }
31465   {
31466     try {
31467       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
31468     } CALL_CATCH_EXCEPTION(0);
31469   }
31470
31471   jresult = (void *)result;
31472   return jresult;
31473 }
31474
31475
31476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
31477   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31478   int arg2 ;
31479   int arg3 ;
31480   int arg4 ;
31481   int arg5 ;
31482
31483   arg1 = (Dali::Rect< int > *)jarg1;
31484   arg2 = (int)jarg2;
31485   arg3 = (int)jarg3;
31486   arg4 = (int)jarg4;
31487   arg5 = (int)jarg5;
31488   {
31489     try {
31490       (arg1)->Set(arg2,arg3,arg4,arg5);
31491     } CALL_CATCH_EXCEPTION();
31492   }
31493
31494 }
31495
31496
31497 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
31498   bool jresult ;
31499   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31500   bool result;
31501
31502   arg1 = (Dali::Rect< int > *)jarg1;
31503   {
31504     try {
31505       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
31506     } CALL_CATCH_EXCEPTION(0);
31507   }
31508
31509   jresult = result;
31510   return jresult;
31511 }
31512
31513
31514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
31515   int jresult ;
31516   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31517   int result;
31518
31519   arg1 = (Dali::Rect< int > *)jarg1;
31520   {
31521     try {
31522       result = (int)((Dali::Rect< int > const *)arg1)->Left();
31523     } CALL_CATCH_EXCEPTION(0);
31524   }
31525
31526   jresult = result;
31527   return jresult;
31528 }
31529
31530
31531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
31532   int jresult ;
31533   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31534   int result;
31535
31536   arg1 = (Dali::Rect< int > *)jarg1;
31537   {
31538     try {
31539       result = (int)((Dali::Rect< int > const *)arg1)->Right();
31540     } CALL_CATCH_EXCEPTION(0);
31541   }
31542
31543   jresult = result;
31544   return jresult;
31545 }
31546
31547
31548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
31549   int jresult ;
31550   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31551   int result;
31552
31553   arg1 = (Dali::Rect< int > *)jarg1;
31554   {
31555     try {
31556       result = (int)((Dali::Rect< int > const *)arg1)->Top();
31557     } CALL_CATCH_EXCEPTION(0);
31558   }
31559
31560   jresult = result;
31561   return jresult;
31562 }
31563
31564
31565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
31566   int jresult ;
31567   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31568   int result;
31569
31570   arg1 = (Dali::Rect< int > *)jarg1;
31571   {
31572     try {
31573       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
31574     } CALL_CATCH_EXCEPTION(0);
31575   }
31576
31577   jresult = result;
31578   return jresult;
31579 }
31580
31581
31582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
31583   int jresult ;
31584   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31585   int result;
31586
31587   arg1 = (Dali::Rect< int > *)jarg1;
31588   {
31589     try {
31590       result = (int)((Dali::Rect< int > const *)arg1)->Area();
31591     } CALL_CATCH_EXCEPTION(0);
31592   }
31593
31594   jresult = result;
31595   return jresult;
31596 }
31597
31598
31599 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
31600   bool jresult ;
31601   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31602   Dali::Rect< int > *arg2 = 0 ;
31603   bool result;
31604
31605   arg1 = (Dali::Rect< int > *)jarg1;
31606   arg2 = (Dali::Rect< int > *)jarg2;
31607   if (!arg2) {
31608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
31609     return 0;
31610   }
31611   {
31612     try {
31613       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
31614     } CALL_CATCH_EXCEPTION(0);
31615   }
31616
31617   jresult = result;
31618   return jresult;
31619 }
31620
31621
31622 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
31623   bool jresult ;
31624   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31625   Dali::Rect< int > *arg2 = 0 ;
31626   bool result;
31627
31628   arg1 = (Dali::Rect< int > *)jarg1;
31629   arg2 = (Dali::Rect< int > *)jarg2;
31630   if (!arg2) {
31631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
31632     return 0;
31633   }
31634   {
31635     try {
31636       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
31637     } CALL_CATCH_EXCEPTION(0);
31638   }
31639
31640   jresult = result;
31641   return jresult;
31642 }
31643
31644
31645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
31646   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31647   int arg2 ;
31648
31649   arg1 = (Dali::Rect< int > *)jarg1;
31650   arg2 = (int)jarg2;
31651   if (arg1) (arg1)->x = arg2;
31652 }
31653
31654
31655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
31656   int jresult ;
31657   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31658   int result;
31659
31660   arg1 = (Dali::Rect< int > *)jarg1;
31661   result = (int) ((arg1)->x);
31662   jresult = result;
31663   return jresult;
31664 }
31665
31666
31667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
31668   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31669   int arg2 ;
31670
31671   arg1 = (Dali::Rect< int > *)jarg1;
31672   arg2 = (int)jarg2;
31673   if (arg1) (arg1)->left = arg2;
31674 }
31675
31676
31677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
31678   int jresult ;
31679   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31680   int result;
31681
31682   arg1 = (Dali::Rect< int > *)jarg1;
31683   result = (int) ((arg1)->left);
31684   jresult = result;
31685   return jresult;
31686 }
31687
31688
31689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
31690   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31691   int arg2 ;
31692
31693   arg1 = (Dali::Rect< int > *)jarg1;
31694   arg2 = (int)jarg2;
31695   if (arg1) (arg1)->y = arg2;
31696 }
31697
31698
31699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
31700   int jresult ;
31701   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31702   int result;
31703
31704   arg1 = (Dali::Rect< int > *)jarg1;
31705   result = (int) ((arg1)->y);
31706   jresult = result;
31707   return jresult;
31708 }
31709
31710
31711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
31712   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31713   int arg2 ;
31714
31715   arg1 = (Dali::Rect< int > *)jarg1;
31716   arg2 = (int)jarg2;
31717   if (arg1) (arg1)->right = arg2;
31718 }
31719
31720
31721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
31722   int jresult ;
31723   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31724   int result;
31725
31726   arg1 = (Dali::Rect< int > *)jarg1;
31727   result = (int) ((arg1)->right);
31728   jresult = result;
31729   return jresult;
31730 }
31731
31732
31733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
31734   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31735   int arg2 ;
31736
31737   arg1 = (Dali::Rect< int > *)jarg1;
31738   arg2 = (int)jarg2;
31739   if (arg1) (arg1)->width = arg2;
31740 }
31741
31742
31743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
31744   int jresult ;
31745   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31746   int result;
31747
31748   arg1 = (Dali::Rect< int > *)jarg1;
31749   result = (int) ((arg1)->width);
31750   jresult = result;
31751   return jresult;
31752 }
31753
31754
31755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
31756   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31757   int arg2 ;
31758
31759   arg1 = (Dali::Rect< int > *)jarg1;
31760   arg2 = (int)jarg2;
31761   if (arg1) (arg1)->bottom = arg2;
31762 }
31763
31764
31765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
31766   int jresult ;
31767   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31768   int result;
31769
31770   arg1 = (Dali::Rect< int > *)jarg1;
31771   result = (int) ((arg1)->bottom);
31772   jresult = result;
31773   return jresult;
31774 }
31775
31776
31777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
31778   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31779   int arg2 ;
31780
31781   arg1 = (Dali::Rect< int > *)jarg1;
31782   arg2 = (int)jarg2;
31783   if (arg1) (arg1)->height = arg2;
31784 }
31785
31786
31787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
31788   int jresult ;
31789   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31790   int result;
31791
31792   arg1 = (Dali::Rect< int > *)jarg1;
31793   result = (int) ((arg1)->height);
31794   jresult = result;
31795   return jresult;
31796 }
31797
31798
31799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
31800   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31801   int arg2 ;
31802
31803   arg1 = (Dali::Rect< int > *)jarg1;
31804   arg2 = (int)jarg2;
31805   if (arg1) (arg1)->top = arg2;
31806 }
31807
31808
31809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
31810   int jresult ;
31811   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31812   int result;
31813
31814   arg1 = (Dali::Rect< int > *)jarg1;
31815   result = (int) ((arg1)->top);
31816   jresult = result;
31817   return jresult;
31818 }
31819
31820
31821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
31822   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31823
31824   arg1 = (Dali::Rect< int > *)jarg1;
31825   {
31826     try {
31827       delete arg1;
31828     } CALL_CATCH_EXCEPTION();
31829   }
31830
31831 }
31832
31833
31834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
31835   void * jresult ;
31836   Dali::Rect< float > *result = 0 ;
31837
31838   {
31839     try {
31840       result = (Dali::Rect< float > *)new Dali::Rect< float >();
31841     } CALL_CATCH_EXCEPTION(0);
31842   }
31843
31844   jresult = (void *)result;
31845   return jresult;
31846 }
31847
31848
31849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
31850   void * jresult ;
31851   float arg1 ;
31852   float arg2 ;
31853   float arg3 ;
31854   float arg4 ;
31855   Dali::Rect< float > *result = 0 ;
31856
31857   arg1 = (float)jarg1;
31858   arg2 = (float)jarg2;
31859   arg3 = (float)jarg4;
31860   arg4 = (float)jarg3;
31861   {
31862     try {
31863       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
31864     } CALL_CATCH_EXCEPTION(0);
31865   }
31866
31867   jresult = (void *)result;
31868   return jresult;
31869 }
31870
31871
31872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
31873   void * jresult ;
31874   Dali::Rect< float > *arg1 = 0 ;
31875   Dali::Rect< float > *result = 0 ;
31876
31877   arg1 = (Dali::Rect< float > *)jarg1;
31878   if (!arg1) {
31879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
31880     return 0;
31881   }
31882   {
31883     try {
31884       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
31885     } CALL_CATCH_EXCEPTION(0);
31886   }
31887
31888   jresult = (void *)result;
31889   return jresult;
31890 }
31891
31892
31893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
31894   void * jresult ;
31895   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31896   Dali::Rect< float > *arg2 = 0 ;
31897   Dali::Rect< float > *result = 0 ;
31898
31899   arg1 = (Dali::Rect< float > *)jarg1;
31900   arg2 = (Dali::Rect< float > *)jarg2;
31901   if (!arg2) {
31902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
31903     return 0;
31904   }
31905   {
31906     try {
31907       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
31908     } CALL_CATCH_EXCEPTION(0);
31909   }
31910
31911   jresult = (void *)result;
31912   return jresult;
31913 }
31914
31915
31916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
31917   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31918   float arg2 ;
31919   float arg3 ;
31920   float arg4 ;
31921   float arg5 ;
31922
31923   arg1 = (Dali::Rect< float > *)jarg1;
31924   arg2 = (float)jarg2;
31925   arg3 = (float)jarg3;
31926   arg4 = (float)jarg5;
31927   arg5 = (float)jarg4;
31928   {
31929     try {
31930       (arg1)->Set(arg2,arg3,arg4,arg5);
31931     } CALL_CATCH_EXCEPTION();
31932   }
31933
31934 }
31935
31936
31937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
31938   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31939   float arg2 ;
31940
31941   arg1 = (Dali::Rect< float > *)jarg1;
31942   arg2 = (float)jarg2;
31943   if (arg1) (arg1)->left = arg2;
31944 }
31945
31946
31947 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
31948   float jresult ;
31949   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31950   float result;
31951
31952   arg1 = (Dali::Rect< float > *)jarg1;
31953   result = (float) ((arg1)->left);
31954   jresult = result;
31955   return jresult;
31956 }
31957
31958
31959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
31960   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31961   float arg2 ;
31962
31963   arg1 = (Dali::Rect< float > *)jarg1;
31964   arg2 = (float)jarg2;
31965   if (arg1) (arg1)->left = arg2;
31966 }
31967
31968
31969 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
31970   float jresult ;
31971   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31972   float result;
31973
31974   arg1 = (Dali::Rect< float > *)jarg1;
31975   result = (float) ((arg1)->left);
31976   jresult = result;
31977   return jresult;
31978 }
31979
31980
31981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
31982   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31983   float arg2 ;
31984
31985   arg1 = (Dali::Rect< float > *)jarg1;
31986   arg2 = (float)jarg2;
31987   if (arg1) (arg1)->right = arg2;
31988 }
31989
31990
31991 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
31992   float jresult ;
31993   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31994   float result;
31995
31996   arg1 = (Dali::Rect< float > *)jarg1;
31997   result = (float) ((arg1)->right);
31998   jresult = result;
31999   return jresult;
32000 }
32001
32002
32003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
32004   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
32005   float arg2 ;
32006
32007   arg1 = (Dali::Rect< float > *)jarg1;
32008   arg2 = (float)jarg2;
32009   if (arg1) (arg1)->right = arg2;
32010 }
32011
32012
32013 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
32014   float jresult ;
32015   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
32016   float result;
32017
32018   arg1 = (Dali::Rect< float > *)jarg1;
32019   result = (float) ((arg1)->right);
32020   jresult = result;
32021   return jresult;
32022 }
32023
32024
32025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
32026   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
32027   float arg2 ;
32028
32029   arg1 = (Dali::Rect< float > *)jarg1;
32030   arg2 = (float)jarg2;
32031   if (arg1) (arg1)->bottom = arg2;
32032 }
32033
32034
32035 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
32036   float jresult ;
32037   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
32038   float result;
32039
32040   arg1 = (Dali::Rect< float > *)jarg1;
32041   result = (float) ((arg1)->bottom);
32042   jresult = result;
32043   return jresult;
32044 }
32045
32046
32047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
32048   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
32049   float arg2 ;
32050
32051   arg1 = (Dali::Rect< float > *)jarg1;
32052   arg2 = (float)jarg2;
32053   if (arg1) (arg1)->top = arg2;
32054 }
32055
32056
32057 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
32058   float jresult ;
32059   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
32060   float result;
32061
32062   arg1 = (Dali::Rect< float > *)jarg1;
32063   result = (float) ((arg1)->top);
32064   jresult = result;
32065   return jresult;
32066 }
32067
32068
32069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
32070   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
32071
32072   arg1 = (Dali::Rect< float > *)jarg1;
32073   {
32074     try {
32075       delete arg1;
32076     } CALL_CATCH_EXCEPTION();
32077   }
32078
32079 }
32080
32081
32082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
32083   int jresult ;
32084   int result;
32085
32086   result = (int)Dali::Vector< int >::BaseType;
32087   jresult = (int)result;
32088   return jresult;
32089 }
32090
32091
32092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
32093   void * jresult ;
32094   Dali::Vector< int > *result = 0 ;
32095
32096   {
32097     try {
32098       result = (Dali::Vector< int > *)new Dali::Vector< int >();
32099     } CALL_CATCH_EXCEPTION(0);
32100   }
32101
32102   jresult = (void *)result;
32103   return jresult;
32104 }
32105
32106
32107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
32108   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32109
32110   arg1 = (Dali::Vector< int > *)jarg1;
32111   {
32112     try {
32113       delete arg1;
32114     } CALL_CATCH_EXCEPTION();
32115   }
32116
32117 }
32118
32119
32120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
32121   void * jresult ;
32122   Dali::Vector< int > *arg1 = 0 ;
32123   Dali::Vector< int > *result = 0 ;
32124
32125   arg1 = (Dali::Vector< int > *)jarg1;
32126   if (!arg1) {
32127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
32128     return 0;
32129   }
32130   {
32131     try {
32132       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
32133     } CALL_CATCH_EXCEPTION(0);
32134   }
32135
32136   jresult = (void *)result;
32137   return jresult;
32138 }
32139
32140
32141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
32142   void * jresult ;
32143   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32144   Dali::Vector< int > *arg2 = 0 ;
32145   Dali::Vector< int > *result = 0 ;
32146
32147   arg1 = (Dali::Vector< int > *)jarg1;
32148   arg2 = (Dali::Vector< int > *)jarg2;
32149   if (!arg2) {
32150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
32151     return 0;
32152   }
32153   {
32154     try {
32155       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
32156     } CALL_CATCH_EXCEPTION(0);
32157   }
32158
32159   jresult = (void *)result;
32160   return jresult;
32161 }
32162
32163
32164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
32165   void * jresult ;
32166   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32167   Dali::Vector< int >::Iterator result;
32168
32169   arg1 = (Dali::Vector< int > *)jarg1;
32170   {
32171     try {
32172       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
32173     } CALL_CATCH_EXCEPTION(0);
32174   }
32175
32176   jresult = (void *)result;
32177   return jresult;
32178 }
32179
32180
32181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
32182   void * jresult ;
32183   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32184   Dali::Vector< int >::Iterator result;
32185
32186   arg1 = (Dali::Vector< int > *)jarg1;
32187   {
32188     try {
32189       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
32190     } CALL_CATCH_EXCEPTION(0);
32191   }
32192
32193   jresult = (void *)result;
32194   return jresult;
32195 }
32196
32197
32198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
32199   void * jresult ;
32200   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32201   Dali::Vector< int >::SizeType arg2 ;
32202   Dali::Vector< int >::ItemType *result = 0 ;
32203
32204   arg1 = (Dali::Vector< int > *)jarg1;
32205   arg2 = (Dali::Vector< int >::SizeType)jarg2;
32206   {
32207     try {
32208       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
32209     } CALL_CATCH_EXCEPTION(0);
32210   }
32211
32212   jresult = (void *)result;
32213   return jresult;
32214 }
32215
32216
32217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
32218   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32219   Dali::Vector< int >::ItemType *arg2 = 0 ;
32220   Dali::Vector< int >::ItemType temp2 ;
32221
32222   arg1 = (Dali::Vector< int > *)jarg1;
32223   temp2 = (Dali::Vector< int >::ItemType)jarg2;
32224   arg2 = &temp2;
32225   {
32226     try {
32227       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
32228     } CALL_CATCH_EXCEPTION();
32229   }
32230
32231 }
32232
32233
32234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
32235   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32236   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
32237   Dali::Vector< int >::ItemType *arg3 = 0 ;
32238   Dali::Vector< int >::ItemType temp3 ;
32239
32240   arg1 = (Dali::Vector< int > *)jarg1;
32241   arg2 = (Dali::Vector< int >::Iterator)jarg2;
32242   temp3 = (Dali::Vector< int >::ItemType)jarg3;
32243   arg3 = &temp3;
32244   {
32245     try {
32246       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
32247     } CALL_CATCH_EXCEPTION();
32248   }
32249
32250 }
32251
32252
32253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
32254   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32255   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
32256   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
32257   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
32258
32259   arg1 = (Dali::Vector< int > *)jarg1;
32260   arg2 = (Dali::Vector< int >::Iterator)jarg2;
32261   arg3 = (Dali::Vector< int >::Iterator)jarg3;
32262   arg4 = (Dali::Vector< int >::Iterator)jarg4;
32263   {
32264     try {
32265       (arg1)->Insert(arg2,arg3,arg4);
32266     } CALL_CATCH_EXCEPTION();
32267   }
32268
32269 }
32270
32271
32272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
32273   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32274   Dali::Vector< int >::SizeType arg2 ;
32275
32276   arg1 = (Dali::Vector< int > *)jarg1;
32277   arg2 = (Dali::Vector< int >::SizeType)jarg2;
32278   {
32279     try {
32280       (arg1)->Reserve(arg2);
32281     } CALL_CATCH_EXCEPTION();
32282   }
32283
32284 }
32285
32286
32287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
32288   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32289   Dali::Vector< int >::SizeType arg2 ;
32290
32291   arg1 = (Dali::Vector< int > *)jarg1;
32292   arg2 = (Dali::Vector< int >::SizeType)jarg2;
32293   {
32294     try {
32295       (arg1)->Resize(arg2);
32296     } CALL_CATCH_EXCEPTION();
32297   }
32298
32299 }
32300
32301
32302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
32303   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32304   Dali::Vector< int >::SizeType arg2 ;
32305   Dali::Vector< int >::ItemType *arg3 = 0 ;
32306   Dali::Vector< int >::ItemType temp3 ;
32307
32308   arg1 = (Dali::Vector< int > *)jarg1;
32309   arg2 = (Dali::Vector< int >::SizeType)jarg2;
32310   temp3 = (Dali::Vector< int >::ItemType)jarg3;
32311   arg3 = &temp3;
32312   {
32313     try {
32314       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
32315     } CALL_CATCH_EXCEPTION();
32316   }
32317
32318 }
32319
32320
32321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
32322   void * jresult ;
32323   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32324   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
32325   Dali::Vector< int >::Iterator result;
32326
32327   arg1 = (Dali::Vector< int > *)jarg1;
32328   arg2 = (Dali::Vector< int >::Iterator)jarg2;
32329   {
32330     try {
32331       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
32332     } CALL_CATCH_EXCEPTION(0);
32333   }
32334
32335   jresult = (void *)result;
32336   return jresult;
32337 }
32338
32339
32340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
32341   void * jresult ;
32342   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32343   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
32344   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
32345   Dali::Vector< int >::Iterator result;
32346
32347   arg1 = (Dali::Vector< int > *)jarg1;
32348   arg2 = (Dali::Vector< int >::Iterator)jarg2;
32349   arg3 = (Dali::Vector< int >::Iterator)jarg3;
32350   {
32351     try {
32352       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
32353     } CALL_CATCH_EXCEPTION(0);
32354   }
32355
32356   jresult = (void *)result;
32357   return jresult;
32358 }
32359
32360
32361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
32362   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32363   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
32364
32365   arg1 = (Dali::Vector< int > *)jarg1;
32366   arg2 = (Dali::Vector< int >::Iterator)jarg2;
32367   {
32368     try {
32369       (arg1)->Remove(arg2);
32370     } CALL_CATCH_EXCEPTION();
32371   }
32372
32373 }
32374
32375
32376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
32377   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32378   Dali::Vector< int > *arg2 = 0 ;
32379
32380   arg1 = (Dali::Vector< int > *)jarg1;
32381   arg2 = (Dali::Vector< int > *)jarg2;
32382   if (!arg2) {
32383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
32384     return ;
32385   }
32386   {
32387     try {
32388       (arg1)->Swap(*arg2);
32389     } CALL_CATCH_EXCEPTION();
32390   }
32391
32392 }
32393
32394
32395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
32396   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32397
32398   arg1 = (Dali::Vector< int > *)jarg1;
32399   {
32400     try {
32401       (arg1)->Clear();
32402     } CALL_CATCH_EXCEPTION();
32403   }
32404
32405 }
32406
32407
32408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
32409   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32410
32411   arg1 = (Dali::Vector< int > *)jarg1;
32412   {
32413     try {
32414       (arg1)->Release();
32415     } CALL_CATCH_EXCEPTION();
32416   }
32417
32418 }
32419
32420
32421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
32422   int jresult ;
32423   int result;
32424
32425   result = (int)Dali::Vector< float >::BaseType;
32426   jresult = (int)result;
32427   return jresult;
32428 }
32429
32430
32431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
32432   void * jresult ;
32433   Dali::Vector< float > *result = 0 ;
32434
32435   {
32436     try {
32437       result = (Dali::Vector< float > *)new Dali::Vector< float >();
32438     } CALL_CATCH_EXCEPTION(0);
32439   }
32440
32441   jresult = (void *)result;
32442   return jresult;
32443 }
32444
32445
32446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
32447   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32448
32449   arg1 = (Dali::Vector< float > *)jarg1;
32450   {
32451     try {
32452       delete arg1;
32453     } CALL_CATCH_EXCEPTION();
32454   }
32455
32456 }
32457
32458
32459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
32460   void * jresult ;
32461   Dali::Vector< float > *arg1 = 0 ;
32462   Dali::Vector< float > *result = 0 ;
32463
32464   arg1 = (Dali::Vector< float > *)jarg1;
32465   if (!arg1) {
32466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
32467     return 0;
32468   }
32469   {
32470     try {
32471       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
32472     } CALL_CATCH_EXCEPTION(0);
32473   }
32474
32475   jresult = (void *)result;
32476   return jresult;
32477 }
32478
32479
32480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
32481   void * jresult ;
32482   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32483   Dali::Vector< float > *arg2 = 0 ;
32484   Dali::Vector< float > *result = 0 ;
32485
32486   arg1 = (Dali::Vector< float > *)jarg1;
32487   arg2 = (Dali::Vector< float > *)jarg2;
32488   if (!arg2) {
32489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
32490     return 0;
32491   }
32492   {
32493     try {
32494       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
32495     } CALL_CATCH_EXCEPTION(0);
32496   }
32497
32498   jresult = (void *)result;
32499   return jresult;
32500 }
32501
32502
32503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
32504   void * jresult ;
32505   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32506   Dali::Vector< float >::Iterator result;
32507
32508   arg1 = (Dali::Vector< float > *)jarg1;
32509   {
32510     try {
32511       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
32512     } CALL_CATCH_EXCEPTION(0);
32513   }
32514
32515   jresult = (void *)result;
32516   return jresult;
32517 }
32518
32519
32520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
32521   void * jresult ;
32522   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32523   Dali::Vector< float >::Iterator result;
32524
32525   arg1 = (Dali::Vector< float > *)jarg1;
32526   {
32527     try {
32528       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
32529     } CALL_CATCH_EXCEPTION(0);
32530   }
32531
32532   jresult = (void *)result;
32533   return jresult;
32534 }
32535
32536
32537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
32538   void * jresult ;
32539   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32540   Dali::Vector< float >::SizeType arg2 ;
32541   Dali::Vector< float >::ItemType *result = 0 ;
32542
32543   arg1 = (Dali::Vector< float > *)jarg1;
32544   arg2 = (Dali::Vector< float >::SizeType)jarg2;
32545   {
32546     try {
32547       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
32548     } CALL_CATCH_EXCEPTION(0);
32549   }
32550
32551   jresult = (void *)result;
32552   return jresult;
32553 }
32554
32555
32556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
32557   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32558   Dali::Vector< float >::ItemType *arg2 = 0 ;
32559   Dali::Vector< float >::ItemType temp2 ;
32560
32561   arg1 = (Dali::Vector< float > *)jarg1;
32562   temp2 = (Dali::Vector< float >::ItemType)jarg2;
32563   arg2 = &temp2;
32564   {
32565     try {
32566       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
32567     } CALL_CATCH_EXCEPTION();
32568   }
32569
32570 }
32571
32572
32573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
32574   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32575   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
32576   Dali::Vector< float >::ItemType *arg3 = 0 ;
32577   Dali::Vector< float >::ItemType temp3 ;
32578
32579   arg1 = (Dali::Vector< float > *)jarg1;
32580   arg2 = (Dali::Vector< float >::Iterator)jarg2;
32581   temp3 = (Dali::Vector< float >::ItemType)jarg3;
32582   arg3 = &temp3;
32583   {
32584     try {
32585       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
32586     } CALL_CATCH_EXCEPTION();
32587   }
32588
32589 }
32590
32591
32592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
32593   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32594   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
32595   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
32596   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
32597
32598   arg1 = (Dali::Vector< float > *)jarg1;
32599   arg2 = (Dali::Vector< float >::Iterator)jarg2;
32600   arg3 = (Dali::Vector< float >::Iterator)jarg3;
32601   arg4 = (Dali::Vector< float >::Iterator)jarg4;
32602   {
32603     try {
32604       (arg1)->Insert(arg2,arg3,arg4);
32605     } CALL_CATCH_EXCEPTION();
32606   }
32607
32608 }
32609
32610
32611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
32612   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32613   Dali::Vector< float >::SizeType arg2 ;
32614
32615   arg1 = (Dali::Vector< float > *)jarg1;
32616   arg2 = (Dali::Vector< float >::SizeType)jarg2;
32617   {
32618     try {
32619       (arg1)->Reserve(arg2);
32620     } CALL_CATCH_EXCEPTION();
32621   }
32622
32623 }
32624
32625 //// ========================= end of part 2 =============================
32626
32627 //// ========================== start part 3 ===============================
32628
32629
32630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
32631   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32632   Dali::Vector< float >::SizeType arg2 ;
32633
32634   arg1 = (Dali::Vector< float > *)jarg1;
32635   arg2 = (Dali::Vector< float >::SizeType)jarg2;
32636   {
32637     try {
32638       (arg1)->Resize(arg2);
32639     } CALL_CATCH_EXCEPTION();
32640   }
32641
32642 }
32643
32644
32645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
32646   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32647   Dali::Vector< float >::SizeType arg2 ;
32648   Dali::Vector< float >::ItemType *arg3 = 0 ;
32649   Dali::Vector< float >::ItemType temp3 ;
32650
32651   arg1 = (Dali::Vector< float > *)jarg1;
32652   arg2 = (Dali::Vector< float >::SizeType)jarg2;
32653   temp3 = (Dali::Vector< float >::ItemType)jarg3;
32654   arg3 = &temp3;
32655   {
32656     try {
32657       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
32658     } CALL_CATCH_EXCEPTION();
32659   }
32660
32661 }
32662
32663
32664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
32665   void * jresult ;
32666   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32667   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
32668   Dali::Vector< float >::Iterator result;
32669
32670   arg1 = (Dali::Vector< float > *)jarg1;
32671   arg2 = (Dali::Vector< float >::Iterator)jarg2;
32672   {
32673     try {
32674       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
32675     } CALL_CATCH_EXCEPTION(0);
32676   }
32677
32678   jresult = (void *)result;
32679   return jresult;
32680 }
32681
32682
32683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
32684   void * jresult ;
32685   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32686   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
32687   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
32688   Dali::Vector< float >::Iterator result;
32689
32690   arg1 = (Dali::Vector< float > *)jarg1;
32691   arg2 = (Dali::Vector< float >::Iterator)jarg2;
32692   arg3 = (Dali::Vector< float >::Iterator)jarg3;
32693   {
32694     try {
32695       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
32696     } CALL_CATCH_EXCEPTION(0);
32697   }
32698
32699   jresult = (void *)result;
32700   return jresult;
32701 }
32702
32703
32704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
32705   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32706   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
32707
32708   arg1 = (Dali::Vector< float > *)jarg1;
32709   arg2 = (Dali::Vector< float >::Iterator)jarg2;
32710   {
32711     try {
32712       (arg1)->Remove(arg2);
32713     } CALL_CATCH_EXCEPTION();
32714   }
32715
32716 }
32717
32718
32719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
32720   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32721   Dali::Vector< float > *arg2 = 0 ;
32722
32723   arg1 = (Dali::Vector< float > *)jarg1;
32724   arg2 = (Dali::Vector< float > *)jarg2;
32725   if (!arg2) {
32726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
32727     return ;
32728   }
32729   {
32730     try {
32731       (arg1)->Swap(*arg2);
32732     } CALL_CATCH_EXCEPTION();
32733   }
32734
32735 }
32736
32737
32738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
32739   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32740
32741   arg1 = (Dali::Vector< float > *)jarg1;
32742   {
32743     try {
32744       (arg1)->Clear();
32745     } CALL_CATCH_EXCEPTION();
32746   }
32747
32748 }
32749
32750
32751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
32752   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32753
32754   arg1 = (Dali::Vector< float > *)jarg1;
32755   {
32756     try {
32757       (arg1)->Release();
32758     } CALL_CATCH_EXCEPTION();
32759   }
32760
32761 }
32762
32763
32764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
32765   int jresult ;
32766   int result;
32767
32768   result = (int)Dali::Vector< unsigned char >::BaseType;
32769   jresult = (int)result;
32770   return jresult;
32771 }
32772
32773
32774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
32775   void * jresult ;
32776   Dali::Vector< unsigned char > *result = 0 ;
32777
32778   {
32779     try {
32780       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
32781     } CALL_CATCH_EXCEPTION(0);
32782   }
32783
32784   jresult = (void *)result;
32785   return jresult;
32786 }
32787
32788
32789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
32790   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32791
32792   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32793   {
32794     try {
32795       delete arg1;
32796     } CALL_CATCH_EXCEPTION();
32797   }
32798
32799 }
32800
32801
32802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
32803   void * jresult ;
32804   Dali::Vector< unsigned char > *arg1 = 0 ;
32805   Dali::Vector< unsigned char > *result = 0 ;
32806
32807   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32808   if (!arg1) {
32809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
32810     return 0;
32811   }
32812   {
32813     try {
32814       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
32815     } CALL_CATCH_EXCEPTION(0);
32816   }
32817
32818   jresult = (void *)result;
32819   return jresult;
32820 }
32821
32822
32823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
32824   void * jresult ;
32825   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32826   Dali::Vector< unsigned char > *arg2 = 0 ;
32827   Dali::Vector< unsigned char > *result = 0 ;
32828
32829   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32830   arg2 = (Dali::Vector< unsigned char > *)jarg2;
32831   if (!arg2) {
32832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
32833     return 0;
32834   }
32835   {
32836     try {
32837       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
32838     } CALL_CATCH_EXCEPTION(0);
32839   }
32840
32841   jresult = (void *)result;
32842   return jresult;
32843 }
32844
32845
32846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
32847   void * jresult ;
32848   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32849   Dali::Vector< unsigned char >::Iterator result;
32850
32851   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32852   {
32853     try {
32854       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
32855     } CALL_CATCH_EXCEPTION(0);
32856   }
32857
32858   jresult = (void *)result;
32859   return jresult;
32860 }
32861
32862
32863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
32864   void * jresult ;
32865   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32866   Dali::Vector< unsigned char >::Iterator result;
32867
32868   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32869   {
32870     try {
32871       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
32872     } CALL_CATCH_EXCEPTION(0);
32873   }
32874
32875   jresult = (void *)result;
32876   return jresult;
32877 }
32878
32879
32880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
32881   void * jresult ;
32882   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32883   Dali::Vector< unsigned char >::SizeType arg2 ;
32884   Dali::Vector< unsigned char >::ItemType *result = 0 ;
32885
32886   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32887   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
32888   {
32889     try {
32890       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
32891     } CALL_CATCH_EXCEPTION(0);
32892   }
32893
32894   jresult = (void *)result;
32895   return jresult;
32896 }
32897
32898
32899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
32900   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32901   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
32902   Dali::Vector< unsigned char >::ItemType temp2 ;
32903
32904   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32905   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
32906   arg2 = &temp2;
32907   {
32908     try {
32909       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
32910     } CALL_CATCH_EXCEPTION();
32911   }
32912
32913 }
32914
32915
32916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
32917   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32918   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
32919   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
32920   Dali::Vector< unsigned char >::ItemType temp3 ;
32921
32922   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32923   arg2 = jarg2;
32924   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
32925   arg3 = &temp3;
32926   {
32927     try {
32928       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
32929     } CALL_CATCH_EXCEPTION();
32930   }
32931
32932
32933
32934 }
32935
32936
32937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
32938   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32939   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
32940   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
32941   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
32942
32943   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32944   arg2 = jarg2;
32945   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
32946   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
32947   {
32948     try {
32949       (arg1)->Insert(arg2,arg3,arg4);
32950     } CALL_CATCH_EXCEPTION();
32951   }
32952
32953
32954
32955 }
32956
32957
32958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
32959   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32960   Dali::Vector< unsigned char >::SizeType arg2 ;
32961
32962   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32963   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
32964   {
32965     try {
32966       (arg1)->Reserve(arg2);
32967     } CALL_CATCH_EXCEPTION();
32968   }
32969
32970 }
32971
32972
32973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
32974   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32975   Dali::Vector< unsigned char >::SizeType arg2 ;
32976
32977   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32978   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
32979   {
32980     try {
32981       (arg1)->Resize(arg2);
32982     } CALL_CATCH_EXCEPTION();
32983   }
32984
32985 }
32986
32987
32988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
32989   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32990   Dali::Vector< unsigned char >::SizeType arg2 ;
32991   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
32992   Dali::Vector< unsigned char >::ItemType temp3 ;
32993
32994   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32995   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
32996   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
32997   arg3 = &temp3;
32998   {
32999     try {
33000       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
33001     } CALL_CATCH_EXCEPTION();
33002   }
33003
33004 }
33005
33006
33007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
33008   void * jresult ;
33009   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
33010   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
33011   Dali::Vector< unsigned char >::Iterator result;
33012
33013   arg1 = (Dali::Vector< unsigned char > *)jarg1;
33014   arg2 = jarg2;
33015   {
33016     try {
33017       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
33018     } CALL_CATCH_EXCEPTION(0);
33019   }
33020
33021   jresult = (void *)result;
33022
33023
33024   return jresult;
33025 }
33026
33027
33028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
33029   void * jresult ;
33030   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
33031   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
33032   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
33033   Dali::Vector< unsigned char >::Iterator result;
33034
33035   arg1 = (Dali::Vector< unsigned char > *)jarg1;
33036   arg2 = jarg2;
33037   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
33038   {
33039     try {
33040       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
33041     } CALL_CATCH_EXCEPTION(0);
33042   }
33043
33044   jresult = (void *)result;
33045
33046
33047   return jresult;
33048 }
33049
33050
33051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
33052   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
33053   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
33054
33055   arg1 = (Dali::Vector< unsigned char > *)jarg1;
33056   arg2 = jarg2;
33057   {
33058     try {
33059       (arg1)->Remove(arg2);
33060     } CALL_CATCH_EXCEPTION();
33061   }
33062
33063
33064
33065 }
33066
33067
33068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
33069   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
33070   Dali::Vector< unsigned char > *arg2 = 0 ;
33071
33072   arg1 = (Dali::Vector< unsigned char > *)jarg1;
33073   arg2 = (Dali::Vector< unsigned char > *)jarg2;
33074   if (!arg2) {
33075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
33076     return ;
33077   }
33078   {
33079     try {
33080       (arg1)->Swap(*arg2);
33081     } CALL_CATCH_EXCEPTION();
33082   }
33083
33084 }
33085
33086
33087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
33088   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
33089
33090   arg1 = (Dali::Vector< unsigned char > *)jarg1;
33091   {
33092     try {
33093       (arg1)->Clear();
33094     } CALL_CATCH_EXCEPTION();
33095   }
33096
33097 }
33098
33099
33100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
33101   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
33102
33103   arg1 = (Dali::Vector< unsigned char > *)jarg1;
33104   {
33105     try {
33106       (arg1)->Release();
33107     } CALL_CATCH_EXCEPTION();
33108   }
33109
33110 }
33111
33112
33113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
33114   int jresult ;
33115   int result;
33116
33117   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
33118   jresult = (int)result;
33119   return jresult;
33120 }
33121
33122
33123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
33124   void * jresult ;
33125   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
33126
33127   {
33128     try {
33129       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
33130     } CALL_CATCH_EXCEPTION(0);
33131   }
33132
33133   jresult = (void *)result;
33134   return jresult;
33135 }
33136
33137
33138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
33139   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33140
33141   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33142   {
33143     try {
33144       delete arg1;
33145     } CALL_CATCH_EXCEPTION();
33146   }
33147
33148 }
33149
33150
33151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
33152   void * jresult ;
33153   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
33154   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
33155
33156   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33157   if (!arg1) {
33158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
33159     return 0;
33160   }
33161   {
33162     try {
33163       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
33164     } CALL_CATCH_EXCEPTION(0);
33165   }
33166
33167   jresult = (void *)result;
33168   return jresult;
33169 }
33170
33171
33172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
33173   void * jresult ;
33174   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33175   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
33176   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
33177
33178   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33179   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
33180   if (!arg2) {
33181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
33182     return 0;
33183   }
33184   {
33185     try {
33186       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
33187     } CALL_CATCH_EXCEPTION(0);
33188   }
33189
33190   jresult = (void *)result;
33191   return jresult;
33192 }
33193
33194
33195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
33196   void * jresult ;
33197   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33198   Dali::Vector< Dali::Uint16Pair >::Iterator result;
33199
33200   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33201   {
33202     try {
33203       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
33204     } CALL_CATCH_EXCEPTION(0);
33205   }
33206
33207   jresult = (void *)result;
33208   return jresult;
33209 }
33210
33211
33212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
33213   void * jresult ;
33214   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33215   Dali::Vector< Dali::Uint16Pair >::Iterator result;
33216
33217   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33218   {
33219     try {
33220       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
33221     } CALL_CATCH_EXCEPTION(0);
33222   }
33223
33224   jresult = (void *)result;
33225   return jresult;
33226 }
33227
33228
33229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
33230   void * jresult ;
33231   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33232   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
33233   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
33234
33235   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33236   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
33237   {
33238     try {
33239       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
33240     } CALL_CATCH_EXCEPTION(0);
33241   }
33242
33243   jresult = (void *)result;
33244   return jresult;
33245 }
33246
33247
33248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
33249   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33250   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
33251
33252   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33253   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
33254   if (!arg2) {
33255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
33256     return ;
33257   }
33258   {
33259     try {
33260       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
33261     } CALL_CATCH_EXCEPTION();
33262   }
33263
33264 }
33265
33266
33267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
33268   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33269   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
33270   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
33271
33272   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33273   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
33274   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
33275   if (!arg3) {
33276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
33277     return ;
33278   }
33279   {
33280     try {
33281       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
33282     } CALL_CATCH_EXCEPTION();
33283   }
33284
33285 }
33286
33287
33288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
33289   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33290   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
33291   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
33292   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
33293
33294   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33295   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
33296   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
33297   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
33298   {
33299     try {
33300       (arg1)->Insert(arg2,arg3,arg4);
33301     } CALL_CATCH_EXCEPTION();
33302   }
33303
33304 }
33305
33306
33307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
33308   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33309   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
33310
33311   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33312   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
33313   {
33314     try {
33315       (arg1)->Reserve(arg2);
33316     } CALL_CATCH_EXCEPTION();
33317   }
33318
33319 }
33320
33321
33322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
33323   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33324   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
33325
33326   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33327   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
33328   {
33329     try {
33330       (arg1)->Resize(arg2);
33331     } CALL_CATCH_EXCEPTION();
33332   }
33333
33334 }
33335
33336
33337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
33338   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33339   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
33340   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
33341
33342   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33343   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
33344   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
33345   if (!arg3) {
33346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
33347     return ;
33348   }
33349   {
33350     try {
33351       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
33352     } CALL_CATCH_EXCEPTION();
33353   }
33354
33355 }
33356
33357
33358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
33359   void * jresult ;
33360   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33361   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
33362   Dali::Vector< Dali::Uint16Pair >::Iterator result;
33363
33364   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33365   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
33366   {
33367     try {
33368       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
33369     } CALL_CATCH_EXCEPTION(0);
33370   }
33371
33372   jresult = (void *)result;
33373   return jresult;
33374 }
33375
33376
33377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
33378   void * jresult ;
33379   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33380   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
33381   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
33382   Dali::Vector< Dali::Uint16Pair >::Iterator result;
33383
33384   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33385   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
33386   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
33387   {
33388     try {
33389       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
33390     } CALL_CATCH_EXCEPTION(0);
33391   }
33392
33393   jresult = (void *)result;
33394   return jresult;
33395 }
33396
33397
33398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
33399   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33400   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
33401
33402   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33403   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
33404   {
33405     try {
33406       (arg1)->Remove(arg2);
33407     } CALL_CATCH_EXCEPTION();
33408   }
33409
33410 }
33411
33412
33413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
33414   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33415   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
33416
33417   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33418   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
33419   if (!arg2) {
33420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
33421     return ;
33422   }
33423   {
33424     try {
33425       (arg1)->Swap(*arg2);
33426     } CALL_CATCH_EXCEPTION();
33427   }
33428
33429 }
33430
33431
33432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
33433   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33434
33435   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33436   {
33437     try {
33438       (arg1)->Clear();
33439     } CALL_CATCH_EXCEPTION();
33440   }
33441
33442 }
33443
33444
33445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
33446   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33447
33448   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33449   {
33450     try {
33451       (arg1)->Release();
33452     } CALL_CATCH_EXCEPTION();
33453   }
33454
33455 }
33456
33457
33458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
33459   void * jresult ;
33460   Dali::Signal< void () > *result = 0 ;
33461
33462   {
33463     try {
33464       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
33465     } CALL_CATCH_EXCEPTION(0);
33466   }
33467
33468   jresult = (void *)result;
33469   return jresult;
33470 }
33471
33472
33473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
33474   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
33475
33476   arg1 = (Dali::Signal< void () > *)jarg1;
33477   {
33478     try {
33479       delete arg1;
33480     } CALL_CATCH_EXCEPTION();
33481   }
33482
33483 }
33484
33485
33486 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
33487   bool jresult ;
33488   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
33489   bool result;
33490
33491   arg1 = (Dali::Signal< void () > *)jarg1;
33492   {
33493     try {
33494       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
33495     } CALL_CATCH_EXCEPTION(0);
33496   }
33497
33498   jresult = result;
33499   return jresult;
33500 }
33501
33502
33503 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
33504   unsigned long jresult ;
33505   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
33506   std::size_t result;
33507
33508   arg1 = (Dali::Signal< void () > *)jarg1;
33509   {
33510     try {
33511       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
33512     } CALL_CATCH_EXCEPTION(0);
33513   }
33514
33515   jresult = (unsigned long)result;
33516   return jresult;
33517 }
33518
33519
33520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
33521   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
33522   void (*arg2)() = (void (*)()) 0 ;
33523
33524   arg1 = (Dali::Signal< void () > *)jarg1;
33525   arg2 = (void (*)())jarg2;
33526   {
33527     try {
33528       (arg1)->Connect(arg2);
33529     } CALL_CATCH_EXCEPTION();
33530   }
33531
33532 }
33533
33534
33535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
33536   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
33537   void (*arg2)() = (void (*)()) 0 ;
33538
33539   arg1 = (Dali::Signal< void () > *)jarg1;
33540   arg2 = (void (*)())jarg2;
33541   {
33542     try {
33543       (arg1)->Disconnect(arg2);
33544     } CALL_CATCH_EXCEPTION();
33545   }
33546
33547 }
33548
33549
33550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
33551   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
33552   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
33553   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
33554
33555   arg1 = (Dali::Signal< void () > *)jarg1;
33556   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
33557   arg3 = (Dali::FunctorDelegate *)jarg3;
33558   {
33559     try {
33560       (arg1)->Connect(arg2,arg3);
33561     } CALL_CATCH_EXCEPTION();
33562   }
33563
33564 }
33565
33566
33567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
33568   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
33569
33570   arg1 = (Dali::Signal< void () > *)jarg1;
33571   {
33572     try {
33573       (arg1)->Emit();
33574     } CALL_CATCH_EXCEPTION();
33575   }
33576
33577 }
33578
33579
33580 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
33581   bool jresult ;
33582   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
33583   bool result;
33584
33585   arg1 = (Dali::Signal< void (float) > *)jarg1;
33586   {
33587     try {
33588       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
33589     } CALL_CATCH_EXCEPTION(0);
33590   }
33591
33592   jresult = result;
33593   return jresult;
33594 }
33595
33596
33597 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
33598   unsigned long jresult ;
33599   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
33600   std::size_t result;
33601
33602   arg1 = (Dali::Signal< void (float) > *)jarg1;
33603   {
33604     try {
33605       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
33606     } CALL_CATCH_EXCEPTION(0);
33607   }
33608
33609   jresult = (unsigned long)result;
33610   return jresult;
33611 }
33612
33613
33614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
33615   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
33616   void (*arg2)(float) = (void (*)(float)) 0 ;
33617
33618   arg1 = (Dali::Signal< void (float) > *)jarg1;
33619   arg2 = (void (*)(float))jarg2;
33620   {
33621     try {
33622       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
33623     } CALL_CATCH_EXCEPTION();
33624   }
33625
33626 }
33627
33628
33629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
33630   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
33631   void (*arg2)(float) = (void (*)(float)) 0 ;
33632
33633   arg1 = (Dali::Signal< void (float) > *)jarg1;
33634   arg2 = (void (*)(float))jarg2;
33635   {
33636     try {
33637       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
33638     } CALL_CATCH_EXCEPTION();
33639   }
33640
33641 }
33642
33643
33644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
33645   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
33646   float arg2 ;
33647
33648   arg1 = (Dali::Signal< void (float) > *)jarg1;
33649   arg2 = (float)jarg2;
33650   {
33651     try {
33652       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
33653     } CALL_CATCH_EXCEPTION();
33654   }
33655
33656 }
33657
33658
33659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
33660   void * jresult ;
33661   Dali::Signal< void (float) > *result = 0 ;
33662
33663   {
33664     try {
33665       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
33666     } CALL_CATCH_EXCEPTION(0);
33667   }
33668
33669   jresult = (void *)result;
33670   return jresult;
33671 }
33672
33673
33674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
33675   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
33676
33677   arg1 = (Dali::Signal< void (float) > *)jarg1;
33678   {
33679     try {
33680       delete arg1;
33681     } CALL_CATCH_EXCEPTION();
33682   }
33683
33684 }
33685
33686
33687 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
33688   bool jresult ;
33689   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
33690   bool result;
33691
33692   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
33693   {
33694     try {
33695       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
33696     } CALL_CATCH_EXCEPTION(0);
33697   }
33698
33699   jresult = result;
33700   return jresult;
33701 }
33702
33703
33704 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
33705   unsigned long jresult ;
33706   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
33707   std::size_t result;
33708
33709   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
33710   {
33711     try {
33712       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
33713     } CALL_CATCH_EXCEPTION(0);
33714   }
33715
33716   jresult = (unsigned long)result;
33717   return jresult;
33718 }
33719
33720
33721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
33722   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
33723   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
33724
33725   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
33726   arg2 = (void (*)(Dali::BaseHandle))jarg2;
33727   {
33728     try {
33729       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
33730     } CALL_CATCH_EXCEPTION();
33731   }
33732
33733 }
33734
33735
33736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
33737   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
33738   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
33739
33740   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
33741   arg2 = (void (*)(Dali::BaseHandle))jarg2;
33742   {
33743     try {
33744       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
33745     } CALL_CATCH_EXCEPTION();
33746   }
33747
33748 }
33749
33750
33751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
33752   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
33753   Dali::BaseHandle arg2 ;
33754   Dali::BaseHandle *argp2 ;
33755
33756   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
33757   argp2 = (Dali::BaseHandle *)jarg2;
33758   if (!argp2) {
33759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33760     return ;
33761   }
33762   arg2 = *argp2;
33763   {
33764     try {
33765       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
33766     } CALL_CATCH_EXCEPTION();
33767   }
33768
33769 }
33770
33771
33772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
33773   void * jresult ;
33774   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
33775
33776   {
33777     try {
33778       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
33779     } CALL_CATCH_EXCEPTION(0);
33780   }
33781
33782   jresult = (void *)result;
33783   return jresult;
33784 }
33785
33786
33787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
33788   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
33789
33790   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
33791   {
33792     try {
33793       delete arg1;
33794     } CALL_CATCH_EXCEPTION();
33795   }
33796
33797 }
33798
33799
33800 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
33801   bool jresult ;
33802   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
33803   bool result;
33804
33805   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
33806   {
33807     try {
33808       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
33809     } CALL_CATCH_EXCEPTION(0);
33810   }
33811
33812   jresult = result;
33813   return jresult;
33814 }
33815
33816
33817 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
33818   unsigned long jresult ;
33819   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
33820   std::size_t result;
33821
33822   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
33823   {
33824     try {
33825       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
33826     } CALL_CATCH_EXCEPTION(0);
33827   }
33828
33829   jresult = (unsigned long)result;
33830   return jresult;
33831 }
33832
33833
33834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
33835   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
33836   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
33837
33838   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
33839   arg2 = (void (*)(Dali::RefObject const *))jarg2;
33840   {
33841     try {
33842       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
33843     } CALL_CATCH_EXCEPTION();
33844   }
33845
33846 }
33847
33848
33849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
33850   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
33851   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
33852
33853   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
33854   arg2 = (void (*)(Dali::RefObject const *))jarg2;
33855   {
33856     try {
33857       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
33858     } CALL_CATCH_EXCEPTION();
33859   }
33860
33861 }
33862
33863
33864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
33865   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
33866   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
33867
33868   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
33869   arg2 = (Dali::RefObject *)jarg2;
33870   {
33871     try {
33872       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
33873     } CALL_CATCH_EXCEPTION();
33874   }
33875
33876 }
33877
33878
33879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
33880   void * jresult ;
33881   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
33882
33883   {
33884     try {
33885       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
33886     } CALL_CATCH_EXCEPTION(0);
33887   }
33888
33889   jresult = (void *)result;
33890   return jresult;
33891 }
33892
33893
33894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
33895   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
33896
33897   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
33898   {
33899     try {
33900       delete arg1;
33901     } CALL_CATCH_EXCEPTION();
33902   }
33903
33904 }
33905
33906
33907 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
33908   bool jresult ;
33909   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
33910   bool result;
33911
33912   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
33913   {
33914     try {
33915       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
33916     } CALL_CATCH_EXCEPTION(0);
33917   }
33918
33919   jresult = result;
33920   return jresult;
33921 }
33922
33923
33924 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
33925   unsigned long jresult ;
33926   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
33927   std::size_t result;
33928
33929   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
33930   {
33931     try {
33932       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
33933     } CALL_CATCH_EXCEPTION(0);
33934   }
33935
33936   jresult = (unsigned long)result;
33937   return jresult;
33938 }
33939
33940
33941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
33942   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
33943   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
33944
33945   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
33946   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
33947   {
33948     try {
33949       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
33950     } CALL_CATCH_EXCEPTION();
33951   }
33952
33953 }
33954
33955
33956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
33957   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
33958   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
33959
33960   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
33961   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
33962   {
33963     try {
33964       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
33965     } CALL_CATCH_EXCEPTION();
33966   }
33967
33968 }
33969
33970
33971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
33972   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
33973   Dali::PropertyNotification *arg2 = 0 ;
33974
33975   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
33976   arg2 = (Dali::PropertyNotification *)jarg2;
33977   if (!arg2) {
33978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
33979     return ;
33980   }
33981   {
33982     try {
33983       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
33984     } CALL_CATCH_EXCEPTION();
33985   }
33986
33987 }
33988
33989
33990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
33991   void * jresult ;
33992   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
33993
33994   {
33995     try {
33996       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
33997     } CALL_CATCH_EXCEPTION(0);
33998   }
33999
34000   jresult = (void *)result;
34001   return jresult;
34002 }
34003
34004
34005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
34006   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
34007
34008   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
34009   {
34010     try {
34011       delete arg1;
34012     } CALL_CATCH_EXCEPTION();
34013   }
34014
34015 }
34016
34017
34018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
34019   void * jresult ;
34020   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
34021
34022   {
34023     try {
34024       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
34025     } CALL_CATCH_EXCEPTION(0);
34026   }
34027
34028   jresult = (void *)result;
34029   return jresult;
34030 }
34031
34032
34033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
34034   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
34035
34036   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
34037   {
34038     try {
34039       delete arg1;
34040     } CALL_CATCH_EXCEPTION();
34041   }
34042
34043 }
34044
34045
34046 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
34047   bool jresult ;
34048   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
34049   bool result;
34050
34051   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
34052   {
34053     try {
34054       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);
34055     } CALL_CATCH_EXCEPTION(0);
34056   }
34057
34058   jresult = result;
34059   return jresult;
34060 }
34061
34062
34063 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
34064   unsigned long jresult ;
34065   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
34066   std::size_t result;
34067
34068   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
34069   {
34070     try {
34071       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);
34072     } CALL_CATCH_EXCEPTION(0);
34073   }
34074
34075   jresult = (unsigned long)result;
34076   return jresult;
34077 }
34078
34079
34080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
34081   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
34082   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
34083
34084   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
34085   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
34086   {
34087     try {
34088       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
34089     } CALL_CATCH_EXCEPTION();
34090   }
34091
34092 }
34093
34094
34095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
34096   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
34097   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
34098
34099   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
34100   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
34101   {
34102     try {
34103       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
34104     } CALL_CATCH_EXCEPTION();
34105   }
34106
34107 }
34108
34109
34110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
34111   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
34112   Dali::Actor arg2 ;
34113   Dali::LongPressGesture *arg3 = 0 ;
34114   Dali::Actor *argp2 ;
34115
34116   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
34117   argp2 = (Dali::Actor *)jarg2;
34118   if (!argp2) {
34119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34120     return ;
34121   }
34122   arg2 = *argp2;
34123   arg3 = (Dali::LongPressGesture *)jarg3;
34124   if (!arg3) {
34125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
34126     return ;
34127   }
34128   {
34129     try {
34130       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
34131     } CALL_CATCH_EXCEPTION();
34132   }
34133
34134 }
34135
34136
34137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
34138   void * jresult ;
34139   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
34140
34141   {
34142     try {
34143       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
34144     } CALL_CATCH_EXCEPTION(0);
34145   }
34146
34147   jresult = (void *)result;
34148   return jresult;
34149 }
34150
34151
34152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
34153   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
34154
34155   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
34156   {
34157     try {
34158       delete arg1;
34159     } CALL_CATCH_EXCEPTION();
34160   }
34161
34162 }
34163
34164
34165 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
34166   bool jresult ;
34167   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
34168   bool result;
34169
34170   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
34171   {
34172     try {
34173       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);
34174     } CALL_CATCH_EXCEPTION(0);
34175   }
34176
34177   jresult = result;
34178   return jresult;
34179 }
34180
34181
34182 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
34183   unsigned long jresult ;
34184   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
34185   std::size_t result;
34186
34187   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
34188   {
34189     try {
34190       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);
34191     } CALL_CATCH_EXCEPTION(0);
34192   }
34193
34194   jresult = (unsigned long)result;
34195   return jresult;
34196 }
34197
34198
34199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
34200   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
34201   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
34202
34203   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
34204   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
34205   {
34206     try {
34207       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
34208     } CALL_CATCH_EXCEPTION();
34209   }
34210
34211 }
34212
34213
34214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
34215   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
34216   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
34217
34218   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
34219   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
34220   {
34221     try {
34222       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
34223     } CALL_CATCH_EXCEPTION();
34224   }
34225
34226 }
34227
34228
34229 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
34230   bool jresult ;
34231   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
34232   Dali::Actor arg2 ;
34233   Dali::TouchEvent *arg3 = 0 ;
34234   Dali::Actor *argp2 ;
34235   bool result;
34236
34237   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
34238   argp2 = (Dali::Actor *)jarg2;
34239   if (!argp2) {
34240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34241     return 0;
34242   }
34243   arg2 = *argp2;
34244   arg3 = (Dali::TouchEvent *)jarg3;
34245   if (!arg3) {
34246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
34247     return 0;
34248   }
34249   {
34250     try {
34251       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchEvent const &)*arg3);
34252     } CALL_CATCH_EXCEPTION(0);
34253   }
34254
34255   jresult = result;
34256   return jresult;
34257 }
34258
34259
34260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
34261   void * jresult ;
34262   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *result = 0 ;
34263
34264   {
34265     try {
34266       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) >();
34267     } CALL_CATCH_EXCEPTION(0);
34268   }
34269
34270   jresult = (void *)result;
34271   return jresult;
34272 }
34273
34274
34275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
34276   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
34277
34278   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
34279   {
34280     try {
34281       delete arg1;
34282     } CALL_CATCH_EXCEPTION();
34283   }
34284
34285 }
34286
34287
34288 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
34289   bool jresult ;
34290   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
34291   bool result;
34292
34293   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
34294   {
34295     try {
34296       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);
34297     } CALL_CATCH_EXCEPTION(0);
34298   }
34299
34300   jresult = result;
34301   return jresult;
34302 }
34303
34304
34305 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
34306   unsigned long jresult ;
34307   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
34308   std::size_t result;
34309
34310   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
34311   {
34312     try {
34313       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);
34314     } CALL_CATCH_EXCEPTION(0);
34315   }
34316
34317   jresult = (unsigned long)result;
34318   return jresult;
34319 }
34320
34321
34322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
34323   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
34324   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
34325
34326   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
34327   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
34328   {
34329     try {
34330       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
34331     } CALL_CATCH_EXCEPTION();
34332   }
34333
34334 }
34335
34336
34337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
34338   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
34339   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
34340
34341   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
34342   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
34343   {
34344     try {
34345       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
34346     } CALL_CATCH_EXCEPTION();
34347   }
34348
34349 }
34350
34351
34352 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
34353   bool jresult ;
34354   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
34355   Dali::Actor arg2 ;
34356   Dali::HoverEvent *arg3 = 0 ;
34357   Dali::Actor *argp2 ;
34358   bool result;
34359
34360   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
34361   argp2 = (Dali::Actor *)jarg2;
34362   if (!argp2) {
34363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34364     return 0;
34365   }
34366   arg2 = *argp2;
34367   arg3 = (Dali::HoverEvent *)jarg3;
34368   if (!arg3) {
34369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
34370     return 0;
34371   }
34372   {
34373     try {
34374       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
34375     } CALL_CATCH_EXCEPTION(0);
34376   }
34377
34378   jresult = result;
34379   return jresult;
34380 }
34381
34382
34383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
34384   void * jresult ;
34385   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
34386
34387   {
34388     try {
34389       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
34390     } CALL_CATCH_EXCEPTION(0);
34391   }
34392
34393   jresult = (void *)result;
34394   return jresult;
34395 }
34396
34397
34398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
34399   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
34400
34401   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
34402   {
34403     try {
34404       delete arg1;
34405     } CALL_CATCH_EXCEPTION();
34406   }
34407
34408 }
34409
34410
34411 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
34412   bool jresult ;
34413   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
34414   bool result;
34415
34416   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
34417   {
34418     try {
34419       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);
34420     } CALL_CATCH_EXCEPTION(0);
34421   }
34422
34423   jresult = result;
34424   return jresult;
34425 }
34426
34427
34428 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
34429   unsigned long jresult ;
34430   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
34431   std::size_t result;
34432
34433   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
34434   {
34435     try {
34436       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);
34437     } CALL_CATCH_EXCEPTION(0);
34438   }
34439
34440   jresult = (unsigned long)result;
34441   return jresult;
34442 }
34443
34444
34445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
34446   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
34447   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
34448
34449   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
34450   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
34451   {
34452     try {
34453       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
34454     } CALL_CATCH_EXCEPTION();
34455   }
34456
34457 }
34458
34459
34460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
34461   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
34462   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
34463
34464   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
34465   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
34466   {
34467     try {
34468       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
34469     } CALL_CATCH_EXCEPTION();
34470   }
34471
34472 }
34473
34474
34475 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
34476   bool jresult ;
34477   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
34478   Dali::Actor arg2 ;
34479   Dali::WheelEvent *arg3 = 0 ;
34480   Dali::Actor *argp2 ;
34481   bool result;
34482
34483   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
34484   argp2 = (Dali::Actor *)jarg2;
34485   if (!argp2) {
34486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34487     return 0;
34488   }
34489   arg2 = *argp2;
34490   arg3 = (Dali::WheelEvent *)jarg3;
34491   if (!arg3) {
34492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34493     return 0;
34494   }
34495   {
34496     try {
34497       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
34498     } CALL_CATCH_EXCEPTION(0);
34499   }
34500
34501   jresult = result;
34502   return jresult;
34503 }
34504
34505
34506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
34507   void * jresult ;
34508   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
34509
34510   {
34511     try {
34512       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
34513     } CALL_CATCH_EXCEPTION(0);
34514   }
34515
34516   jresult = (void *)result;
34517   return jresult;
34518 }
34519
34520
34521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
34522   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
34523
34524   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
34525   {
34526     try {
34527       delete arg1;
34528     } CALL_CATCH_EXCEPTION();
34529   }
34530
34531 }
34532
34533
34534 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
34535   bool jresult ;
34536   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
34537   bool result;
34538
34539   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
34540   {
34541     try {
34542       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
34543     } CALL_CATCH_EXCEPTION(0);
34544   }
34545
34546   jresult = result;
34547   return jresult;
34548 }
34549
34550
34551 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
34552   unsigned long jresult ;
34553   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
34554   std::size_t result;
34555
34556   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
34557   {
34558     try {
34559       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
34560     } CALL_CATCH_EXCEPTION(0);
34561   }
34562
34563   jresult = (unsigned long)result;
34564   return jresult;
34565 }
34566
34567
34568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
34569   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
34570   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
34571
34572   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
34573   arg2 = (void (*)(Dali::Actor))jarg2;
34574   {
34575     try {
34576       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
34577     } CALL_CATCH_EXCEPTION();
34578   }
34579
34580 }
34581
34582
34583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
34584   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
34585   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
34586
34587   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
34588   arg2 = (void (*)(Dali::Actor))jarg2;
34589   {
34590     try {
34591       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
34592     } CALL_CATCH_EXCEPTION();
34593   }
34594
34595 }
34596
34597
34598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
34599   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
34600   Dali::Actor arg2 ;
34601   Dali::Actor *argp2 ;
34602
34603   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
34604   argp2 = (Dali::Actor *)jarg2;
34605   if (!argp2) {
34606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34607     return ;
34608   }
34609   arg2 = *argp2;
34610   {
34611     try {
34612       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
34613     } CALL_CATCH_EXCEPTION();
34614   }
34615
34616 }
34617
34618
34619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
34620   void * jresult ;
34621   Dali::Signal< void (Dali::Actor) > *result = 0 ;
34622
34623   {
34624     try {
34625       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
34626     } CALL_CATCH_EXCEPTION(0);
34627   }
34628
34629   jresult = (void *)result;
34630   return jresult;
34631 }
34632
34633
34634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
34635   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
34636
34637   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
34638   {
34639     try {
34640       delete arg1;
34641     } CALL_CATCH_EXCEPTION();
34642   }
34643
34644 }
34645
34646
34647 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
34648   bool jresult ;
34649   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
34650   bool result;
34651
34652   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
34653   {
34654     try {
34655       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
34656     } CALL_CATCH_EXCEPTION(0);
34657   }
34658
34659   jresult = result;
34660   return jresult;
34661 }
34662
34663
34664 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
34665   unsigned long jresult ;
34666   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
34667   std::size_t result;
34668
34669   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
34670   {
34671     try {
34672       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
34673     } CALL_CATCH_EXCEPTION(0);
34674   }
34675
34676   jresult = (unsigned long)result;
34677   return jresult;
34678 }
34679
34680
34681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
34682   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
34683   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
34684
34685   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
34686   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
34687   {
34688     try {
34689       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
34690     } CALL_CATCH_EXCEPTION();
34691   }
34692
34693 }
34694
34695
34696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
34697   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
34698   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
34699
34700   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
34701   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
34702   {
34703     try {
34704       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
34705     } CALL_CATCH_EXCEPTION();
34706   }
34707
34708 }
34709
34710
34711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
34712   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
34713   Dali::KeyEvent *arg2 = 0 ;
34714
34715   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
34716   arg2 = (Dali::KeyEvent *)jarg2;
34717   if (!arg2) {
34718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
34719     return ;
34720   }
34721   {
34722     try {
34723       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
34724     } CALL_CATCH_EXCEPTION();
34725   }
34726
34727 }
34728
34729
34730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
34731   void * jresult ;
34732   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
34733
34734   {
34735     try {
34736       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
34737     } CALL_CATCH_EXCEPTION(0);
34738   }
34739
34740   jresult = (void *)result;
34741   return jresult;
34742 }
34743
34744
34745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
34746   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
34747
34748   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
34749   {
34750     try {
34751       delete arg1;
34752     } CALL_CATCH_EXCEPTION();
34753   }
34754
34755 }
34756
34757
34758 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
34759   bool jresult ;
34760   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
34761   bool result;
34762
34763   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
34764   {
34765     try {
34766       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
34767     } CALL_CATCH_EXCEPTION(0);
34768   }
34769
34770   jresult = result;
34771   return jresult;
34772 }
34773
34774
34775 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
34776   unsigned long jresult ;
34777   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
34778   std::size_t result;
34779
34780   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
34781   {
34782     try {
34783       result = Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
34784     } CALL_CATCH_EXCEPTION(0);
34785   }
34786
34787   jresult = (unsigned long)result;
34788   return jresult;
34789 }
34790
34791
34792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
34793   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
34794   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
34795
34796   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
34797   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
34798   {
34799     try {
34800       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
34801     } CALL_CATCH_EXCEPTION();
34802   }
34803
34804 }
34805
34806
34807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
34808   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
34809   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
34810
34811   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
34812   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
34813   {
34814     try {
34815       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
34816     } CALL_CATCH_EXCEPTION();
34817   }
34818
34819 }
34820
34821
34822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
34823   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
34824   Dali::TouchEvent *arg2 = 0 ;
34825
34826   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
34827   arg2 = (Dali::TouchEvent *)jarg2;
34828   if (!arg2) {
34829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
34830     return ;
34831   }
34832   {
34833     try {
34834       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchEvent const &)*arg2);
34835     } CALL_CATCH_EXCEPTION();
34836   }
34837
34838 }
34839
34840
34841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
34842   void * jresult ;
34843   Dali::Signal< void (Dali::TouchEvent const &) > *result = 0 ;
34844
34845   {
34846     try {
34847       result = (Dali::Signal< void (Dali::TouchEvent const &) > *)new Dali::Signal< void (Dali::TouchEvent const &) >();
34848     } CALL_CATCH_EXCEPTION(0);
34849   }
34850
34851   jresult = (void *)result;
34852   return jresult;
34853 }
34854
34855
34856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
34857   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
34858
34859   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
34860   {
34861     try {
34862       delete arg1;
34863     } CALL_CATCH_EXCEPTION();
34864   }
34865
34866 }
34867
34868
34869 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
34870   bool jresult ;
34871   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
34872   bool result;
34873
34874   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
34875   {
34876     try {
34877       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
34878     } CALL_CATCH_EXCEPTION(0);
34879   }
34880
34881   jresult = result;
34882   return jresult;
34883 }
34884
34885
34886 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
34887   unsigned long jresult ;
34888   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
34889   std::size_t result;
34890
34891   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
34892   {
34893     try {
34894       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
34895     } CALL_CATCH_EXCEPTION(0);
34896   }
34897
34898   jresult = (unsigned long)result;
34899   return jresult;
34900 }
34901
34902
34903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
34904   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
34905   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
34906
34907   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
34908   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
34909   {
34910     try {
34911       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
34912     } CALL_CATCH_EXCEPTION();
34913   }
34914
34915 }
34916
34917
34918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
34919   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
34920   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
34921
34922   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
34923   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
34924   {
34925     try {
34926       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
34927     } CALL_CATCH_EXCEPTION();
34928   }
34929
34930 }
34931
34932
34933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
34934   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
34935   Dali::WheelEvent *arg2 = 0 ;
34936
34937   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
34938   arg2 = (Dali::WheelEvent *)jarg2;
34939   if (!arg2) {
34940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34941     return ;
34942   }
34943   {
34944     try {
34945       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
34946     } CALL_CATCH_EXCEPTION();
34947   }
34948
34949 }
34950
34951
34952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
34953   void * jresult ;
34954   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
34955
34956   {
34957     try {
34958       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
34959     } CALL_CATCH_EXCEPTION(0);
34960   }
34961
34962   jresult = (void *)result;
34963   return jresult;
34964 }
34965
34966
34967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
34968   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
34969
34970   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
34971   {
34972     try {
34973       delete arg1;
34974     } CALL_CATCH_EXCEPTION();
34975   }
34976
34977 }
34978
34979
34980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
34981   void * jresult ;
34982   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
34983
34984   {
34985     try {
34986       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
34987     } CALL_CATCH_EXCEPTION(0);
34988   }
34989
34990   jresult = (void *)result;
34991   return jresult;
34992 }
34993
34994
34995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
34996   void * jresult ;
34997   Dali::Radian arg1 ;
34998   Dali::Radian arg2 ;
34999   Dali::Radian *argp1 ;
35000   Dali::Radian *argp2 ;
35001   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
35002
35003   argp1 = (Dali::Radian *)jarg1;
35004   if (!argp1) {
35005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35006     return 0;
35007   }
35008   arg1 = *argp1;
35009   argp2 = (Dali::Radian *)jarg2;
35010   if (!argp2) {
35011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35012     return 0;
35013   }
35014   arg2 = *argp2;
35015   {
35016     try {
35017       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
35018     } CALL_CATCH_EXCEPTION(0);
35019   }
35020
35021   jresult = (void *)result;
35022   return jresult;
35023 }
35024
35025
35026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
35027   void * jresult ;
35028   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
35029   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
35030
35031   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
35032   if (!arg1) {
35033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
35034     return 0;
35035   }
35036   {
35037     try {
35038       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
35039     } CALL_CATCH_EXCEPTION(0);
35040   }
35041
35042   jresult = (void *)result;
35043   return jresult;
35044 }
35045
35046
35047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
35048   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
35049   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
35050
35051   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
35052   arg2 = (Dali::Radian *)jarg2;
35053   if (arg1) (arg1)->first = *arg2;
35054 }
35055
35056
35057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
35058   void * jresult ;
35059   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
35060   Dali::Radian *result = 0 ;
35061
35062   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
35063   result = (Dali::Radian *)& ((arg1)->first);
35064   jresult = (void *)result;
35065   return jresult;
35066 }
35067
35068
35069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
35070   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
35071   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
35072
35073   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
35074   arg2 = (Dali::Radian *)jarg2;
35075   if (arg1) (arg1)->second = *arg2;
35076 }
35077
35078
35079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
35080   void * jresult ;
35081   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
35082   Dali::Radian *result = 0 ;
35083
35084   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
35085   result = (Dali::Radian *)& ((arg1)->second);
35086   jresult = (void *)result;
35087   return jresult;
35088 }
35089
35090
35091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
35092   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
35093
35094   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
35095   {
35096     try {
35097       delete arg1;
35098     } CALL_CATCH_EXCEPTION();
35099   }
35100
35101 }
35102
35103
35104 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
35105   bool jresult ;
35106   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
35107   bool result;
35108
35109   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
35110   {
35111     try {
35112       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);
35113     } CALL_CATCH_EXCEPTION(0);
35114   }
35115
35116   jresult = result;
35117   return jresult;
35118 }
35119
35120
35121 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
35122   unsigned long jresult ;
35123   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
35124   std::size_t result;
35125
35126   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
35127   {
35128     try {
35129       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);
35130     } CALL_CATCH_EXCEPTION(0);
35131   }
35132
35133   jresult = (unsigned long)result;
35134   return jresult;
35135 }
35136
35137
35138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
35139   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
35140   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
35141
35142   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
35143   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
35144   {
35145     try {
35146       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
35147     } CALL_CATCH_EXCEPTION();
35148   }
35149
35150 }
35151
35152
35153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
35154   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
35155   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
35156
35157   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
35158   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
35159   {
35160     try {
35161       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
35162     } CALL_CATCH_EXCEPTION();
35163   }
35164
35165 }
35166
35167
35168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
35169   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
35170   Dali::Actor arg2 ;
35171   Dali::PanGesture *arg3 = 0 ;
35172   Dali::Actor *argp2 ;
35173
35174   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
35175   argp2 = (Dali::Actor *)jarg2;
35176   if (!argp2) {
35177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
35178     return ;
35179   }
35180   arg2 = *argp2;
35181   arg3 = (Dali::PanGesture *)jarg3;
35182   if (!arg3) {
35183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35184     return ;
35185   }
35186   {
35187     try {
35188       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
35189     } CALL_CATCH_EXCEPTION();
35190   }
35191
35192 }
35193
35194
35195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
35196   void * jresult ;
35197   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
35198
35199   {
35200     try {
35201       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
35202     } CALL_CATCH_EXCEPTION(0);
35203   }
35204
35205   jresult = (void *)result;
35206   return jresult;
35207 }
35208
35209
35210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
35211   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
35212
35213   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
35214   {
35215     try {
35216       delete arg1;
35217     } CALL_CATCH_EXCEPTION();
35218   }
35219
35220 }
35221
35222
35223 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
35224   bool jresult ;
35225   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
35226   bool result;
35227
35228   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
35229   {
35230     try {
35231       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);
35232     } CALL_CATCH_EXCEPTION(0);
35233   }
35234
35235   jresult = result;
35236   return jresult;
35237 }
35238
35239
35240 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
35241   unsigned long jresult ;
35242   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
35243   std::size_t result;
35244
35245   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
35246   {
35247     try {
35248       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);
35249     } CALL_CATCH_EXCEPTION(0);
35250   }
35251
35252   jresult = (unsigned long)result;
35253   return jresult;
35254 }
35255
35256
35257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
35258   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
35259   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
35260
35261   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
35262   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
35263   {
35264     try {
35265       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
35266     } CALL_CATCH_EXCEPTION();
35267   }
35268
35269 }
35270
35271
35272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
35273   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
35274   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
35275
35276   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
35277   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
35278   {
35279     try {
35280       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
35281     } CALL_CATCH_EXCEPTION();
35282   }
35283
35284 }
35285
35286
35287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
35288   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
35289   Dali::Actor arg2 ;
35290   Dali::PinchGesture *arg3 = 0 ;
35291   Dali::Actor *argp2 ;
35292
35293   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
35294   argp2 = (Dali::Actor *)jarg2;
35295   if (!argp2) {
35296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
35297     return ;
35298   }
35299   arg2 = *argp2;
35300   arg3 = (Dali::PinchGesture *)jarg3;
35301   if (!arg3) {
35302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
35303     return ;
35304   }
35305   {
35306     try {
35307       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
35308     } CALL_CATCH_EXCEPTION();
35309   }
35310
35311 }
35312
35313
35314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
35315   void * jresult ;
35316   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
35317
35318   {
35319     try {
35320       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
35321     } CALL_CATCH_EXCEPTION(0);
35322   }
35323
35324   jresult = (void *)result;
35325   return jresult;
35326 }
35327
35328
35329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
35330   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
35331
35332   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
35333   {
35334     try {
35335       delete arg1;
35336     } CALL_CATCH_EXCEPTION();
35337   }
35338
35339 }
35340
35341
35342 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
35343   bool jresult ;
35344   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
35345   bool result;
35346
35347   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
35348   {
35349     try {
35350       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);
35351     } CALL_CATCH_EXCEPTION(0);
35352   }
35353
35354   jresult = result;
35355   return jresult;
35356 }
35357
35358
35359 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
35360   unsigned long jresult ;
35361   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
35362   std::size_t result;
35363
35364   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
35365   {
35366     try {
35367       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);
35368     } CALL_CATCH_EXCEPTION(0);
35369   }
35370
35371   jresult = (unsigned long)result;
35372   return jresult;
35373 }
35374
35375
35376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
35377   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
35378   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
35379
35380   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
35381   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
35382   {
35383     try {
35384       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
35385     } CALL_CATCH_EXCEPTION();
35386   }
35387
35388 }
35389
35390
35391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
35392   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
35393   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
35394
35395   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
35396   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
35397   {
35398     try {
35399       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
35400     } CALL_CATCH_EXCEPTION();
35401   }
35402
35403 }
35404
35405
35406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
35407   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
35408   Dali::Actor arg2 ;
35409   Dali::TapGesture *arg3 = 0 ;
35410   Dali::Actor *argp2 ;
35411
35412   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
35413   argp2 = (Dali::Actor *)jarg2;
35414   if (!argp2) {
35415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
35416     return ;
35417   }
35418   arg2 = *argp2;
35419   arg3 = (Dali::TapGesture *)jarg3;
35420   if (!arg3) {
35421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
35422     return ;
35423   }
35424   {
35425     try {
35426       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
35427     } CALL_CATCH_EXCEPTION();
35428   }
35429
35430 }
35431
35432
35433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
35434   void * jresult ;
35435   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
35436
35437   {
35438     try {
35439       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
35440     } CALL_CATCH_EXCEPTION(0);
35441   }
35442
35443   jresult = (void *)result;
35444   return jresult;
35445 }
35446
35447
35448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
35449   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
35450
35451   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
35452   {
35453     try {
35454       delete arg1;
35455     } CALL_CATCH_EXCEPTION();
35456   }
35457
35458 }
35459
35460
35461 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
35462   bool jresult ;
35463   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
35464   bool result = false;
35465
35466   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
35467   {
35468     try {
35469       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);
35470     } CALL_CATCH_EXCEPTION(0);
35471   }
35472   jresult = result;
35473   return jresult;
35474 }
35475
35476 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
35477   unsigned long jresult ;
35478   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
35479   std::size_t result = 0;
35480
35481   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
35482   {
35483     try {
35484       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);
35485     }CALL_CATCH_EXCEPTION(0);
35486   }
35487   jresult = (unsigned long)result;
35488   return jresult;
35489 }
35490
35491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
35492   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
35493   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
35494
35495   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
35496   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
35497   {
35498     try {
35499       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
35500     } CALL_CATCH_EXCEPTION();
35501   }
35502 }
35503
35504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
35505   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
35506   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
35507
35508   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
35509   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
35510   {
35511     try {
35512       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
35513     } CALL_CATCH_EXCEPTION();
35514   }
35515 }
35516
35517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
35518   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
35519   Dali::Actor arg2 ;
35520   //bool arg3 ;
35521   Dali::LayoutDirection::Type arg4 ;
35522   Dali::Actor *argp2 ;
35523
35524   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
35525   argp2 = (Dali::Actor *)jarg2;
35526   if (!argp2) {
35527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
35528     return ;
35529   }
35530   arg2 = *argp2;
35531   //arg3 = jarg3 ? true : false;
35532   arg4 = (Dali::LayoutDirection::Type)jarg4;
35533   {
35534     try {
35535       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
35536     } CALL_CATCH_EXCEPTION();
35537   }
35538 }
35539
35540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
35541   void * jresult ;
35542   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
35543
35544   {
35545     try {
35546       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
35547     } CALL_CATCH_EXCEPTION(0);
35548   }
35549   jresult = (void *)result;
35550   return jresult;
35551 }
35552
35553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
35554   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
35555
35556   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
35557   {
35558     try {
35559       delete arg1;
35560     } CALL_CATCH_EXCEPTION();
35561   }
35562 }
35563
35564
35565 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
35566   bool jresult ;
35567   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
35568   bool result = false;
35569
35570   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
35571   {
35572     try {
35573       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);
35574     } CALL_CATCH_EXCEPTION(0);
35575   }
35576   jresult = result;
35577   return jresult;
35578 }
35579
35580
35581 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
35582   unsigned long jresult ;
35583   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
35584   std::size_t result;
35585
35586   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
35587   {
35588     try {
35589       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);
35590     } CALL_CATCH_EXCEPTION(0);
35591   }
35592
35593   jresult = (unsigned long)result;
35594   return jresult;
35595 }
35596
35597
35598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
35599   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
35600   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
35601
35602   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
35603   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
35604   {
35605     try {
35606       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
35607     } CALL_CATCH_EXCEPTION();
35608   }
35609
35610 }
35611
35612
35613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
35614   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
35615   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
35616
35617   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
35618   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
35619   {
35620     try {
35621       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
35622     } CALL_CATCH_EXCEPTION();
35623   }
35624
35625 }
35626
35627
35628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, bool jarg3, int jarg4) {
35629   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
35630   Dali::Actor arg2 ;
35631   bool arg3 ;
35632   Dali::DevelActor::VisibilityChange::Type arg4 ;
35633   Dali::Actor *argp2 ;
35634
35635   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
35636   argp2 = (Dali::Actor *)jarg2;
35637   if (!argp2) {
35638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
35639     return ;
35640   }
35641   arg2 = *argp2;
35642   arg3 = jarg3 ? true : false;
35643   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
35644   {
35645     try {
35646       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
35647     } CALL_CATCH_EXCEPTION();
35648   }
35649
35650 }
35651
35652
35653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
35654   void * jresult ;
35655   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
35656
35657   {
35658     try {
35659       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
35660     } CALL_CATCH_EXCEPTION(0);
35661   }
35662
35663   jresult = (void *)result;
35664   return jresult;
35665 }
35666
35667
35668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
35669   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
35670
35671   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
35672   {
35673     try {
35674       delete arg1;
35675     } CALL_CATCH_EXCEPTION();
35676   }
35677
35678 }
35679
35680
35681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
35682   void * jresult ;
35683   Dali::Timer *result = 0 ;
35684
35685   {
35686     try {
35687       result = (Dali::Timer *)new Dali::Timer();
35688     } CALL_CATCH_EXCEPTION(0);
35689   }
35690
35691   jresult = (void *)result;
35692   return jresult;
35693 }
35694
35695
35696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
35697   void * jresult ;
35698   unsigned int arg1 ;
35699   Dali::Timer result;
35700
35701   arg1 = (unsigned int)jarg1;
35702   {
35703     try {
35704       result = Dali::Timer::New(arg1);
35705     } CALL_CATCH_EXCEPTION(0);
35706   }
35707
35708   jresult = new Dali::Timer((const Dali::Timer &)result);
35709   return jresult;
35710 }
35711
35712
35713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
35714   void * jresult ;
35715   Dali::Timer *arg1 = 0 ;
35716   Dali::Timer *result = 0 ;
35717
35718   arg1 = (Dali::Timer *)jarg1;
35719   if (!arg1) {
35720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
35721     return 0;
35722   }
35723   {
35724     try {
35725       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
35726     } CALL_CATCH_EXCEPTION(0);
35727   }
35728
35729   jresult = (void *)result;
35730   return jresult;
35731 }
35732
35733
35734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
35735   void * jresult ;
35736   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
35737   Dali::Timer *arg2 = 0 ;
35738   Dali::Timer *result = 0 ;
35739
35740   arg1 = (Dali::Timer *)jarg1;
35741   arg2 = (Dali::Timer *)jarg2;
35742   if (!arg2) {
35743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
35744     return 0;
35745   }
35746   {
35747     try {
35748       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
35749     } CALL_CATCH_EXCEPTION(0);
35750   }
35751
35752   jresult = (void *)result;
35753   return jresult;
35754 }
35755
35756
35757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
35758   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
35759
35760   arg1 = (Dali::Timer *)jarg1;
35761   {
35762     try {
35763       delete arg1;
35764     } CALL_CATCH_EXCEPTION();
35765   }
35766
35767 }
35768
35769
35770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
35771   void * jresult ;
35772   Dali::BaseHandle arg1 ;
35773   Dali::BaseHandle *argp1 ;
35774   Dali::Timer result;
35775
35776   argp1 = (Dali::BaseHandle *)jarg1;
35777   if (!argp1) {
35778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35779     return 0;
35780   }
35781   arg1 = *argp1;
35782   {
35783     try {
35784       result = Dali::Timer::DownCast(arg1);
35785     } CALL_CATCH_EXCEPTION(0);
35786   }
35787
35788   jresult = new Dali::Timer((const Dali::Timer &)result);
35789   return jresult;
35790 }
35791
35792
35793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
35794   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
35795
35796   arg1 = (Dali::Timer *)jarg1;
35797   {
35798     try {
35799       (arg1)->Start();
35800     } CALL_CATCH_EXCEPTION();
35801   }
35802
35803 }
35804
35805
35806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
35807   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
35808
35809   arg1 = (Dali::Timer *)jarg1;
35810   {
35811     try {
35812       (arg1)->Stop();
35813     } CALL_CATCH_EXCEPTION();
35814   }
35815
35816 }
35817
35818
35819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
35820   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
35821   unsigned int arg2 ;
35822
35823   arg1 = (Dali::Timer *)jarg1;
35824   arg2 = (unsigned int)jarg2;
35825   {
35826     try {
35827       (arg1)->SetInterval(arg2);
35828     } CALL_CATCH_EXCEPTION();
35829   }
35830
35831 }
35832
35833
35834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
35835   unsigned int jresult ;
35836   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
35837   unsigned int result;
35838
35839   arg1 = (Dali::Timer *)jarg1;
35840   {
35841     try {
35842       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
35843     } CALL_CATCH_EXCEPTION(0);
35844   }
35845
35846   jresult = result;
35847   return jresult;
35848 }
35849
35850
35851 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
35852   bool jresult ;
35853   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
35854   bool result;
35855
35856   arg1 = (Dali::Timer *)jarg1;
35857   {
35858     try {
35859       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
35860     } CALL_CATCH_EXCEPTION(0);
35861   }
35862
35863   jresult = result;
35864   return jresult;
35865 }
35866
35867
35868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
35869   void * jresult ;
35870   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
35871   Dali::Timer::TimerSignalType *result = 0 ;
35872
35873   arg1 = (Dali::Timer *)jarg1;
35874   {
35875     try {
35876       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
35877     } CALL_CATCH_EXCEPTION(0);
35878   }
35879
35880   jresult = (void *)result;
35881   return jresult;
35882 }
35883
35884
35885 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
35886   bool jresult ;
35887   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
35888   bool result;
35889
35890   arg1 = (Dali::Signal< bool () > *)jarg1;
35891   {
35892     try {
35893       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
35894     } CALL_CATCH_EXCEPTION(0);
35895   }
35896
35897   jresult = result;
35898   return jresult;
35899 }
35900
35901
35902 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
35903   unsigned long jresult ;
35904   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
35905   std::size_t result;
35906
35907   arg1 = (Dali::Signal< bool () > *)jarg1;
35908   {
35909     try {
35910       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
35911     } CALL_CATCH_EXCEPTION(0);
35912   }
35913
35914   jresult = (unsigned long)result;
35915   return jresult;
35916 }
35917
35918
35919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
35920   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
35921   bool (*arg2)() = (bool (*)()) 0 ;
35922
35923   arg1 = (Dali::Signal< bool () > *)jarg1;
35924   arg2 = (bool (*)())jarg2;
35925   {
35926     try {
35927       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
35928     } CALL_CATCH_EXCEPTION();
35929   }
35930
35931 }
35932
35933
35934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
35935   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
35936   bool (*arg2)() = (bool (*)()) 0 ;
35937
35938   arg1 = (Dali::Signal< bool () > *)jarg1;
35939   arg2 = (bool (*)())jarg2;
35940   {
35941     try {
35942       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
35943     } CALL_CATCH_EXCEPTION();
35944   }
35945
35946 }
35947
35948
35949 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
35950   bool jresult ;
35951   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
35952   bool result;
35953
35954   arg1 = (Dali::Signal< bool () > *)jarg1;
35955   {
35956     try {
35957       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
35958     } CALL_CATCH_EXCEPTION(0);
35959   }
35960
35961   jresult = result;
35962   return jresult;
35963 }
35964
35965
35966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
35967   void * jresult ;
35968   Dali::Signal< bool () > *result = 0 ;
35969
35970   {
35971     try {
35972       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
35973     } CALL_CATCH_EXCEPTION(0);
35974   }
35975
35976   jresult = (void *)result;
35977   return jresult;
35978 }
35979
35980
35981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
35982   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
35983
35984   arg1 = (Dali::Signal< bool () > *)jarg1;
35985   {
35986     try {
35987       delete arg1;
35988     } CALL_CATCH_EXCEPTION();
35989   }
35990
35991 }
35992
35993
35994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
35995   int jresult ;
35996   int result;
35997
35998   {
35999     try {
36000       result = (int)Dali::Toolkit::Visual::Property::TYPE;
36001     } CALL_CATCH_EXCEPTION(0);
36002   }
36003
36004   jresult = (int)result;
36005   return jresult;
36006 }
36007
36008
36009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
36010   int jresult ;
36011   int result;
36012
36013   {
36014     try {
36015       result = (int)Dali::Toolkit::Visual::Property::SHADER;
36016     } CALL_CATCH_EXCEPTION(0);
36017   }
36018
36019   jresult = (int)result;
36020   return jresult;
36021 }
36022
36023
36024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
36025   int jresult ;
36026   int result;
36027
36028   {
36029     try {
36030       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
36031     } CALL_CATCH_EXCEPTION(0);
36032   }
36033
36034   jresult = (int)result;
36035   return jresult;
36036 }
36037
36038
36039 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
36040   int jresult ;
36041   int result;
36042
36043   {
36044     try {
36045       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
36046     } CALL_CATCH_EXCEPTION(0);
36047   }
36048
36049   jresult = (int)result;
36050   return jresult;
36051 }
36052
36053
36054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
36055   int jresult ;
36056   int result;
36057
36058   {
36059     try {
36060       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
36061     } CALL_CATCH_EXCEPTION(0);
36062   }
36063
36064   jresult = (int)result;
36065   return jresult;
36066 }
36067
36068
36069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
36070   int jresult ;
36071   int result;
36072
36073   {
36074     try {
36075       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
36076     } CALL_CATCH_EXCEPTION(0);
36077   }
36078
36079   jresult = (int)result;
36080   return jresult;
36081 }
36082
36083
36084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
36085   int jresult ;
36086   int result;
36087
36088   {
36089     try {
36090       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
36091     } CALL_CATCH_EXCEPTION(0);
36092   }
36093
36094   jresult = (int)result;
36095   return jresult;
36096 }
36097
36098
36099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
36100   int jresult ;
36101   int result;
36102
36103   {
36104     try {
36105       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
36106     } CALL_CATCH_EXCEPTION(0);
36107   }
36108
36109   jresult = (int)result;
36110   return jresult;
36111 }
36112
36113
36114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
36115   int jresult ;
36116   int result;
36117
36118   {
36119     try {
36120       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
36121     } CALL_CATCH_EXCEPTION(0);
36122   }
36123
36124   jresult = (int)result;
36125   return jresult;
36126 }
36127
36128
36129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
36130   int jresult ;
36131   int result;
36132
36133   {
36134     try {
36135       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
36136     } CALL_CATCH_EXCEPTION(0);
36137   }
36138
36139   jresult = (int)result;
36140   return jresult;
36141 }
36142
36143
36144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
36145   int jresult ;
36146   int result;
36147
36148   {
36149     try {
36150       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
36151     } CALL_CATCH_EXCEPTION(0);
36152   }
36153
36154   jresult = (int)result;
36155   return jresult;
36156 }
36157
36158
36159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
36160   int jresult ;
36161   int result;
36162
36163   {
36164     try {
36165       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
36166     } CALL_CATCH_EXCEPTION(0);
36167   }
36168
36169   jresult = (int)result;
36170   return jresult;
36171 }
36172
36173
36174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
36175   int jresult ;
36176   int result;
36177
36178   {
36179     try {
36180       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
36181     } CALL_CATCH_EXCEPTION(0);
36182   }
36183
36184   jresult = (int)result;
36185   return jresult;
36186 }
36187
36188
36189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
36190   int jresult ;
36191   int result;
36192
36193   {
36194     try {
36195       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
36196     } CALL_CATCH_EXCEPTION(0);
36197   }
36198
36199   jresult = (int)result;
36200   return jresult;
36201 }
36202
36203
36204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
36205   int jresult ;
36206   int result;
36207
36208   {
36209     try {
36210       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
36211     } CALL_CATCH_EXCEPTION(0);
36212   }
36213
36214   jresult = (int)result;
36215   return jresult;
36216 }
36217
36218
36219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
36220   int jresult ;
36221   int result;
36222
36223   {
36224     try {
36225       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
36226     } CALL_CATCH_EXCEPTION(0);
36227   }
36228
36229   jresult = (int)result;
36230   return jresult;
36231 }
36232
36233
36234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
36235   int jresult ;
36236   int result;
36237
36238   {
36239     try {
36240       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
36241     } CALL_CATCH_EXCEPTION(0);
36242   }
36243
36244   jresult = (int)result;
36245   return jresult;
36246 }
36247
36248
36249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
36250   int jresult ;
36251   int result;
36252
36253   {
36254     try {
36255       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
36256     } CALL_CATCH_EXCEPTION(0);
36257   }
36258
36259   jresult = (int)result;
36260   return jresult;
36261 }
36262
36263
36264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
36265   int jresult ;
36266   int result;
36267
36268   {
36269     try {
36270       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
36271     } CALL_CATCH_EXCEPTION(0);
36272   }
36273
36274   jresult = (int)result;
36275   return jresult;
36276 }
36277
36278
36279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
36280   int jresult ;
36281   int result;
36282
36283   {
36284     try {
36285       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
36286     } CALL_CATCH_EXCEPTION(0);
36287   }
36288
36289   jresult = (int)result;
36290   return jresult;
36291 }
36292
36293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
36294   int jresult ;
36295   int result;
36296
36297   {
36298     try {
36299       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
36300     } CALL_CATCH_EXCEPTION(0);
36301   }
36302
36303   jresult = (int)result;
36304   return jresult;
36305 }
36306
36307
36308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
36309   int jresult ;
36310   int result;
36311   {
36312     try
36313     {
36314       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
36315     } CALL_CATCH_EXCEPTION(0);
36316   }
36317
36318   jresult = (int)result;
36319   return jresult;
36320 }
36321
36322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
36323   int jresult ;
36324   int result;
36325   {
36326     try
36327     {
36328       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
36329     } CALL_CATCH_EXCEPTION(0);
36330   }
36331
36332   jresult = (int)result;
36333   return jresult;
36334 }
36335
36336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
36337   int jresult ;
36338   int result;
36339   {
36340     try
36341     {
36342       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
36343     } CALL_CATCH_EXCEPTION(0);
36344   }
36345
36346   jresult = (int)result;
36347   return jresult;
36348 }
36349
36350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
36351   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
36352 }
36353
36354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
36355   int jresult ;
36356   int result;
36357   {
36358     try
36359     {
36360       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
36361     } CALL_CATCH_EXCEPTION(0);
36362   }
36363
36364   jresult = (int)result;
36365   return jresult;
36366 }
36367
36368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
36369   int jresult ;
36370   int result;
36371   {
36372     try
36373     {
36374       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
36375     } CALL_CATCH_EXCEPTION(0);
36376   }
36377
36378   jresult = (int)result;
36379   return jresult;
36380 }
36381
36382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
36383   int jresult ;
36384   int result;
36385
36386   {
36387     try {
36388       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
36389     } CALL_CATCH_EXCEPTION(0);
36390   }
36391
36392   jresult = (int)result;
36393   return jresult;
36394 }
36395
36396
36397 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
36398   int jresult ;
36399   int result;
36400
36401   {
36402     try {
36403       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
36404     } CALL_CATCH_EXCEPTION(0);
36405   }
36406
36407   jresult = (int)result;
36408   return jresult;
36409 }
36410
36411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
36412   int jresult ;
36413   int result;
36414   {
36415     try
36416     {
36417       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
36418     } CALL_CATCH_EXCEPTION(0);
36419   }
36420
36421   jresult = (int)result;
36422   return jresult;
36423 }
36424
36425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
36426   int jresult ;
36427   int result;
36428   {
36429     try
36430     {
36431       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
36432     } CALL_CATCH_EXCEPTION(0);
36433   }
36434
36435   jresult = (int)result;
36436   return jresult;
36437 }
36438
36439 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
36440   int jresult ;
36441   int result;
36442   {
36443     try
36444     {
36445       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
36446     } CALL_CATCH_EXCEPTION(0);
36447   }
36448
36449   jresult = (int)result;
36450   return jresult;
36451 }
36452
36453
36454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
36455   int jresult ;
36456   int result;
36457   {
36458     try
36459     {
36460       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
36461     } CALL_CATCH_EXCEPTION(0);
36462   }
36463
36464   jresult = (int)result;
36465   return jresult;
36466 }
36467
36468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
36469   int jresult ;
36470   int result;
36471   {
36472     try
36473     {
36474       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
36475     } CALL_CATCH_EXCEPTION(0);
36476   }
36477
36478   jresult = (int)result;
36479   return jresult;
36480 }
36481
36482
36483
36484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
36485   int jresult ;
36486   int result;
36487
36488   {
36489     try {
36490       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
36491     } CALL_CATCH_EXCEPTION(0);
36492   }
36493
36494   jresult = (int)result;
36495   return jresult;
36496 }
36497
36498
36499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
36500   int jresult ;
36501   int result;
36502
36503   {
36504     try {
36505       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
36506     } CALL_CATCH_EXCEPTION(0);
36507   }
36508
36509   jresult = (int)result;
36510   return jresult;
36511 }
36512
36513
36514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
36515   int jresult ;
36516   int result;
36517
36518   {
36519     try {
36520       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
36521     } CALL_CATCH_EXCEPTION(0);
36522   }
36523
36524   jresult = (int)result;
36525   return jresult;
36526 }
36527
36528
36529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
36530   int jresult ;
36531   int result;
36532
36533   {
36534     try {
36535       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
36536     } CALL_CATCH_EXCEPTION(0);
36537   }
36538
36539   jresult = (int)result;
36540   return jresult;
36541 }
36542
36543
36544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
36545   int jresult ;
36546   int result;
36547
36548   {
36549     try {
36550       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
36551     } CALL_CATCH_EXCEPTION(0);
36552   }
36553
36554   jresult = (int)result;
36555   return jresult;
36556 }
36557
36558
36559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
36560   int jresult ;
36561   int result;
36562
36563   {
36564     try {
36565       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
36566     } CALL_CATCH_EXCEPTION(0);
36567   }
36568
36569   jresult = (int)result;
36570   return jresult;
36571 }
36572
36573
36574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
36575   int jresult ;
36576   int result;
36577
36578   {
36579     try {
36580       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
36581     } CALL_CATCH_EXCEPTION(0);
36582   }
36583
36584   jresult = (int)result;
36585   return jresult;
36586 }
36587
36588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_USE_FIXED_CACHE_get() {
36589   int jresult ;
36590   int result;
36591
36592   {
36593     try {
36594       result = (int)Dali::Toolkit::DevelImageVisual::Property::USE_FIXED_CACHE;
36595     } CALL_CATCH_EXCEPTION(0);
36596   }
36597
36598   jresult = (int)result;
36599   return jresult;
36600 }
36601
36602 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
36603   int jresult ;
36604   int result;
36605
36606   {
36607     try {
36608       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
36609     } CALL_CATCH_EXCEPTION(0);
36610   }
36611
36612   jresult = (int)result;
36613   return jresult;
36614 }
36615
36616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
36617   int jresult ;
36618   int result;
36619
36620   {
36621     try {
36622       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
36623     } CALL_CATCH_EXCEPTION(0);
36624   }
36625
36626   jresult = (int)result;
36627   return jresult;
36628 }
36629
36630
36631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
36632   int jresult ;
36633   int result;
36634
36635   {
36636     try {
36637       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
36638     } CALL_CATCH_EXCEPTION(0);
36639   }
36640
36641   jresult = (int)result;
36642   return jresult;
36643 }
36644
36645
36646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
36647   int jresult ;
36648   int result;
36649
36650   {
36651     try {
36652       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
36653     } CALL_CATCH_EXCEPTION(0);
36654   }
36655
36656   jresult = (int)result;
36657   return jresult;
36658 }
36659
36660
36661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
36662   int jresult ;
36663   int result;
36664
36665   {
36666     try {
36667       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
36668     } CALL_CATCH_EXCEPTION(0);
36669   }
36670
36671   jresult = (int)result;
36672   return jresult;
36673 }
36674
36675
36676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
36677   int jresult ;
36678   int result;
36679
36680   {
36681     try {
36682       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
36683     } CALL_CATCH_EXCEPTION(0);
36684   }
36685
36686   jresult = (int)result;
36687   return jresult;
36688 }
36689
36690
36691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
36692   int jresult ;
36693   int result;
36694
36695   {
36696     try {
36697       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
36698     } CALL_CATCH_EXCEPTION(0);
36699   }
36700
36701   jresult = (int)result;
36702   return jresult;
36703 }
36704
36705
36706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
36707   int jresult ;
36708   int result;
36709
36710   {
36711     try {
36712       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
36713     } CALL_CATCH_EXCEPTION(0);
36714   }
36715
36716   jresult = (int)result;
36717   return jresult;
36718 }
36719
36720
36721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
36722   int jresult ;
36723   int result;
36724
36725   {
36726     try {
36727       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
36728     } CALL_CATCH_EXCEPTION(0);
36729   }
36730
36731   jresult = (int)result;
36732   return jresult;
36733 }
36734
36735
36736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
36737   int jresult ;
36738   int result;
36739
36740   {
36741     try {
36742       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
36743     } CALL_CATCH_EXCEPTION(0);
36744   }
36745
36746   jresult = (int)result;
36747   return jresult;
36748 }
36749
36750
36751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
36752   int jresult ;
36753   int result;
36754
36755   {
36756     try {
36757       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
36758     } CALL_CATCH_EXCEPTION(0);
36759   }
36760
36761   jresult = (int)result;
36762   return jresult;
36763 }
36764
36765
36766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
36767   int jresult ;
36768   int result;
36769
36770   {
36771     try {
36772       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
36773     } CALL_CATCH_EXCEPTION(0);
36774   }
36775
36776   jresult = (int)result;
36777   return jresult;
36778 }
36779
36780
36781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
36782   int jresult ;
36783   int result;
36784
36785   {
36786     try {
36787       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
36788     } CALL_CATCH_EXCEPTION(0);
36789   }
36790
36791   jresult = (int)result;
36792   return jresult;
36793 }
36794
36795
36796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
36797   int jresult ;
36798   int result;
36799
36800   {
36801     try {
36802       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
36803     } CALL_CATCH_EXCEPTION(0);
36804   }
36805
36806   jresult = (int)result;
36807   return jresult;
36808 }
36809
36810
36811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
36812   int jresult ;
36813   int result;
36814
36815   {
36816     try {
36817       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
36818     } CALL_CATCH_EXCEPTION(0);
36819   }
36820
36821   jresult = (int)result;
36822   return jresult;
36823 }
36824
36825
36826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
36827   int jresult ;
36828   int result;
36829
36830   {
36831     try {
36832       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
36833     } CALL_CATCH_EXCEPTION(0);
36834   }
36835
36836   jresult = (int)result;
36837   return jresult;
36838 }
36839
36840
36841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
36842   int jresult ;
36843   int result;
36844
36845   {
36846     try {
36847       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
36848     } CALL_CATCH_EXCEPTION(0);
36849   }
36850
36851   jresult = (int)result;
36852   return jresult;
36853 }
36854
36855
36856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
36857   int jresult ;
36858   int result;
36859
36860   {
36861     try {
36862       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
36863     } CALL_CATCH_EXCEPTION(0);
36864   }
36865
36866   jresult = (int)result;
36867   return jresult;
36868 }
36869
36870
36871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
36872   int jresult ;
36873   int result;
36874
36875   {
36876     try {
36877       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
36878     } CALL_CATCH_EXCEPTION(0);
36879   }
36880
36881   jresult = (int)result;
36882   return jresult;
36883 }
36884
36885
36886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
36887   int jresult ;
36888   int result;
36889
36890   {
36891     try {
36892       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
36893     } CALL_CATCH_EXCEPTION(0);
36894   }
36895
36896   jresult = (int)result;
36897   return jresult;
36898 }
36899
36900
36901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
36902   int jresult ;
36903   int result;
36904
36905   {
36906     try {
36907       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
36908     } CALL_CATCH_EXCEPTION(0);
36909   }
36910
36911   jresult = (int)result;
36912   return jresult;
36913 }
36914
36915
36916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
36917   int jresult ;
36918   int result;
36919
36920   {
36921     try {
36922       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
36923     } CALL_CATCH_EXCEPTION(0);
36924   }
36925
36926   jresult = (int)result;
36927   return jresult;
36928 }
36929
36930
36931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
36932   int jresult ;
36933   int result;
36934
36935   {
36936     try {
36937       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
36938     } CALL_CATCH_EXCEPTION(0);
36939   }
36940
36941   jresult = (int)result;
36942   return jresult;
36943 }
36944
36945
36946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
36947   int jresult ;
36948   int result;
36949
36950   {
36951     try {
36952       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
36953     } CALL_CATCH_EXCEPTION(0);
36954   }
36955
36956   jresult = (int)result;
36957   return jresult;
36958 }
36959
36960
36961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
36962   int jresult ;
36963   int result;
36964
36965   {
36966     try {
36967       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
36968     } CALL_CATCH_EXCEPTION(0);
36969   }
36970
36971   jresult = (int)result;
36972   return jresult;
36973 }
36974
36975
36976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
36977   int jresult ;
36978   int result;
36979
36980   {
36981     try {
36982       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
36983     } CALL_CATCH_EXCEPTION(0);
36984   }
36985
36986   jresult = (int)result;
36987   return jresult;
36988 }
36989
36990
36991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
36992   int jresult ;
36993   int result;
36994
36995   {
36996     try {
36997       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
36998     } CALL_CATCH_EXCEPTION(0);
36999   }
37000
37001   jresult = (int)result;
37002   return jresult;
37003 }
37004
37005
37006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
37007   int jresult ;
37008   int result;
37009
37010   {
37011     try {
37012       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
37013     } CALL_CATCH_EXCEPTION(0);
37014   }
37015
37016   jresult = (int)result;
37017   return jresult;
37018 }
37019
37020
37021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
37022   int jresult ;
37023   int result;
37024
37025   {
37026     try {
37027       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
37028     } CALL_CATCH_EXCEPTION(0);
37029   }
37030
37031   jresult = (int)result;
37032   return jresult;
37033 }
37034
37035
37036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
37037   void * jresult ;
37038   Dali::Toolkit::Builder *result = 0 ;
37039
37040   {
37041     try {
37042       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
37043     } CALL_CATCH_EXCEPTION(0);
37044   }
37045
37046   jresult = (void *)result;
37047   return jresult;
37048 }
37049
37050
37051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
37052   void * jresult ;
37053   Dali::Toolkit::Builder result;
37054
37055   {
37056     try {
37057       result = Dali::Toolkit::Builder::New();
37058     } CALL_CATCH_EXCEPTION(0);
37059   }
37060
37061   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
37062   return jresult;
37063 }
37064
37065
37066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
37067   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37068
37069   arg1 = (Dali::Toolkit::Builder *)jarg1;
37070   {
37071     try {
37072       delete arg1;
37073     } CALL_CATCH_EXCEPTION();
37074   }
37075
37076 }
37077
37078
37079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
37080   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37081   std::string *arg2 = 0 ;
37082   Dali::Toolkit::Builder::UIFormat arg3 ;
37083
37084   arg1 = (Dali::Toolkit::Builder *)jarg1;
37085   if (!jarg2) {
37086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37087     return ;
37088   }
37089   std::string arg2_str(jarg2);
37090   arg2 = &arg2_str;
37091   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
37092   {
37093     try {
37094       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
37095     } CALL_CATCH_EXCEPTION();
37096   }
37097
37098
37099   //argout typemap for const std::string&
37100
37101 }
37102
37103
37104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
37105   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37106   std::string *arg2 = 0 ;
37107
37108   arg1 = (Dali::Toolkit::Builder *)jarg1;
37109   if (!jarg2) {
37110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37111     return ;
37112   }
37113   std::string arg2_str(jarg2);
37114   arg2 = &arg2_str;
37115   {
37116     try {
37117       (arg1)->LoadFromString((std::string const &)*arg2);
37118     } CALL_CATCH_EXCEPTION();
37119   }
37120
37121
37122   //argout typemap for const std::string&
37123
37124 }
37125
37126
37127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
37128   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37129   Dali::Property::Map *arg2 = 0 ;
37130
37131   arg1 = (Dali::Toolkit::Builder *)jarg1;
37132   arg2 = (Dali::Property::Map *)jarg2;
37133   if (!arg2) {
37134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
37135     return ;
37136   }
37137   {
37138     try {
37139       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
37140     } CALL_CATCH_EXCEPTION();
37141   }
37142
37143 }
37144
37145
37146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
37147   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37148   std::string *arg2 = 0 ;
37149   Dali::Property::Value *arg3 = 0 ;
37150
37151   arg1 = (Dali::Toolkit::Builder *)jarg1;
37152   if (!jarg2) {
37153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37154     return ;
37155   }
37156   std::string arg2_str(jarg2);
37157   arg2 = &arg2_str;
37158   arg3 = (Dali::Property::Value *)jarg3;
37159   if (!arg3) {
37160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
37161     return ;
37162   }
37163   {
37164     try {
37165       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
37166     } CALL_CATCH_EXCEPTION();
37167   }
37168
37169
37170   //argout typemap for const std::string&
37171
37172 }
37173
37174
37175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
37176   void * jresult ;
37177   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37178   Dali::Property::Map *result = 0 ;
37179
37180   arg1 = (Dali::Toolkit::Builder *)jarg1;
37181   {
37182     try {
37183       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
37184     } CALL_CATCH_EXCEPTION(0);
37185   }
37186
37187   jresult = (void *)result;
37188   return jresult;
37189 }
37190
37191
37192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
37193   void * jresult ;
37194   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37195   std::string *arg2 = 0 ;
37196   Dali::Property::Value *result = 0 ;
37197
37198   arg1 = (Dali::Toolkit::Builder *)jarg1;
37199   if (!jarg2) {
37200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37201     return 0;
37202   }
37203   std::string arg2_str(jarg2);
37204   arg2 = &arg2_str;
37205   {
37206     try {
37207       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
37208     } CALL_CATCH_EXCEPTION(0);
37209   }
37210
37211   jresult = (void *)result;
37212
37213   //argout typemap for const std::string&
37214
37215   return jresult;
37216 }
37217
37218
37219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
37220   void * jresult ;
37221   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37222   std::string *arg2 = 0 ;
37223   Dali::Animation result;
37224
37225   arg1 = (Dali::Toolkit::Builder *)jarg1;
37226   if (!jarg2) {
37227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37228     return 0;
37229   }
37230   std::string arg2_str(jarg2);
37231   arg2 = &arg2_str;
37232   {
37233     try {
37234       result = (arg1)->CreateAnimation((std::string const &)*arg2);
37235     } CALL_CATCH_EXCEPTION(0);
37236   }
37237
37238   jresult = new Dali::Animation((const Dali::Animation &)result);
37239
37240   //argout typemap for const std::string&
37241
37242   return jresult;
37243 }
37244
37245
37246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
37247   void * jresult ;
37248   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37249   std::string *arg2 = 0 ;
37250   Dali::Property::Map *arg3 = 0 ;
37251   Dali::Animation result;
37252
37253   arg1 = (Dali::Toolkit::Builder *)jarg1;
37254   if (!jarg2) {
37255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37256     return 0;
37257   }
37258   std::string arg2_str(jarg2);
37259   arg2 = &arg2_str;
37260   arg3 = (Dali::Property::Map *)jarg3;
37261   if (!arg3) {
37262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
37263     return 0;
37264   }
37265   {
37266     try {
37267       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
37268     } CALL_CATCH_EXCEPTION(0);
37269   }
37270
37271   jresult = new Dali::Animation((const Dali::Animation &)result);
37272
37273   //argout typemap for const std::string&
37274
37275   return jresult;
37276 }
37277
37278
37279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
37280   void * jresult ;
37281   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37282   std::string *arg2 = 0 ;
37283   Dali::Actor arg3 ;
37284   Dali::Actor *argp3 ;
37285   Dali::Animation result;
37286
37287   arg1 = (Dali::Toolkit::Builder *)jarg1;
37288   if (!jarg2) {
37289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37290     return 0;
37291   }
37292   std::string arg2_str(jarg2);
37293   arg2 = &arg2_str;
37294   argp3 = (Dali::Actor *)jarg3;
37295   if (!argp3) {
37296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37297     return 0;
37298   }
37299   arg3 = *argp3;
37300   {
37301     try {
37302       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
37303     } CALL_CATCH_EXCEPTION(0);
37304   }
37305
37306   jresult = new Dali::Animation((const Dali::Animation &)result);
37307
37308   //argout typemap for const std::string&
37309
37310   return jresult;
37311 }
37312
37313
37314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
37315   void * jresult ;
37316   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37317   std::string *arg2 = 0 ;
37318   Dali::Property::Map *arg3 = 0 ;
37319   Dali::Actor arg4 ;
37320   Dali::Actor *argp4 ;
37321   Dali::Animation result;
37322
37323   arg1 = (Dali::Toolkit::Builder *)jarg1;
37324   if (!jarg2) {
37325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37326     return 0;
37327   }
37328   std::string arg2_str(jarg2);
37329   arg2 = &arg2_str;
37330   arg3 = (Dali::Property::Map *)jarg3;
37331   if (!arg3) {
37332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
37333     return 0;
37334   }
37335   argp4 = (Dali::Actor *)jarg4;
37336   if (!argp4) {
37337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37338     return 0;
37339   }
37340   arg4 = *argp4;
37341   {
37342     try {
37343       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
37344     } CALL_CATCH_EXCEPTION(0);
37345   }
37346
37347   jresult = new Dali::Animation((const Dali::Animation &)result);
37348
37349   //argout typemap for const std::string&
37350
37351   return jresult;
37352 }
37353
37354
37355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
37356   void * jresult ;
37357   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37358   std::string *arg2 = 0 ;
37359   Dali::BaseHandle result;
37360
37361   arg1 = (Dali::Toolkit::Builder *)jarg1;
37362   if (!jarg2) {
37363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37364     return 0;
37365   }
37366   std::string arg2_str(jarg2);
37367   arg2 = &arg2_str;
37368   {
37369     try {
37370       result = (arg1)->Create((std::string const &)*arg2);
37371     } CALL_CATCH_EXCEPTION(0);
37372   }
37373
37374   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
37375
37376   //argout typemap for const std::string&
37377
37378   return jresult;
37379 }
37380
37381
37382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
37383   void * jresult ;
37384   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37385   std::string *arg2 = 0 ;
37386   Dali::Property::Map *arg3 = 0 ;
37387   Dali::BaseHandle result;
37388
37389   arg1 = (Dali::Toolkit::Builder *)jarg1;
37390   if (!jarg2) {
37391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37392     return 0;
37393   }
37394   std::string arg2_str(jarg2);
37395   arg2 = &arg2_str;
37396   arg3 = (Dali::Property::Map *)jarg3;
37397   if (!arg3) {
37398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
37399     return 0;
37400   }
37401   {
37402     try {
37403       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
37404     } CALL_CATCH_EXCEPTION(0);
37405   }
37406
37407   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
37408
37409   //argout typemap for const std::string&
37410
37411   return jresult;
37412 }
37413
37414
37415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
37416   void * jresult ;
37417   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37418   std::string *arg2 = 0 ;
37419   Dali::BaseHandle result;
37420
37421   arg1 = (Dali::Toolkit::Builder *)jarg1;
37422   if (!jarg2) {
37423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37424     return 0;
37425   }
37426   std::string arg2_str(jarg2);
37427   arg2 = &arg2_str;
37428   {
37429     try {
37430       result = (arg1)->CreateFromJson((std::string const &)*arg2);
37431     } CALL_CATCH_EXCEPTION(0);
37432   }
37433
37434   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
37435
37436   //argout typemap for const std::string&
37437
37438   return jresult;
37439 }
37440
37441
37442 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
37443   bool jresult ;
37444   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37445   std::string *arg2 = 0 ;
37446   Dali::Handle *arg3 = 0 ;
37447   bool result;
37448
37449   arg1 = (Dali::Toolkit::Builder *)jarg1;
37450   if (!jarg2) {
37451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37452     return 0;
37453   }
37454   std::string arg2_str(jarg2);
37455   arg2 = &arg2_str;
37456   arg3 = (Dali::Handle *)jarg3;
37457   if (!arg3) {
37458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
37459     return 0;
37460   }
37461   {
37462     try {
37463       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
37464     } CALL_CATCH_EXCEPTION(0);
37465   }
37466
37467   jresult = result;
37468
37469   //argout typemap for const std::string&
37470
37471   return jresult;
37472 }
37473
37474
37475 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
37476   bool jresult ;
37477   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37478   Dali::Handle *arg2 = 0 ;
37479   std::string *arg3 = 0 ;
37480   bool result;
37481
37482   arg1 = (Dali::Toolkit::Builder *)jarg1;
37483   arg2 = (Dali::Handle *)jarg2;
37484   if (!arg2) {
37485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
37486     return 0;
37487   }
37488   if (!jarg3) {
37489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37490     return 0;
37491   }
37492   std::string arg3_str(jarg3);
37493   arg3 = &arg3_str;
37494   {
37495     try {
37496       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
37497     } CALL_CATCH_EXCEPTION(0);
37498   }
37499
37500   jresult = result;
37501
37502   //argout typemap for const std::string&
37503
37504   return jresult;
37505 }
37506
37507
37508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
37509   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37510   Dali::Actor arg2 ;
37511   Dali::Actor *argp2 ;
37512
37513   arg1 = (Dali::Toolkit::Builder *)jarg1;
37514   argp2 = (Dali::Actor *)jarg2;
37515   if (!argp2) {
37516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37517     return ;
37518   }
37519   arg2 = *argp2;
37520   {
37521     try {
37522       (arg1)->AddActors(arg2);
37523     } CALL_CATCH_EXCEPTION();
37524   }
37525
37526 }
37527
37528
37529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
37530   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37531   std::string *arg2 = 0 ;
37532   Dali::Actor arg3 ;
37533   Dali::Actor *argp3 ;
37534
37535   arg1 = (Dali::Toolkit::Builder *)jarg1;
37536   if (!jarg2) {
37537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37538     return ;
37539   }
37540   std::string arg2_str(jarg2);
37541   arg2 = &arg2_str;
37542   argp3 = (Dali::Actor *)jarg3;
37543   if (!argp3) {
37544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37545     return ;
37546   }
37547   arg3 = *argp3;
37548   {
37549     try {
37550       (arg1)->AddActors((std::string const &)*arg2,arg3);
37551     } CALL_CATCH_EXCEPTION();
37552   }
37553
37554
37555   //argout typemap for const std::string&
37556
37557 }
37558
37559
37560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
37561   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37562   std::string *arg2 = 0 ;
37563
37564   arg1 = (Dali::Toolkit::Builder *)jarg1;
37565   if (!jarg2) {
37566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37567     return ;
37568   }
37569   std::string arg2_str(jarg2);
37570   arg2 = &arg2_str;
37571   {
37572     try {
37573       (arg1)->CreateRenderTask((std::string const &)*arg2);
37574     } CALL_CATCH_EXCEPTION();
37575   }
37576
37577
37578   //argout typemap for const std::string&
37579
37580 }
37581
37582
37583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
37584   void * jresult ;
37585   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37586   std::string *arg2 = 0 ;
37587   Dali::Path result;
37588
37589   arg1 = (Dali::Toolkit::Builder *)jarg1;
37590   if (!jarg2) {
37591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37592     return 0;
37593   }
37594   std::string arg2_str(jarg2);
37595   arg2 = &arg2_str;
37596   {
37597     try {
37598       result = (arg1)->GetPath((std::string const &)*arg2);
37599     } CALL_CATCH_EXCEPTION(0);
37600   }
37601
37602   jresult = new Dali::Path((const Dali::Path &)result);
37603
37604   //argout typemap for const std::string&
37605
37606   return jresult;
37607 }
37608
37609
37610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
37611   void * jresult ;
37612   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37613   std::string *arg2 = 0 ;
37614   Dali::PathConstrainer result;
37615
37616   arg1 = (Dali::Toolkit::Builder *)jarg1;
37617   if (!jarg2) {
37618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37619     return 0;
37620   }
37621   std::string arg2_str(jarg2);
37622   arg2 = &arg2_str;
37623   {
37624     try {
37625       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
37626     } CALL_CATCH_EXCEPTION(0);
37627   }
37628
37629   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
37630
37631   //argout typemap for const std::string&
37632
37633   return jresult;
37634 }
37635
37636
37637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
37638   void * jresult ;
37639   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37640   std::string *arg2 = 0 ;
37641   Dali::LinearConstrainer result;
37642
37643   arg1 = (Dali::Toolkit::Builder *)jarg1;
37644   if (!jarg2) {
37645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37646     return 0;
37647   }
37648   std::string arg2_str(jarg2);
37649   arg2 = &arg2_str;
37650   {
37651     try {
37652       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
37653     } CALL_CATCH_EXCEPTION(0);
37654   }
37655
37656   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
37657
37658   //argout typemap for const std::string&
37659
37660   return jresult;
37661 }
37662
37663
37664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
37665   void * jresult ;
37666   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37667   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
37668
37669   arg1 = (Dali::Toolkit::Builder *)jarg1;
37670   {
37671     try {
37672       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
37673     } CALL_CATCH_EXCEPTION(0);
37674   }
37675
37676   jresult = (void *)result;
37677   return jresult;
37678 }
37679
37680
37681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
37682   void * jresult ;
37683   Dali::Toolkit::TransitionData *result = 0 ;
37684
37685   {
37686     try {
37687       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
37688     } CALL_CATCH_EXCEPTION(0);
37689   }
37690
37691   jresult = (void *)result;
37692   return jresult;
37693 }
37694
37695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
37696   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
37697
37698   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
37699   {
37700     try {
37701       delete arg1;
37702     } CALL_CATCH_EXCEPTION();
37703   }
37704
37705 }
37706
37707
37708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
37709   void * jresult ;
37710   Dali::Property::Map *arg1 = 0 ;
37711   Dali::Toolkit::TransitionData result;
37712
37713   arg1 = (Dali::Property::Map *)jarg1;
37714   if (!arg1) {
37715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
37716     return 0;
37717   }
37718   {
37719     try {
37720       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
37721     } CALL_CATCH_EXCEPTION(0);
37722   }
37723
37724   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
37725   return jresult;
37726 }
37727
37728
37729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
37730   void * jresult ;
37731   Dali::Property::Array *arg1 = 0 ;
37732   Dali::Toolkit::TransitionData result;
37733
37734   arg1 = (Dali::Property::Array *)jarg1;
37735   if (!arg1) {
37736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
37737     return 0;
37738   }
37739   {
37740     try {
37741       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
37742     } CALL_CATCH_EXCEPTION(0);
37743   }
37744
37745   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
37746   return jresult;
37747 }
37748
37749
37750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
37751   void * jresult ;
37752   Dali::BaseHandle arg1 ;
37753   Dali::BaseHandle *argp1 ;
37754   Dali::Toolkit::TransitionData result;
37755
37756   argp1 = (Dali::BaseHandle *)jarg1;
37757   if (!argp1) {
37758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37759     return 0;
37760   }
37761   arg1 = *argp1;
37762   {
37763     try {
37764       result = Dali::Toolkit::TransitionData::DownCast(arg1);
37765     } CALL_CATCH_EXCEPTION(0);
37766   }
37767
37768   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
37769   return jresult;
37770 }
37771
37772
37773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
37774   void * jresult ;
37775   Dali::Toolkit::TransitionData *arg1 = 0 ;
37776   Dali::Toolkit::TransitionData *result = 0 ;
37777
37778   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
37779   if (!arg1) {
37780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
37781     return 0;
37782   }
37783   {
37784     try {
37785       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
37786     } CALL_CATCH_EXCEPTION(0);
37787   }
37788
37789   jresult = (void *)result;
37790   return jresult;
37791 }
37792
37793
37794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
37795   void * jresult ;
37796   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
37797   Dali::Toolkit::TransitionData *arg2 = 0 ;
37798   Dali::Toolkit::TransitionData *result = 0 ;
37799
37800   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
37801   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
37802   if (!arg2) {
37803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
37804     return 0;
37805   }
37806   {
37807     try {
37808       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
37809     } CALL_CATCH_EXCEPTION(0);
37810   }
37811
37812   jresult = (void *)result;
37813   return jresult;
37814 }
37815
37816
37817 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
37818   unsigned long jresult ;
37819   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
37820   size_t result;
37821
37822   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
37823   {
37824     try {
37825       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
37826     } CALL_CATCH_EXCEPTION(0);
37827   }
37828
37829   jresult = (unsigned long)result;
37830   return jresult;
37831 }
37832
37833
37834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
37835   void * jresult ;
37836   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
37837   size_t arg2 ;
37838   Dali::Property::Map result;
37839
37840   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
37841   arg2 = (size_t)jarg2;
37842   {
37843     try {
37844       result = (arg1)->GetAnimatorAt(arg2);
37845     } CALL_CATCH_EXCEPTION(0);
37846   }
37847
37848   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
37849   return jresult;
37850 }
37851
37852
37853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
37854   int jresult ;
37855   int result;
37856
37857   {
37858     try {
37859       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
37860     } CALL_CATCH_EXCEPTION(0);
37861   }
37862
37863   jresult = (int)result;
37864   return jresult;
37865 }
37866
37867
37868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
37869   int jresult ;
37870   int result;
37871
37872   {
37873     try {
37874       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
37875     } CALL_CATCH_EXCEPTION(0);
37876   }
37877
37878   jresult = (int)result;
37879   return jresult;
37880 }
37881
37882
37883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
37884   int jresult ;
37885   int result;
37886
37887   {
37888     try {
37889       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
37890     } CALL_CATCH_EXCEPTION(0);
37891   }
37892
37893   jresult = (int)result;
37894   return jresult;
37895 }
37896
37897
37898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
37899   int jresult ;
37900   int result;
37901
37902   {
37903     try {
37904       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
37905     } CALL_CATCH_EXCEPTION(0);
37906   }
37907
37908   jresult = (int)result;
37909   return jresult;
37910 }
37911
37912
37913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
37914   int jresult ;
37915   int result;
37916
37917   {
37918     try {
37919       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
37920     } CALL_CATCH_EXCEPTION(0);
37921   }
37922
37923   jresult = (int)result;
37924   return jresult;
37925 }
37926
37927
37928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
37929   int jresult ;
37930   int result;
37931
37932   {
37933     try {
37934       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
37935     } CALL_CATCH_EXCEPTION(0);
37936   }
37937
37938   jresult = (int)result;
37939   return jresult;
37940 }
37941
37942
37943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
37944   int jresult ;
37945   int result;
37946
37947   {
37948     try {
37949       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
37950     } CALL_CATCH_EXCEPTION(0);
37951   }
37952
37953   jresult = (int)result;
37954   return jresult;
37955 }
37956
37957
37958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
37959   int jresult ;
37960   int result;
37961
37962   {
37963     try {
37964       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
37965     } CALL_CATCH_EXCEPTION(0);
37966   }
37967
37968   jresult = (int)result;
37969   return jresult;
37970 }
37971
37972
37973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
37974   int jresult ;
37975   int result;
37976
37977   {
37978     try {
37979       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
37980     } CALL_CATCH_EXCEPTION(0);
37981   }
37982
37983   jresult = (int)result;
37984   return jresult;
37985 }
37986
37987
37988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
37989   int jresult ;
37990   int result;
37991
37992   {
37993     try {
37994       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
37995     } CALL_CATCH_EXCEPTION(0);
37996   }
37997
37998   jresult = (int)result;
37999   return jresult;
38000 }
38001
38002
38003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
38004   int jresult ;
38005   int result;
38006
38007   {
38008     try {
38009       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
38010     } CALL_CATCH_EXCEPTION(0);
38011   }
38012
38013   jresult = (int)result;
38014   return jresult;
38015 }
38016
38017
38018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
38019   int jresult ;
38020   int result;
38021
38022   {
38023     try {
38024       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
38025     } CALL_CATCH_EXCEPTION(0);
38026   }
38027
38028   jresult = (int)result;
38029   return jresult;
38030 }
38031
38032
38033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
38034   int jresult ;
38035   int result;
38036
38037   {
38038     try {
38039       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
38040     } CALL_CATCH_EXCEPTION(0);
38041   }
38042
38043   jresult = (int)result;
38044   return jresult;
38045 }
38046
38047
38048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
38049   int jresult ;
38050   int result;
38051
38052   {
38053     try {
38054       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
38055     } CALL_CATCH_EXCEPTION(0);
38056   }
38057
38058   jresult = (int)result;
38059   return jresult;
38060 }
38061
38062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New_With_Behaviour(int behaviour) {
38063   void * jresult ;
38064   Dali::Toolkit::Control result;
38065
38066   {
38067     try {
38068       result = Dali::Toolkit::Internal::Control::New((Dali::Toolkit::Internal::Control::ControlBehaviour)behaviour);
38069     } CALL_CATCH_EXCEPTION(0);
38070   }
38071
38072   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
38073   return jresult;
38074 }
38075
38076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
38077   return CSharp_Dali_ViewImpl_New_With_Behaviour((int)Dali::Toolkit::Internal::Control::ControlBehaviour::CONTROL_BEHAVIOUR_DEFAULT);
38078 }
38079
38080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
38081   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38082   std::string *arg2 = 0 ;
38083
38084   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38085   if (!jarg2) {
38086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
38087     return ;
38088   }
38089   std::string arg2_str(jarg2);
38090   arg2 = &arg2_str;
38091   {
38092     try {
38093       (arg1)->SetStyleName((std::string const &)*arg2);
38094     } CALL_CATCH_EXCEPTION();
38095   }
38096
38097
38098   //argout typemap for const std::string&
38099
38100 }
38101
38102
38103 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
38104   char * jresult ;
38105   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38106   std::string *result = 0 ;
38107
38108   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38109   {
38110     try {
38111       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
38112     } CALL_CATCH_EXCEPTION(0);
38113   }
38114
38115   jresult = SWIG_csharp_string_callback(result->c_str());
38116   return jresult;
38117 }
38118
38119
38120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
38121   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38122   Dali::Vector4 *arg2 = 0 ;
38123
38124   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38125   arg2 = (Dali::Vector4 *)jarg2;
38126   if (!arg2) {
38127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
38128     return ;
38129   }
38130   {
38131     try {
38132       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
38133     } CALL_CATCH_EXCEPTION();
38134   }
38135
38136 }
38137
38138
38139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
38140   void * jresult ;
38141   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
38142   Dali::Vector4 result;
38143
38144   arg1 = (Dali::Handle *)jarg1;
38145   {
38146     try {
38147       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
38148       if (resultMap)
38149       {
38150         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
38151         if(type && type->Get<int>() == Visual::COLOR )
38152         {
38153           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
38154           if (value)
38155           {
38156             result = value->Get<Vector4>();
38157           }
38158         }
38159       }
38160     } CALL_CATCH_EXCEPTION(0);
38161   }
38162
38163   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38164   return jresult;
38165 }
38166
38167
38168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
38169   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38170   Dali::Property::Map *arg2 = 0 ;
38171
38172   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38173   arg2 = (Dali::Property::Map *)jarg2;
38174   if (!arg2) {
38175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
38176     return ;
38177   }
38178   {
38179     try {
38180       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
38181     } CALL_CATCH_EXCEPTION();
38182   }
38183
38184 }
38185
38186
38187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
38188   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38189
38190   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38191   {
38192     try {
38193       (arg1)->ClearBackground();
38194     } CALL_CATCH_EXCEPTION();
38195   }
38196
38197 }
38198
38199
38200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
38201   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38202   Dali::GestureType::Value arg2 ;
38203
38204   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38205   arg2 = (Dali::GestureType::Value)jarg2;
38206   {
38207     try {
38208       (arg1)->EnableGestureDetection(arg2);
38209     } CALL_CATCH_EXCEPTION();
38210   }
38211
38212 }
38213
38214
38215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
38216   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38217   Dali::GestureType::Value arg2 ;
38218
38219   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38220   arg2 = (Dali::GestureType::Value)jarg2;
38221   {
38222     try {
38223       (arg1)->DisableGestureDetection(arg2);
38224     } CALL_CATCH_EXCEPTION();
38225   }
38226
38227 }
38228
38229
38230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
38231   void * jresult ;
38232   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38233   Dali::PinchGestureDetector result;
38234
38235   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38236   {
38237     try {
38238       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
38239     } CALL_CATCH_EXCEPTION(0);
38240   }
38241
38242   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
38243   return jresult;
38244 }
38245
38246
38247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
38248   void * jresult ;
38249   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38250   Dali::PanGestureDetector result;
38251
38252   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38253   {
38254     try {
38255       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
38256     } CALL_CATCH_EXCEPTION(0);
38257   }
38258
38259   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
38260   return jresult;
38261 }
38262
38263
38264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
38265   void * jresult ;
38266   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38267   Dali::TapGestureDetector result;
38268
38269   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38270   {
38271     try {
38272       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
38273     } CALL_CATCH_EXCEPTION(0);
38274   }
38275
38276   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
38277   return jresult;
38278 }
38279
38280
38281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
38282   void * jresult ;
38283   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38284   Dali::LongPressGestureDetector result;
38285
38286   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38287   {
38288     try {
38289       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
38290     } CALL_CATCH_EXCEPTION(0);
38291   }
38292
38293   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
38294   return jresult;
38295 }
38296
38297
38298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, bool jarg2) {
38299   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38300   bool arg2 ;
38301
38302   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38303   arg2 = jarg2 ? true : false;
38304   {
38305     try {
38306       (arg1)->SetKeyboardNavigationSupport(arg2);
38307     } CALL_CATCH_EXCEPTION();
38308   }
38309
38310 }
38311
38312
38313 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
38314   bool jresult ;
38315   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38316   bool result;
38317
38318   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38319   {
38320     try {
38321       result = (bool)(arg1)->IsKeyboardNavigationSupported();
38322     } CALL_CATCH_EXCEPTION(0);
38323   }
38324
38325   jresult = result;
38326   return jresult;
38327 }
38328
38329
38330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
38331   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38332
38333   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38334   {
38335     try {
38336       (arg1)->SetKeyInputFocus();
38337     } CALL_CATCH_EXCEPTION();
38338   }
38339
38340 }
38341
38342
38343 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
38344   bool jresult ;
38345   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38346   bool result;
38347
38348   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38349   {
38350     try {
38351       result = (bool)(arg1)->HasKeyInputFocus();
38352     } CALL_CATCH_EXCEPTION(0);
38353   }
38354
38355   jresult = result;
38356   return jresult;
38357 }
38358
38359
38360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
38361   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38362
38363   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38364   {
38365     try {
38366       (arg1)->ClearKeyInputFocus();
38367     } CALL_CATCH_EXCEPTION();
38368   }
38369
38370 }
38371
38372
38373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, bool jarg2) {
38374   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38375   bool arg2 ;
38376
38377   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38378   arg2 = jarg2 ? true : false;
38379   {
38380     try {
38381       (arg1)->SetAsKeyboardFocusGroup(arg2);
38382     } CALL_CATCH_EXCEPTION();
38383   }
38384
38385 }
38386
38387
38388 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
38389   bool jresult ;
38390   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38391   bool result;
38392
38393   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38394   {
38395     try {
38396       result = (bool)(arg1)->IsKeyboardFocusGroup();
38397     } CALL_CATCH_EXCEPTION(0);
38398   }
38399
38400   jresult = result;
38401   return jresult;
38402 }
38403
38404
38405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
38406   void * jresult ;
38407   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38408   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
38409
38410   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38411   {
38412     try {
38413       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38414     } CALL_CATCH_EXCEPTION(0);
38415   }
38416
38417   jresult = (void *)result;
38418   return jresult;
38419 }
38420
38421
38422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
38423   void * jresult ;
38424   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38425   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
38426
38427   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38428   {
38429     try {
38430       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
38431     } CALL_CATCH_EXCEPTION(0);
38432   }
38433
38434   jresult = (void *)result;
38435   return jresult;
38436 }
38437
38438
38439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
38440   void * jresult ;
38441   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38442   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
38443
38444   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38445   {
38446     try {
38447       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
38448     } CALL_CATCH_EXCEPTION(0);
38449   }
38450
38451   jresult = (void *)result;
38452   return jresult;
38453 }
38454
38455
38456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnection(void * jarg1, int jarg2) {
38457   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38458   int arg2 ;
38459   SwigDirector_ViewImpl *darg = 0;
38460
38461   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38462   arg2 = (int)jarg2;
38463   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38464   if(!darg) {
38465     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38466     return;
38467   }
38468   {
38469     try {
38470       if(darg) {
38471         (darg)->OnSceneConnection(arg2);
38472       }
38473     } CALL_CATCH_EXCEPTION();
38474   }
38475
38476 }
38477
38478
38479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
38480   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38481   int arg2 ;
38482   SwigDirector_ViewImpl *darg = 0;
38483
38484   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38485   arg2 = (int)jarg2;
38486   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38487   if(!darg) {
38488     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38489     return;
38490   }
38491   {
38492     try {
38493       if(darg) {
38494         (darg)->OnSceneConnectionSwigPublic(arg2);
38495       }
38496     } CALL_CATCH_EXCEPTION();
38497   }
38498
38499 }
38500
38501
38502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnection(void * jarg1) {
38503   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38504   SwigDirector_ViewImpl *darg = 0;
38505
38506   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38507   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38508   if(!darg) {
38509     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38510     return;
38511   }
38512   {
38513     try {
38514       if(darg) {
38515         (darg)->OnSceneDisconnection();
38516       }
38517     } CALL_CATCH_EXCEPTION();
38518   }
38519
38520 }
38521
38522
38523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnectionSwigExplicitViewImpl(void * jarg1) {
38524   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38525   SwigDirector_ViewImpl *darg = 0;
38526
38527   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38528   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38529   if(!darg) {
38530     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38531     return;
38532   }
38533   {
38534     try {
38535       if(darg) {
38536         (darg)->OnSceneDisconnectionSwigPublic();
38537       }
38538     } CALL_CATCH_EXCEPTION();
38539   }
38540
38541 }
38542
38543
38544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
38545   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38546   Dali::Actor *arg2 = 0 ;
38547   SwigDirector_ViewImpl *darg = 0;
38548
38549   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38550   arg2 = (Dali::Actor *)jarg2;
38551   if (!arg2) {
38552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38553     return ;
38554   }
38555   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38556   if(!darg) {
38557     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38558     return;
38559   }
38560   {
38561     try {
38562       if(darg) {
38563         (darg)->OnChildAdd(*arg2);
38564       }
38565     } CALL_CATCH_EXCEPTION();
38566   }
38567
38568 }
38569
38570
38571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
38572   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38573   Dali::Actor *arg2 = 0 ;
38574   SwigDirector_ViewImpl *darg = 0;
38575
38576   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38577   arg2 = (Dali::Actor *)jarg2;
38578   if (!arg2) {
38579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38580     return ;
38581   }
38582   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38583   if(!darg) {
38584     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38585     return;
38586   }
38587   {
38588     try {
38589       if(darg) {
38590           (darg)->OnChildAddSwigPublic(*arg2);
38591       }
38592     } CALL_CATCH_EXCEPTION();
38593   }
38594
38595 }
38596
38597
38598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
38599   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38600   Dali::Actor *arg2 = 0 ;
38601   SwigDirector_ViewImpl *darg = 0;
38602
38603   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38604   arg2 = (Dali::Actor *)jarg2;
38605   if (!arg2) {
38606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38607     return ;
38608   }
38609   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38610   if(!darg) {
38611     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38612     return;
38613   }
38614   {
38615     try {
38616       if(darg) {
38617         (darg)->OnChildRemove(*arg2);
38618       }
38619     } CALL_CATCH_EXCEPTION();
38620   }
38621
38622 }
38623
38624
38625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
38626   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38627   Dali::Actor *arg2 = 0 ;
38628   SwigDirector_ViewImpl *darg = 0;
38629
38630   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38631   arg2 = (Dali::Actor *)jarg2;
38632   if (!arg2) {
38633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38634     return ;
38635   }
38636   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38637   if(!darg) {
38638     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38639     return;
38640   }
38641   {
38642     try {
38643       if(darg) {
38644         (darg)->OnChildRemoveSwigPublic(*arg2);
38645       }
38646     } CALL_CATCH_EXCEPTION();
38647   }
38648
38649 }
38650
38651
38652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
38653   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38654   Dali::Property::Index arg2 ;
38655   Dali::Property::Value arg3 ;
38656   Dali::Property::Value *argp3 ;
38657   SwigDirector_ViewImpl *darg = 0;
38658
38659   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38660   arg2 = (Dali::Property::Index)jarg2;
38661   argp3 = (Dali::Property::Value *)jarg3;
38662   if (!argp3) {
38663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
38664     return ;
38665   }
38666   arg3 = *argp3;
38667   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38668   if (!darg) {
38669     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38670     return;
38671   }
38672   {
38673     try {
38674       (darg)->OnPropertySet(arg2,arg3);
38675     } CALL_CATCH_EXCEPTION();
38676   }
38677
38678 }
38679
38680
38681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
38682   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38683   Dali::Vector3 *arg2 = 0 ;
38684   SwigDirector_ViewImpl *darg = 0;
38685
38686   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38687   arg2 = (Dali::Vector3 *)jarg2;
38688   if (!arg2) {
38689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38690     return ;
38691   }
38692   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38693   if (!darg) {
38694     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38695     return;
38696   }
38697   {
38698     try {
38699       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
38700     } CALL_CATCH_EXCEPTION();
38701   }
38702
38703 }
38704
38705
38706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
38707   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38708   Dali::Vector3 *arg2 = 0 ;
38709   SwigDirector_ViewImpl *darg = 0;
38710
38711   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38712   arg2 = (Dali::Vector3 *)jarg2;
38713   if (!arg2) {
38714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38715     return ;
38716   }
38717   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38718   if (!darg) {
38719     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38720     return;
38721   }
38722   {
38723     try {
38724       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
38725     } CALL_CATCH_EXCEPTION();
38726   }
38727
38728 }
38729
38730
38731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
38732   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38733   Dali::Animation *arg2 = 0 ;
38734   Dali::Vector3 *arg3 = 0 ;
38735   SwigDirector_ViewImpl *darg = 0;
38736
38737   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38738   arg2 = (Dali::Animation *)jarg2;
38739   if (!arg2) {
38740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
38741     return ;
38742   }
38743   arg3 = (Dali::Vector3 *)jarg3;
38744   if (!arg3) {
38745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38746     return ;
38747   }
38748   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38749   if (!darg) {
38750     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38751     return;
38752   }
38753   {
38754     try {
38755       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
38756     } CALL_CATCH_EXCEPTION();
38757   }
38758
38759 }
38760
38761
38762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
38763   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38764   Dali::Animation *arg2 = 0 ;
38765   Dali::Vector3 *arg3 = 0 ;
38766   SwigDirector_ViewImpl *darg = 0;
38767
38768   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38769   arg2 = (Dali::Animation *)jarg2;
38770   if (!arg2) {
38771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
38772     return ;
38773   }
38774   arg3 = (Dali::Vector3 *)jarg3;
38775   if (!arg3) {
38776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38777     return ;
38778   }
38779   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38780   if (!darg) {
38781     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38782     return;
38783   }
38784   {
38785     try {
38786       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
38787     } CALL_CATCH_EXCEPTION();
38788   }
38789 }
38790
38791 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
38792   bool jresult ;
38793   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38794   Dali::KeyEvent *arg2 = 0 ;
38795   SwigDirector_ViewImpl *darg = 0;
38796   bool result;
38797
38798   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38799   arg2 = (Dali::KeyEvent *)jarg2;
38800   if (!arg2) {
38801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
38802     return 0;
38803   }
38804   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38805   if (!darg) {
38806     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38807     return 0;
38808   }
38809   {
38810     try {
38811       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
38812     } CALL_CATCH_EXCEPTION(0);
38813   }
38814
38815   jresult = result;
38816   return jresult;
38817 }
38818
38819
38820 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
38821   bool jresult ;
38822   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38823   Dali::KeyEvent *arg2 = 0 ;
38824   SwigDirector_ViewImpl *darg = 0;
38825   bool result;
38826
38827   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38828   arg2 = (Dali::KeyEvent *)jarg2;
38829   if (!arg2) {
38830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
38831     return 0;
38832   }
38833   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38834   if (!darg) {
38835     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38836     return 0;
38837   }
38838   {
38839     try {
38840       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
38841     } CALL_CATCH_EXCEPTION(0);
38842   }
38843
38844   jresult = result;
38845   return jresult;
38846 }
38847
38848
38849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
38850   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38851   Dali::Vector2 *arg2 = 0 ;
38852   Dali::RelayoutContainer *arg3 = 0 ;
38853   SwigDirector_ViewImpl *darg = 0;
38854
38855   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38856   arg2 = (Dali::Vector2 *)jarg2;
38857   if (!arg2) {
38858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38859     return ;
38860   }
38861   arg3 = (Dali::RelayoutContainer *)jarg3;
38862   if (!arg3) {
38863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
38864     return ;
38865   }
38866   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38867   if (!darg) {
38868     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38869     return;
38870   }
38871   {
38872     try {
38873       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
38874     } CALL_CATCH_EXCEPTION();
38875   }
38876
38877 }
38878
38879
38880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
38881   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38882   Dali::Vector2 *arg2 = 0 ;
38883   Dali::RelayoutContainer *arg3 = 0 ;
38884   SwigDirector_ViewImpl *darg = 0;
38885
38886   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38887   arg2 = (Dali::Vector2 *)jarg2;
38888   if (!arg2) {
38889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38890     return ;
38891   }
38892   arg3 = (Dali::RelayoutContainer *)jarg3;
38893   if (!arg3) {
38894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
38895     return ;
38896   }
38897   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38898   if (!darg) {
38899     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38900     return;
38901   }
38902   {
38903     try {
38904       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
38905     } CALL_CATCH_EXCEPTION();
38906   }
38907
38908 }
38909
38910
38911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
38912   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38913   Dali::ResizePolicy::Type arg2 ;
38914   Dali::Dimension::Type arg3 ;
38915   SwigDirector_ViewImpl *darg = 0;
38916
38917   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38918   arg2 = (Dali::ResizePolicy::Type)jarg2;
38919   arg3 = (Dali::Dimension::Type)jarg3;
38920   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38921   if (!darg) {
38922     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38923     return;
38924   }
38925   {
38926     try {
38927       (darg)->OnSetResizePolicy(arg2,arg3);
38928     } CALL_CATCH_EXCEPTION();
38929   }
38930
38931 }
38932
38933
38934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
38935   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38936   Dali::ResizePolicy::Type arg2 ;
38937   Dali::Dimension::Type arg3 ;
38938   SwigDirector_ViewImpl *darg = 0;
38939
38940   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38941   arg2 = (Dali::ResizePolicy::Type)jarg2;
38942   arg3 = (Dali::Dimension::Type)jarg3;
38943   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38944   if (!darg) {
38945     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38946     return;
38947   }
38948   {
38949     try {
38950       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
38951     } CALL_CATCH_EXCEPTION();
38952   }
38953
38954 }
38955
38956
38957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
38958   void * jresult ;
38959   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38960   SwigDirector_ViewImpl *darg = 0;
38961   Dali::Vector3 result;
38962
38963   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38964   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38965   if (!darg) {
38966     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38967     return 0;
38968   }
38969   {
38970     try {
38971       result = (darg)->GetNaturalSize();
38972     } CALL_CATCH_EXCEPTION(0);
38973   }
38974
38975   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
38976   return jresult;
38977 }
38978
38979
38980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
38981   void * jresult ;
38982   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38983   SwigDirector_ViewImpl *darg = 0;
38984   Dali::Vector3 result;
38985
38986   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38987   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38988   if (!darg) {
38989     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38990     return 0;
38991   }
38992   {
38993     try {
38994       result = (darg)->GetNaturalSizeSwigPublic();
38995     } CALL_CATCH_EXCEPTION(0);
38996   }
38997
38998   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
38999   return jresult;
39000 }
39001
39002
39003 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39004   float jresult ;
39005   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39006   Dali::Actor *arg2 = 0 ;
39007   Dali::Dimension::Type arg3 ;
39008   SwigDirector_ViewImpl *darg = 0;
39009   float result;
39010
39011   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39012   arg2 = (Dali::Actor *)jarg2;
39013   if (!arg2) {
39014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39015     return 0;
39016   }
39017   arg3 = (Dali::Dimension::Type)jarg3;
39018   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
39019   if (!darg) {
39020     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
39021     return 0;
39022   }
39023   {
39024     try {
39025       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39026     } CALL_CATCH_EXCEPTION(0);
39027   }
39028
39029   jresult = result;
39030   return jresult;
39031 }
39032
39033
39034 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
39035   float jresult ;
39036   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39037   Dali::Actor *arg2 = 0 ;
39038   Dali::Dimension::Type arg3 ;
39039   SwigDirector_ViewImpl *darg = 0;
39040   float result;
39041
39042   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39043   arg2 = (Dali::Actor *)jarg2;
39044   if (!arg2) {
39045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39046     return 0;
39047   }
39048   arg3 = (Dali::Dimension::Type)jarg3;
39049   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
39050   if (!darg) {
39051     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
39052     return 0;
39053   }
39054   {
39055     try {
39056       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
39057     } CALL_CATCH_EXCEPTION(0);
39058   }
39059
39060   jresult = result;
39061   return jresult;
39062 }
39063
39064
39065 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39066   float jresult ;
39067   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39068   float arg2 ;
39069   SwigDirector_ViewImpl *darg = 0;
39070   float result;
39071
39072   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39073   arg2 = (float)jarg2;
39074   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
39075   if (!darg) {
39076     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
39077     return 0;
39078   }
39079   {
39080     try {
39081       result = (float)(darg)->GetHeightForWidth(arg2);
39082     } CALL_CATCH_EXCEPTION(0);
39083   }
39084
39085   jresult = result;
39086   return jresult;
39087 }
39088
39089
39090 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
39091   float jresult ;
39092   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39093   float arg2 ;
39094   SwigDirector_ViewImpl *darg = 0;
39095   float result;
39096
39097   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39098   arg2 = (float)jarg2;
39099   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
39100   if (!darg) {
39101     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
39102     return 0;
39103   }
39104   {
39105     try {
39106       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
39107     } CALL_CATCH_EXCEPTION(0);
39108   }
39109
39110   jresult = result;
39111   return jresult;
39112 }
39113
39114
39115 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39116   float jresult ;
39117   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39118   float arg2 ;
39119   SwigDirector_ViewImpl *darg = 0;
39120   float result;
39121
39122   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39123   arg2 = (float)jarg2;
39124   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
39125   if (!darg) {
39126     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
39127     return 0;
39128   }
39129   {
39130     try {
39131       result = (float)(darg)->GetWidthForHeight(arg2);
39132     } CALL_CATCH_EXCEPTION(0);
39133   }
39134
39135   jresult = result;
39136   return jresult;
39137 }
39138
39139
39140 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
39141   float jresult ;
39142   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39143   float arg2 ;
39144   SwigDirector_ViewImpl *darg = 0;
39145   float result;
39146
39147   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39148   arg2 = (float)jarg2;
39149   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
39150   if (!darg) {
39151     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
39152     return 0;
39153   }
39154   {
39155     try {
39156       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
39157     } CALL_CATCH_EXCEPTION(0);
39158   }
39159
39160   jresult = result;
39161   return jresult;
39162 }
39163
39164
39165 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39166   bool jresult ;
39167   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39168   Dali::Dimension::Type arg2 ;
39169   SwigDirector_ViewImpl *darg = 0;
39170   bool result;
39171
39172   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39173   arg2 = (Dali::Dimension::Type)jarg2;
39174   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
39175   if (!darg) {
39176     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
39177     return 0;
39178   }
39179   {
39180     try {
39181       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
39182     } CALL_CATCH_EXCEPTION(0);
39183   }
39184
39185   jresult = result;
39186   return jresult;
39187 }
39188
39189
39190 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
39191   bool jresult ;
39192   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39193   Dali::Dimension::Type arg2 ;
39194   SwigDirector_ViewImpl *darg = 0;
39195   bool result;
39196
39197   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39198   arg2 = (Dali::Dimension::Type)jarg2;
39199   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
39200   if (!darg) {
39201     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
39202     return 0;
39203   }
39204   {
39205     try {
39206       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
39207     } CALL_CATCH_EXCEPTION(0);
39208   }
39209
39210   jresult = result;
39211   return jresult;
39212 }
39213
39214
39215 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39216   bool jresult ;
39217   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39218   SwigDirector_ViewImpl *darg = 0;
39219   bool result;
39220
39221   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39222   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
39223   if (!darg) {
39224     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
39225     return 0;
39226   }
39227   {
39228     try {
39229       result = (bool)(darg)->RelayoutDependentOnChildren();
39230     } CALL_CATCH_EXCEPTION(0);
39231   }
39232
39233   jresult = result;
39234   return jresult;
39235 }
39236
39237
39238 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
39239   bool jresult ;
39240   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39241   SwigDirector_ViewImpl *darg = 0;
39242   bool result;
39243
39244   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39245   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
39246   if (!darg) {
39247     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
39248     return 0;
39249   }
39250   {
39251     try {
39252       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
39253     } CALL_CATCH_EXCEPTION(0);
39254   }
39255
39256   jresult = result;
39257   return jresult;
39258 }
39259
39260
39261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39262   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39263   Dali::Dimension::Type arg2 ;
39264   SwigDirector_ViewImpl *darg = 0;
39265
39266   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39267   arg2 = (Dali::Dimension::Type)jarg2;
39268   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
39269   if (!darg) {
39270     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
39271     return;
39272   }
39273   {
39274     try {
39275       (darg)->OnCalculateRelayoutSize(arg2);
39276     } CALL_CATCH_EXCEPTION();
39277   }
39278
39279 }
39280
39281
39282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
39283   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39284   Dali::Dimension::Type arg2 ;
39285   SwigDirector_ViewImpl *darg = 0;
39286
39287   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39288   arg2 = (Dali::Dimension::Type)jarg2;
39289   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
39290   if (!darg) {
39291     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
39292     return;
39293   }
39294   {
39295     try {
39296       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
39297     } CALL_CATCH_EXCEPTION();
39298   }
39299
39300 }
39301
39302
39303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39304   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39305   float arg2 ;
39306   Dali::Dimension::Type arg3 ;
39307   SwigDirector_ViewImpl *darg = 0;
39308
39309   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39310   arg2 = (float)jarg2;
39311   arg3 = (Dali::Dimension::Type)jarg3;
39312   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
39313   if (!darg) {
39314     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
39315     return;
39316   }
39317   {
39318     try {
39319       (darg)->OnLayoutNegotiated(arg2,arg3);
39320     } CALL_CATCH_EXCEPTION();
39321   }
39322
39323 }
39324
39325
39326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
39327   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39328   float arg2 ;
39329   Dali::Dimension::Type arg3 ;
39330   SwigDirector_ViewImpl *darg = 0;
39331
39332   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39333   arg2 = (float)jarg2;
39334   arg3 = (Dali::Dimension::Type)jarg3;
39335   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
39336   if (!darg) {
39337     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
39338     return;
39339   }
39340   {
39341     try {
39342       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
39343     } CALL_CATCH_EXCEPTION();
39344   }
39345
39346 }
39347
39348
39349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
39350   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39351
39352   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39353   {
39354     try {
39355       (arg1)->OnInitialize();
39356     } CALL_CATCH_EXCEPTION();
39357   }
39358
39359 }
39360
39361
39362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
39363   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39364
39365   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39366   {
39367     try {
39368       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
39369     } CALL_CATCH_EXCEPTION();
39370   }
39371
39372 }
39373
39374
39375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
39376   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39377   Dali::Toolkit::StyleManager arg2 ;
39378   Dali::StyleChange::Type arg3 ;
39379   Dali::Toolkit::StyleManager *argp2 ;
39380
39381   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39382   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
39383   if (!argp2) {
39384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
39385     return ;
39386   }
39387   arg2 = *argp2;
39388   arg3 = (Dali::StyleChange::Type)jarg3;
39389   {
39390     try {
39391       (arg1)->OnStyleChange(arg2,arg3);
39392     } CALL_CATCH_EXCEPTION();
39393   }
39394
39395 }
39396
39397
39398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
39399   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39400   Dali::Toolkit::StyleManager arg2 ;
39401   Dali::StyleChange::Type arg3 ;
39402   Dali::Toolkit::StyleManager *argp2 ;
39403
39404   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39405   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
39406   if (!argp2) {
39407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
39408     return ;
39409   }
39410   arg2 = *argp2;
39411   arg3 = (Dali::StyleChange::Type)jarg3;
39412   {
39413     try {
39414       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
39415     } CALL_CATCH_EXCEPTION();
39416   }
39417
39418 }
39419
39420
39421 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
39422   bool jresult ;
39423   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39424   bool result;
39425
39426   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39427   {
39428     try {
39429       result = (bool)(arg1)->OnAccessibilityActivated();
39430     } CALL_CATCH_EXCEPTION(0);
39431   }
39432
39433   jresult = result;
39434   return jresult;
39435 }
39436
39437
39438 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
39439   bool jresult ;
39440   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39441   bool result;
39442
39443   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39444   {
39445     try {
39446       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
39447     } CALL_CATCH_EXCEPTION(0);
39448   }
39449
39450   jresult = result;
39451   return jresult;
39452 }
39453
39454
39455 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
39456   bool jresult ;
39457   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39458   Dali::PanGesture arg2 ;
39459   Dali::PanGesture *argp2 ;
39460   bool result;
39461
39462   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39463   argp2 = (Dali::PanGesture *)jarg2;
39464   if (!argp2) {
39465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
39466     return 0;
39467   }
39468   arg2 = *argp2;
39469   {
39470     try {
39471       result = (bool)(arg1)->OnAccessibilityPan(arg2);
39472     } CALL_CATCH_EXCEPTION(0);
39473   }
39474
39475   jresult = result;
39476   return jresult;
39477 }
39478
39479
39480 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
39481   bool jresult ;
39482   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39483   Dali::PanGesture arg2 ;
39484   Dali::PanGesture *argp2 ;
39485   bool result;
39486
39487   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39488   argp2 = (Dali::PanGesture *)jarg2;
39489   if (!argp2) {
39490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
39491     return 0;
39492   }
39493   arg2 = *argp2;
39494   {
39495     try {
39496       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
39497     } CALL_CATCH_EXCEPTION(0);
39498   }
39499
39500   jresult = result;
39501   return jresult;
39502 }
39503
39504 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, bool jarg2) {
39505   bool jresult ;
39506   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39507   bool arg2 ;
39508   bool result;
39509
39510   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39511   arg2 = jarg2 ? true : false;
39512   {
39513     try {
39514       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
39515     } CALL_CATCH_EXCEPTION(0);
39516   }
39517
39518   jresult = result;
39519   return jresult;
39520 }
39521
39522
39523 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, bool jarg2) {
39524   bool jresult ;
39525   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39526   bool arg2 ;
39527   bool result;
39528
39529   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39530   arg2 = jarg2 ? true : false;
39531   {
39532     try {
39533       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
39534     } CALL_CATCH_EXCEPTION(0);
39535   }
39536
39537   jresult = result;
39538   return jresult;
39539 }
39540
39541
39542 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
39543   bool jresult ;
39544   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39545   bool result;
39546
39547   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39548   {
39549     try {
39550       result = (bool)(arg1)->OnAccessibilityZoom();
39551     } CALL_CATCH_EXCEPTION(0);
39552   }
39553
39554   jresult = result;
39555   return jresult;
39556 }
39557
39558
39559 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
39560   bool jresult ;
39561   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39562   bool result;
39563
39564   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39565   {
39566     try {
39567       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
39568     } CALL_CATCH_EXCEPTION(0);
39569   }
39570
39571   jresult = result;
39572   return jresult;
39573 }
39574
39575
39576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
39577   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39578
39579   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39580   {
39581     try {
39582       (arg1)->OnKeyInputFocusGained();
39583     } CALL_CATCH_EXCEPTION();
39584   }
39585
39586 }
39587
39588
39589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
39590   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39591
39592   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39593   {
39594     try {
39595       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
39596     } CALL_CATCH_EXCEPTION();
39597   }
39598
39599 }
39600
39601
39602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
39603   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39604
39605   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39606   {
39607     try {
39608       (arg1)->OnKeyInputFocusLost();
39609     } CALL_CATCH_EXCEPTION();
39610   }
39611
39612 }
39613
39614
39615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
39616   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39617
39618   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39619   {
39620     try {
39621       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
39622     } CALL_CATCH_EXCEPTION();
39623   }
39624
39625 }
39626
39627
39628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, bool jarg4) {
39629   void * jresult ;
39630   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39631   Dali::Actor arg2 ;
39632   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
39633   bool arg4 ;
39634   Dali::Actor *argp2 ;
39635   Dali::Actor result;
39636
39637   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39638   argp2 = (Dali::Actor *)jarg2;
39639   if (!argp2) {
39640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39641     return 0;
39642   }
39643   arg2 = *argp2;
39644   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
39645   arg4 = jarg4 ? true : false;
39646   {
39647     try {
39648       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
39649     } CALL_CATCH_EXCEPTION(0);
39650   }
39651
39652   jresult = new Dali::Actor((const Dali::Actor &)result);
39653   return jresult;
39654 }
39655
39656
39657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, bool jarg4) {
39658   void * jresult ;
39659   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39660   Dali::Actor arg2 ;
39661   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
39662   bool arg4 ;
39663   Dali::Actor *argp2 ;
39664   Dali::Actor result;
39665
39666   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39667   argp2 = (Dali::Actor *)jarg2;
39668   if (!argp2) {
39669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39670     return 0;
39671   }
39672   arg2 = *argp2;
39673   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
39674   arg4 = jarg4 ? true : false;
39675   {
39676     try {
39677       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
39678     } CALL_CATCH_EXCEPTION(0);
39679   }
39680
39681   jresult = new Dali::Actor((const Dali::Actor &)result);
39682   return jresult;
39683 }
39684
39685
39686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
39687   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39688   Dali::Actor arg2 ;
39689   Dali::Actor *argp2 ;
39690
39691   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39692   argp2 = (Dali::Actor *)jarg2;
39693   if (!argp2) {
39694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39695     return ;
39696   }
39697   arg2 = *argp2;
39698   {
39699     try {
39700       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
39701     } CALL_CATCH_EXCEPTION();
39702   }
39703
39704 }
39705
39706
39707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
39708   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39709   Dali::Actor arg2 ;
39710   Dali::Actor *argp2 ;
39711
39712   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39713   argp2 = (Dali::Actor *)jarg2;
39714   if (!argp2) {
39715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39716     return ;
39717   }
39718   arg2 = *argp2;
39719   {
39720     try {
39721       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
39722     } CALL_CATCH_EXCEPTION();
39723   }
39724
39725 }
39726
39727
39728 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
39729   bool jresult ;
39730   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39731   bool result;
39732
39733   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39734   {
39735     try {
39736       result = (bool)(arg1)->OnKeyboardEnter();
39737     } CALL_CATCH_EXCEPTION(0);
39738   }
39739
39740   jresult = result;
39741   return jresult;
39742 }
39743
39744
39745 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
39746   bool jresult ;
39747   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39748   bool result;
39749
39750   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39751   {
39752     try {
39753       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
39754     } CALL_CATCH_EXCEPTION(0);
39755   }
39756
39757   jresult = result;
39758   return jresult;
39759 }
39760
39761
39762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
39763   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39764   Dali::PinchGesture *arg2 = 0 ;
39765
39766   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39767   arg2 = (Dali::PinchGesture *)jarg2;
39768   if (!arg2) {
39769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
39770     return ;
39771   }
39772   {
39773     try {
39774       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
39775     } CALL_CATCH_EXCEPTION();
39776   }
39777
39778 }
39779
39780
39781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
39782   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39783   Dali::PinchGesture *arg2 = 0 ;
39784
39785   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39786   arg2 = (Dali::PinchGesture *)jarg2;
39787   if (!arg2) {
39788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
39789     return ;
39790   }
39791   {
39792     try {
39793       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
39794     } CALL_CATCH_EXCEPTION();
39795   }
39796
39797 }
39798
39799
39800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
39801   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39802   Dali::PanGesture *arg2 = 0 ;
39803
39804   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39805   arg2 = (Dali::PanGesture *)jarg2;
39806   if (!arg2) {
39807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
39808     return ;
39809   }
39810   {
39811     try {
39812       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
39813     } CALL_CATCH_EXCEPTION();
39814   }
39815
39816 }
39817
39818
39819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
39820   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39821   Dali::PanGesture *arg2 = 0 ;
39822
39823   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39824   arg2 = (Dali::PanGesture *)jarg2;
39825   if (!arg2) {
39826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
39827     return ;
39828   }
39829   {
39830     try {
39831       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
39832     } CALL_CATCH_EXCEPTION();
39833   }
39834
39835 }
39836
39837
39838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
39839   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39840   Dali::TapGesture *arg2 = 0 ;
39841
39842   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39843   arg2 = (Dali::TapGesture *)jarg2;
39844   if (!arg2) {
39845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
39846     return ;
39847   }
39848   {
39849     try {
39850       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
39851     } CALL_CATCH_EXCEPTION();
39852   }
39853
39854 }
39855
39856
39857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
39858   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39859   Dali::TapGesture *arg2 = 0 ;
39860
39861   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39862   arg2 = (Dali::TapGesture *)jarg2;
39863   if (!arg2) {
39864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
39865     return ;
39866   }
39867   {
39868     try {
39869       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
39870     } CALL_CATCH_EXCEPTION();
39871   }
39872
39873 }
39874
39875
39876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
39877   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39878   Dali::LongPressGesture *arg2 = 0 ;
39879
39880   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39881   arg2 = (Dali::LongPressGesture *)jarg2;
39882   if (!arg2) {
39883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
39884     return ;
39885   }
39886   {
39887     try {
39888       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
39889     } CALL_CATCH_EXCEPTION();
39890   }
39891
39892 }
39893
39894
39895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
39896   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39897   Dali::LongPressGesture *arg2 = 0 ;
39898
39899   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39900   arg2 = (Dali::LongPressGesture *)jarg2;
39901   if (!arg2) {
39902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
39903     return ;
39904   }
39905   {
39906     try {
39907       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
39908     } CALL_CATCH_EXCEPTION();
39909   }
39910
39911 }
39912
39913
39914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
39915   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39916   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
39917   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
39918
39919   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39920   arg2 = (Dali::SlotObserver *)jarg2;
39921   arg3 = (Dali::CallbackBase *)jarg3;
39922   {
39923     try {
39924       (arg1)->SignalConnected(arg2,arg3);
39925     } CALL_CATCH_EXCEPTION();
39926   }
39927
39928 }
39929
39930
39931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
39932   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39933   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
39934   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
39935
39936   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39937   arg2 = (Dali::SlotObserver *)jarg2;
39938   arg3 = (Dali::CallbackBase *)jarg3;
39939   {
39940     try {
39941       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
39942     } CALL_CATCH_EXCEPTION();
39943   }
39944
39945 }
39946
39947
39948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
39949   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39950   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
39951   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
39952
39953   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39954   arg2 = (Dali::SlotObserver *)jarg2;
39955   arg3 = (Dali::CallbackBase *)jarg3;
39956   {
39957     try {
39958       (arg1)->SignalDisconnected(arg2,arg3);
39959     } CALL_CATCH_EXCEPTION();
39960   }
39961
39962 }
39963
39964
39965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
39966   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39967   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
39968   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
39969
39970   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39971   arg2 = (Dali::SlotObserver *)jarg2;
39972   arg3 = (Dali::CallbackBase *)jarg3;
39973   {
39974     try {
39975       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
39976     } CALL_CATCH_EXCEPTION();
39977   }
39978
39979 }
39980
39981 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) {
39982   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
39983   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
39984   if (director) {
39985     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);
39986   }
39987 }
39988
39989
39990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
39991   void * jresult ;
39992   Dali::Toolkit::Control *arg1 = 0 ;
39993   Dali::Toolkit::Internal::Control *result = 0 ;
39994
39995   arg1 = (Dali::Toolkit::Control *)jarg1;
39996   if (!arg1) {
39997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
39998     return 0;
39999   }
40000   {
40001     try {
40002       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
40003     } CALL_CATCH_EXCEPTION(0);
40004   }
40005
40006   jresult = (void *)result;
40007   return jresult;
40008 }
40009
40010
40011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
40012   int jresult ;
40013   int result;
40014
40015   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
40016   jresult = (int)result;
40017   return jresult;
40018 }
40019
40020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
40021   int jresult ;
40022   int result;
40023
40024   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
40025   jresult = (int)result;
40026   return jresult;
40027 }
40028
40029
40030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
40031   int jresult ;
40032   int result;
40033
40034   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
40035   jresult = (int)result;
40036   return jresult;
40037 }
40038
40039 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
40040   int jresult ;
40041   int result;
40042
40043   result = (int)Dali::Toolkit::Control::Property::MARGIN;
40044   jresult = (int)result;
40045   return jresult;
40046 }
40047
40048
40049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
40050   int jresult ;
40051   int result;
40052
40053   result = (int)Dali::Toolkit::Control::Property::PADDING;
40054   jresult = (int)result;
40055   return jresult;
40056 }
40057
40058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
40059   int jresult ;
40060   int result;
40061
40062   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
40063   jresult = (int)result;
40064   return jresult;
40065 }
40066
40067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_NAME_get() {
40068   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_NAME;
40069 }
40070
40071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_DESCRIPTION_get() {
40072   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_DESCRIPTION;
40073 }
40074
40075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_TRANSLATION_DOMAIN_get() {
40076   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_TRANSLATION_DOMAIN;
40077 }
40078
40079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_ROLE_get() {
40080   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_ROLE;
40081 }
40082
40083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_HIGHLIGHTABLE_get() {
40084   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE;
40085 }
40086
40087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_ATTRIBUTES_get() {
40088   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_ATTRIBUTES;
40089 }
40090
40091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_HIDDEN_get() {
40092   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_HIDDEN;
40093 }
40094
40095 SWIGEXPORT int SWIGSTDCALL  CSharp_Dali_View_Property_AUTOMATION_ID_get() {
40096   return (int)Dali::Toolkit::DevelControl::Property::AUTOMATION_ID;
40097 }
40098
40099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
40100   void * jresult ;
40101   Dali::Toolkit::Control::Property *result = 0 ;
40102
40103   {
40104     try {
40105       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
40106     } CALL_CATCH_EXCEPTION(0);
40107   }
40108
40109   jresult = (void *)result;
40110   return jresult;
40111 }
40112
40113
40114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
40115   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
40116
40117   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
40118   {
40119     try {
40120       delete arg1;
40121     } CALL_CATCH_EXCEPTION();
40122   }
40123
40124 }
40125
40126
40127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
40128   void * jresult ;
40129   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
40130
40131   {
40132     try {
40133       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
40134     } CALL_CATCH_EXCEPTION(0);
40135   }
40136
40137   jresult = (void *)result;
40138   return jresult;
40139 }
40140
40141
40142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
40143   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
40144
40145   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
40146   {
40147     try {
40148       delete arg1;
40149     } CALL_CATCH_EXCEPTION();
40150   }
40151
40152 }
40153
40154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New_With_Behaviour(int behaviour) {
40155   void * jresult ;
40156   Dali::Toolkit::Control result;
40157
40158   {
40159     try {
40160       result = Dali::Toolkit::Control::New((Dali::Toolkit::Control::ControlBehaviour)behaviour);
40161     } CALL_CATCH_EXCEPTION(0);
40162   }
40163
40164   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
40165   return jresult;
40166 }
40167
40168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
40169   return CSharp_Dali_View_New_With_Behaviour((int)Dali::Toolkit::Control::ControlBehaviour::CONTROL_BEHAVIOUR_DEFAULT);
40170 }
40171
40172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_NewCustom_With_Behaviour(int behaviour) {
40173   void * jresult;
40174   Dali::Toolkit::Control result;
40175
40176   {
40177     try {
40178       result = SlimCustomViewImpl::New((Dali::Toolkit::Internal::Control::ControlBehaviour)behaviour);
40179     } CALL_CATCH_EXCEPTION(0);
40180   }
40181
40182   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
40183   return jresult;
40184 }
40185
40186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_NewCustom() {
40187   return CSharp_Dali_View_NewCustom_With_Behaviour((int)Dali::Toolkit::Internal::Control::ControlBehaviour::CONTROL_BEHAVIOUR_DEFAULT);
40188 }
40189
40190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
40191   void * jresult ;
40192   Dali::Toolkit::Control *result = 0 ;
40193
40194   {
40195     try {
40196       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
40197     } CALL_CATCH_EXCEPTION(0);
40198   }
40199
40200   jresult = (void *)result;
40201   return jresult;
40202 }
40203
40204
40205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
40206   void * jresult ;
40207   Dali::Toolkit::Control *arg1 = 0 ;
40208   Dali::Toolkit::Control *result = 0 ;
40209
40210   arg1 = (Dali::Toolkit::Control *)jarg1;
40211   if (!arg1) {
40212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
40213     return 0;
40214   }
40215   {
40216     try {
40217       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
40218     } CALL_CATCH_EXCEPTION(0);
40219   }
40220
40221   jresult = (void *)result;
40222   return jresult;
40223 }
40224
40225
40226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
40227   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40228
40229   arg1 = (Dali::Toolkit::Control *)jarg1;
40230   {
40231     try {
40232       delete arg1;
40233     } CALL_CATCH_EXCEPTION();
40234   }
40235
40236 }
40237
40238
40239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
40240   void * jresult ;
40241   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40242   Dali::Toolkit::Control *arg2 = 0 ;
40243   Dali::Toolkit::Control *result = 0 ;
40244
40245   arg1 = (Dali::Toolkit::Control *)jarg1;
40246   arg2 = (Dali::Toolkit::Control *)jarg2;
40247   if (!arg2) {
40248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
40249     return 0;
40250   }
40251   {
40252     try {
40253       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
40254     } CALL_CATCH_EXCEPTION(0);
40255   }
40256
40257   jresult = (void *)result;
40258   return jresult;
40259 }
40260
40261
40262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
40263   void * jresult ;
40264   Dali::BaseHandle arg1 ;
40265   Dali::BaseHandle *argp1 ;
40266   Dali::Toolkit::Control result;
40267
40268   argp1 = (Dali::BaseHandle *)jarg1;
40269   if (!argp1) {
40270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40271     return 0;
40272   }
40273   arg1 = *argp1;
40274   {
40275     try {
40276       result = Dali::Toolkit::Control::DownCast(arg1);
40277     } CALL_CATCH_EXCEPTION(0);
40278   }
40279
40280   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
40281   return jresult;
40282 }
40283
40284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Control(void * jarg1) {
40285   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) jarg1;
40286   try {
40287     delete arg1;
40288   } CALL_CATCH_EXCEPTION();
40289 }
40290
40291
40292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
40293   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40294
40295   arg1 = (Dali::Toolkit::Control *)jarg1;
40296   {
40297     try {
40298       (arg1)->SetKeyInputFocus();
40299     } CALL_CATCH_EXCEPTION();
40300   }
40301
40302 }
40303
40304
40305 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
40306   bool jresult ;
40307   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40308   bool result;
40309
40310   arg1 = (Dali::Toolkit::Control *)jarg1;
40311   {
40312     try {
40313       result = (bool)(arg1)->HasKeyInputFocus();
40314     } CALL_CATCH_EXCEPTION(0);
40315   }
40316
40317   jresult = result;
40318   return jresult;
40319 }
40320
40321
40322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
40323   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40324
40325   arg1 = (Dali::Toolkit::Control *)jarg1;
40326   {
40327     try {
40328       (arg1)->ClearKeyInputFocus();
40329     } CALL_CATCH_EXCEPTION();
40330   }
40331
40332 }
40333
40334
40335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
40336   void * jresult ;
40337   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40338   Dali::PinchGestureDetector result;
40339
40340   arg1 = (Dali::Toolkit::Control *)jarg1;
40341   {
40342     try {
40343       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
40344     } CALL_CATCH_EXCEPTION(0);
40345   }
40346
40347   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
40348   return jresult;
40349 }
40350
40351
40352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
40353   void * jresult ;
40354   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40355   Dali::PanGestureDetector result;
40356
40357   arg1 = (Dali::Toolkit::Control *)jarg1;
40358   {
40359     try {
40360       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
40361     } CALL_CATCH_EXCEPTION(0);
40362   }
40363
40364   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40365   return jresult;
40366 }
40367
40368
40369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
40370   void * jresult ;
40371   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40372   Dali::TapGestureDetector result;
40373
40374   arg1 = (Dali::Toolkit::Control *)jarg1;
40375   {
40376     try {
40377       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
40378     } CALL_CATCH_EXCEPTION(0);
40379   }
40380
40381   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
40382   return jresult;
40383 }
40384
40385
40386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
40387   void * jresult ;
40388   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40389   Dali::LongPressGestureDetector result;
40390
40391   arg1 = (Dali::Toolkit::Control *)jarg1;
40392   {
40393     try {
40394       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
40395     } CALL_CATCH_EXCEPTION(0);
40396   }
40397
40398   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
40399   return jresult;
40400 }
40401
40402
40403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
40404   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40405   std::string *arg2 = 0 ;
40406
40407   arg1 = (Dali::Toolkit::Control *)jarg1;
40408   if (!jarg2) {
40409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40410     return ;
40411   }
40412   std::string arg2_str(jarg2);
40413   arg2 = &arg2_str;
40414   {
40415     try {
40416       (arg1)->SetStyleName((std::string const &)*arg2);
40417     } CALL_CATCH_EXCEPTION();
40418   }
40419
40420
40421   //argout typemap for const std::string&
40422
40423 }
40424
40425
40426 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
40427   char * jresult ;
40428   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40429   std::string *result = 0 ;
40430
40431   arg1 = (Dali::Toolkit::Control *)jarg1;
40432   {
40433     try {
40434       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
40435     } CALL_CATCH_EXCEPTION(0);
40436   }
40437
40438   jresult = SWIG_csharp_string_callback(result->c_str());
40439   return jresult;
40440 }
40441
40442
40443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
40444   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40445   Dali::Vector4 *arg2 = 0 ;
40446
40447   arg1 = (Dali::Toolkit::Control *)jarg1;
40448   arg2 = (Dali::Vector4 *)jarg2;
40449   if (!arg2) {
40450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
40451     return ;
40452   }
40453   {
40454     try {
40455       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
40456     } CALL_CATCH_EXCEPTION();
40457   }
40458
40459 }
40460
40461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
40462   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40463
40464   arg1 = (Dali::Toolkit::Control *)jarg1;
40465   {
40466     try {
40467       (arg1)->ClearBackground();
40468     } CALL_CATCH_EXCEPTION();
40469   }
40470
40471 }
40472
40473
40474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
40475   void * jresult ;
40476   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40477   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
40478
40479   arg1 = (Dali::Toolkit::Control *)jarg1;
40480   {
40481     try {
40482       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
40483     } CALL_CATCH_EXCEPTION(0);
40484   }
40485
40486   jresult = (void *)result;
40487   return jresult;
40488 }
40489
40490
40491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
40492   void * jresult ;
40493   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40494   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
40495
40496   arg1 = (Dali::Toolkit::Control *)jarg1;
40497   {
40498     try {
40499       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
40500     } CALL_CATCH_EXCEPTION(0);
40501   }
40502
40503   jresult = (void *)result;
40504   return jresult;
40505 }
40506
40507
40508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
40509   void * jresult ;
40510   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40511   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
40512
40513   arg1 = (Dali::Toolkit::Control *)jarg1;
40514   {
40515     try {
40516       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
40517     } CALL_CATCH_EXCEPTION(0);
40518   }
40519
40520   jresult = (void *)result;
40521   return jresult;
40522 }
40523
40524
40525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
40526   void * jresult ;
40527   Dali::Toolkit::Internal::Control *arg1 = 0 ;
40528   Dali::Toolkit::Control *result = 0 ;
40529
40530   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
40531   if (!arg1) {
40532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
40533     return 0;
40534   }
40535   {
40536     try {
40537       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
40538     } CALL_CATCH_EXCEPTION(0);
40539   }
40540
40541   jresult = (void *)result;
40542   return jresult;
40543 }
40544
40545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
40546 {
40547   int jresult;
40548   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40549   arg1 = (Dali::Toolkit::Control *)jarg1;
40550
40551   if (!arg1) {
40552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
40553     return 0;
40554   }
40555
40556   Dali::Property::Index arg2 = 0 ;
40557   arg2 = (Dali::Property::Index)jarg2;
40558
40559   Toolkit::Visual::ResourceStatus result;
40560   {
40561     try {
40562       result = arg1->GetVisualResourceStatus(arg2);
40563     } CALL_CATCH_EXCEPTION(0);
40564   }
40565
40566   jresult = (int)result;
40567   return jresult;
40568 }
40569
40570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
40571 {
40572   void * jresult;
40573   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40574   arg1 = (Dali::Toolkit::Control *)jarg1;
40575
40576   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
40577
40578   Dali::Toolkit::TransitionData *arg2 = 0 ;
40579   Dali::Animation result;
40580
40581   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
40582   if (!arg2) {
40583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
40584     return 0;
40585   }
40586   {
40587     try {
40588       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
40589     } CALL_CATCH_EXCEPTION(0);
40590   }
40591
40592   jresult = new Dali::Animation((const Dali::Animation &)result);
40593   return jresult;
40594 }
40595
40596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
40597 {
40598   Dali::Toolkit::Control arg1;
40599   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
40600
40601   if (!argp1) {
40602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
40603   }
40604   arg1 = *argp1;
40605
40606   Dali::Property::Index arg2 = 0 ;
40607   arg2 = (Dali::Property::Index)jarg2;
40608
40609   Dali::Property::Index arg3 = 0 ;
40610   arg3 = (Dali::Property::Index)jarg3;
40611
40612   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
40613
40614   {
40615     try {
40616       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
40617     } CALL_CATCH_EXCEPTION();
40618   }
40619 }
40620
40621 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_View_GetVisualProperty(void* control, int propertyIndex, int visualPropertyIndex)
40622 {
40623   if (!control)
40624   {
40625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Given control is null", 0);
40626     return 0;
40627   }
40628
40629   void* result = 0;
40630   try
40631   {
40632     Dali::Property property = DevelControl::GetVisualProperty(*((Dali::Toolkit::Control*)control), (Dali::Property::Index)propertyIndex, (Dali::Property::Index)visualPropertyIndex);
40633     result = new Dali::Property(property.object, property.propertyIndex, property.componentIndex);
40634   }
40635   CALL_CATCH_EXCEPTION(0);
40636
40637   return result;
40638 }
40639
40640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
40641   void * jresult ;
40642   Dali::Toolkit::Control *arg1 = 0 ;
40643   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
40644
40645   arg1 = (Dali::Toolkit::Control *)jarg1;
40646   if (!arg1) {
40647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
40648     return 0;
40649   }
40650   {
40651     try {
40652       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
40653     } CALL_CATCH_EXCEPTION(0);
40654   }
40655
40656   jresult = (void *)result;
40657   return jresult;
40658 }
40659
40660
40661 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
40662   bool jresult ;
40663   Dali::Toolkit::Control *arg1 = 0 ;
40664   bool result;
40665
40666   arg1 = (Dali::Toolkit::Control *)jarg1;
40667   if (!arg1) {
40668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
40669     return 0;
40670   }
40671   {
40672     try {
40673       result = (bool)arg1->IsResourceReady();
40674     } CALL_CATCH_EXCEPTION(0);
40675   }
40676
40677   jresult = result;
40678   return jresult;
40679 }
40680
40681
40682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
40683   void * jresult ;
40684   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
40685
40686   {
40687     try {
40688       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
40689     } CALL_CATCH_EXCEPTION(0);
40690   }
40691
40692   jresult = (void *)result;
40693   return jresult;
40694 }
40695
40696
40697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
40698   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
40699
40700   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
40701   {
40702     try {
40703       delete arg1;
40704     } CALL_CATCH_EXCEPTION();
40705   }
40706
40707 }
40708
40709
40710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
40711   void * jresult ;
40712   Dali::Toolkit::KeyInputFocusManager result;
40713
40714   {
40715     try {
40716       result = Dali::Toolkit::KeyInputFocusManager::Get();
40717     } CALL_CATCH_EXCEPTION(0);
40718   }
40719
40720   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
40721   return jresult;
40722 }
40723
40724
40725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
40726   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
40727   Dali::Toolkit::Control arg2 ;
40728   Dali::Toolkit::Control *argp2 ;
40729
40730   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
40731   argp2 = (Dali::Toolkit::Control *)jarg2;
40732   if (!argp2) {
40733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
40734     return ;
40735   }
40736   arg2 = *argp2;
40737   {
40738     try {
40739       (arg1)->SetFocus(arg2);
40740     } CALL_CATCH_EXCEPTION();
40741   }
40742
40743 }
40744
40745
40746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
40747   void * jresult ;
40748   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
40749   Dali::Toolkit::Control result;
40750
40751   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
40752   {
40753     try {
40754       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
40755     } CALL_CATCH_EXCEPTION(0);
40756   }
40757
40758   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
40759   return jresult;
40760 }
40761
40762
40763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
40764   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
40765   Dali::Toolkit::Control arg2 ;
40766   Dali::Toolkit::Control *argp2 ;
40767
40768   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
40769   argp2 = (Dali::Toolkit::Control *)jarg2;
40770   if (!argp2) {
40771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
40772     return ;
40773   }
40774   arg2 = *argp2;
40775   {
40776     try {
40777       (arg1)->RemoveFocus(arg2);
40778     } CALL_CATCH_EXCEPTION();
40779   }
40780
40781 }
40782
40783
40784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
40785   void * jresult ;
40786   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
40787   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
40788
40789   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
40790   {
40791     try {
40792       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
40793     } CALL_CATCH_EXCEPTION(0);
40794   }
40795
40796   jresult = (void *)result;
40797   return jresult;
40798 }
40799
40800
40801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
40802   void * jresult ;
40803   Dali::Toolkit::Alignment::Padding *result = 0 ;
40804
40805   {
40806     try {
40807       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
40808     } CALL_CATCH_EXCEPTION(0);
40809   }
40810
40811   jresult = (void *)result;
40812   return jresult;
40813 }
40814
40815
40816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
40817   void * jresult ;
40818   float arg1 ;
40819   float arg2 ;
40820   float arg3 ;
40821   float arg4 ;
40822   Dali::Toolkit::Alignment::Padding *result = 0 ;
40823
40824   arg1 = (float)jarg1;
40825   arg2 = (float)jarg2;
40826   arg3 = (float)jarg3;
40827   arg4 = (float)jarg4;
40828   {
40829     try {
40830       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
40831     } CALL_CATCH_EXCEPTION(0);
40832   }
40833
40834   jresult = (void *)result;
40835   return jresult;
40836 }
40837
40838
40839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
40840   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
40841   float arg2 ;
40842
40843   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
40844   arg2 = (float)jarg2;
40845   if (arg1) (arg1)->left = arg2;
40846 }
40847
40848
40849 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
40850   float jresult ;
40851   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
40852   float result;
40853
40854   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
40855   result = (float) ((arg1)->left);
40856   jresult = result;
40857   return jresult;
40858 }
40859
40860
40861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
40862   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
40863   float arg2 ;
40864
40865   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
40866   arg2 = (float)jarg2;
40867   if (arg1) (arg1)->right = arg2;
40868 }
40869
40870
40871 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
40872   float jresult ;
40873   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
40874   float result;
40875
40876   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
40877   result = (float) ((arg1)->right);
40878   jresult = result;
40879   return jresult;
40880 }
40881
40882
40883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
40884   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
40885   float arg2 ;
40886
40887   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
40888   arg2 = (float)jarg2;
40889   if (arg1) (arg1)->top = arg2;
40890 }
40891
40892
40893 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
40894   float jresult ;
40895   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
40896   float result;
40897
40898   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
40899   result = (float) ((arg1)->top);
40900   jresult = result;
40901   return jresult;
40902 }
40903
40904
40905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
40906   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
40907   float arg2 ;
40908
40909   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
40910   arg2 = (float)jarg2;
40911   if (arg1) (arg1)->bottom = arg2;
40912 }
40913
40914
40915 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
40916   float jresult ;
40917   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
40918   float result;
40919
40920   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
40921   result = (float) ((arg1)->bottom);
40922   jresult = result;
40923   return jresult;
40924 }
40925
40926
40927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
40928   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
40929
40930   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
40931   {
40932     try {
40933       delete arg1;
40934     } CALL_CATCH_EXCEPTION();
40935   }
40936
40937 }
40938
40939
40940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
40941   void * jresult ;
40942   Dali::Toolkit::Alignment *result = 0 ;
40943
40944   {
40945     try {
40946       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
40947     } CALL_CATCH_EXCEPTION(0);
40948   }
40949
40950   jresult = (void *)result;
40951   return jresult;
40952 }
40953
40954
40955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
40956   void * jresult ;
40957   Dali::Toolkit::Alignment::Type arg1 ;
40958   Dali::Toolkit::Alignment::Type arg2 ;
40959   Dali::Toolkit::Alignment result;
40960
40961   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
40962   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
40963   {
40964     try {
40965       result = Dali::Toolkit::Alignment::New(arg1,arg2);
40966     } CALL_CATCH_EXCEPTION(0);
40967   }
40968
40969   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
40970   return jresult;
40971 }
40972
40973
40974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
40975   void * jresult ;
40976   Dali::Toolkit::Alignment::Type arg1 ;
40977   Dali::Toolkit::Alignment result;
40978
40979   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
40980   {
40981     try {
40982       result = Dali::Toolkit::Alignment::New(arg1);
40983     } CALL_CATCH_EXCEPTION(0);
40984   }
40985
40986   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
40987   return jresult;
40988 }
40989
40990
40991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
40992   void * jresult ;
40993   Dali::Toolkit::Alignment result;
40994
40995   {
40996     try {
40997       result = Dali::Toolkit::Alignment::New();
40998     } CALL_CATCH_EXCEPTION(0);
40999   }
41000
41001   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
41002   return jresult;
41003 }
41004
41005
41006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
41007   void * jresult ;
41008   Dali::Toolkit::Alignment *arg1 = 0 ;
41009   Dali::Toolkit::Alignment *result = 0 ;
41010
41011   arg1 = (Dali::Toolkit::Alignment *)jarg1;
41012   if (!arg1) {
41013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
41014     return 0;
41015   }
41016   {
41017     try {
41018       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
41019     } CALL_CATCH_EXCEPTION(0);
41020   }
41021
41022   jresult = (void *)result;
41023   return jresult;
41024 }
41025
41026
41027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
41028   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
41029
41030   arg1 = (Dali::Toolkit::Alignment *)jarg1;
41031   {
41032     try {
41033       delete arg1;
41034     } CALL_CATCH_EXCEPTION();
41035   }
41036
41037 }
41038
41039
41040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
41041   void * jresult ;
41042   Dali::BaseHandle arg1 ;
41043   Dali::BaseHandle *argp1 ;
41044   Dali::Toolkit::Alignment result;
41045
41046   argp1 = (Dali::BaseHandle *)jarg1;
41047   if (!argp1) {
41048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41049     return 0;
41050   }
41051   arg1 = *argp1;
41052   {
41053     try {
41054       result = Dali::Toolkit::Alignment::DownCast(arg1);
41055     } CALL_CATCH_EXCEPTION(0);
41056   }
41057
41058   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
41059   return jresult;
41060 }
41061
41062
41063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
41064   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
41065   Dali::Toolkit::Alignment::Type arg2 ;
41066
41067   arg1 = (Dali::Toolkit::Alignment *)jarg1;
41068   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
41069   {
41070     try {
41071       (arg1)->SetAlignmentType(arg2);
41072     } CALL_CATCH_EXCEPTION();
41073   }
41074
41075 }
41076
41077
41078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
41079   int jresult ;
41080   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
41081   Dali::Toolkit::Alignment::Type result;
41082
41083   arg1 = (Dali::Toolkit::Alignment *)jarg1;
41084   {
41085     try {
41086       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
41087     } CALL_CATCH_EXCEPTION(0);
41088   }
41089
41090   jresult = (int)result;
41091   return jresult;
41092 }
41093
41094
41095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
41096   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
41097   Dali::Toolkit::Alignment::Scaling arg2 ;
41098
41099   arg1 = (Dali::Toolkit::Alignment *)jarg1;
41100   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
41101   {
41102     try {
41103       (arg1)->SetScaling(arg2);
41104     } CALL_CATCH_EXCEPTION();
41105   }
41106
41107 }
41108
41109
41110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
41111   int jresult ;
41112   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
41113   Dali::Toolkit::Alignment::Scaling result;
41114
41115   arg1 = (Dali::Toolkit::Alignment *)jarg1;
41116   {
41117     try {
41118       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
41119     } CALL_CATCH_EXCEPTION(0);
41120   }
41121
41122   jresult = (int)result;
41123   return jresult;
41124 }
41125
41126
41127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
41128   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
41129   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
41130
41131   arg1 = (Dali::Toolkit::Alignment *)jarg1;
41132   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
41133   if (!arg2) {
41134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
41135     return ;
41136   }
41137   {
41138     try {
41139       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
41140     } CALL_CATCH_EXCEPTION();
41141   }
41142
41143 }
41144
41145
41146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
41147   void * jresult ;
41148   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
41149   Dali::Toolkit::Alignment::Padding *result = 0 ;
41150
41151   arg1 = (Dali::Toolkit::Alignment *)jarg1;
41152   {
41153     try {
41154       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
41155     } CALL_CATCH_EXCEPTION(0);
41156   }
41157
41158   jresult = (void *)result;
41159   return jresult;
41160 }
41161
41162
41163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
41164   void * jresult ;
41165   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
41166   Dali::Toolkit::Alignment *arg2 = 0 ;
41167   Dali::Toolkit::Alignment *result = 0 ;
41168
41169   arg1 = (Dali::Toolkit::Alignment *)jarg1;
41170   arg2 = (Dali::Toolkit::Alignment *)jarg2;
41171   if (!arg2) {
41172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
41173     return 0;
41174   }
41175   {
41176     try {
41177       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
41178     } CALL_CATCH_EXCEPTION(0);
41179   }
41180
41181   jresult = (void *)result;
41182   return jresult;
41183 }
41184
41185
41186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
41187   int jresult ;
41188   int result;
41189
41190   result = (int)Dali::Toolkit::Button::Property::DISABLED;
41191   jresult = (int)result;
41192   return jresult;
41193 }
41194
41195
41196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
41197   int jresult ;
41198   int result;
41199
41200   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
41201   jresult = (int)result;
41202   return jresult;
41203 }
41204
41205
41206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
41207   int jresult ;
41208   int result;
41209
41210   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
41211   jresult = (int)result;
41212   return jresult;
41213 }
41214
41215
41216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
41217   int jresult ;
41218   int result;
41219
41220   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
41221   jresult = (int)result;
41222   return jresult;
41223 }
41224
41225
41226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
41227   int jresult ;
41228   int result;
41229
41230   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
41231   jresult = (int)result;
41232   return jresult;
41233 }
41234
41235
41236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
41237   int jresult ;
41238   int result;
41239
41240   result = (int)Dali::Toolkit::Button::Property::SELECTED;
41241   jresult = (int)result;
41242   return jresult;
41243 }
41244
41245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
41246   int jresult ;
41247   int result;
41248
41249   result = (int)Dali::Toolkit::Button::Property::LABEL;
41250   jresult = (int)result;
41251   return jresult;
41252 }
41253
41254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
41255   void * jresult ;
41256   Dali::Toolkit::Button::Property *result = 0 ;
41257
41258   {
41259     try {
41260       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
41261     } CALL_CATCH_EXCEPTION(0);
41262   }
41263
41264   jresult = (void *)result;
41265   return jresult;
41266 }
41267
41268
41269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
41270   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
41271
41272   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
41273   {
41274     try {
41275       delete arg1;
41276     } CALL_CATCH_EXCEPTION();
41277   }
41278
41279 }
41280
41281
41282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
41283   void * jresult ;
41284   Dali::Toolkit::Button *result = 0 ;
41285
41286   {
41287     try {
41288       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
41289     } CALL_CATCH_EXCEPTION(0);
41290   }
41291
41292   jresult = (void *)result;
41293   return jresult;
41294 }
41295
41296
41297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
41298   void * jresult ;
41299   Dali::Toolkit::Button *arg1 = 0 ;
41300   Dali::Toolkit::Button *result = 0 ;
41301
41302   arg1 = (Dali::Toolkit::Button *)jarg1;
41303   if (!arg1) {
41304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
41305     return 0;
41306   }
41307   {
41308     try {
41309       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
41310     } CALL_CATCH_EXCEPTION(0);
41311   }
41312
41313   jresult = (void *)result;
41314   return jresult;
41315 }
41316
41317
41318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
41319   void * jresult ;
41320   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
41321   Dali::Toolkit::Button *arg2 = 0 ;
41322   Dali::Toolkit::Button *result = 0 ;
41323
41324   arg1 = (Dali::Toolkit::Button *)jarg1;
41325   arg2 = (Dali::Toolkit::Button *)jarg2;
41326   if (!arg2) {
41327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
41328     return 0;
41329   }
41330   {
41331     try {
41332       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
41333     } CALL_CATCH_EXCEPTION(0);
41334   }
41335
41336   jresult = (void *)result;
41337   return jresult;
41338 }
41339
41340
41341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
41342   void * jresult ;
41343   Dali::BaseHandle arg1 ;
41344   Dali::BaseHandle *argp1 ;
41345   Dali::Toolkit::Button result;
41346
41347   argp1 = (Dali::BaseHandle *)jarg1;
41348   if (!argp1) {
41349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41350     return 0;
41351   }
41352   arg1 = *argp1;
41353   {
41354     try {
41355       result = Dali::Toolkit::Button::DownCast(arg1);
41356     } CALL_CATCH_EXCEPTION(0);
41357   }
41358
41359   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
41360   return jresult;
41361 }
41362
41363
41364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
41365   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
41366
41367   arg1 = (Dali::Toolkit::Button *)jarg1;
41368   {
41369     try {
41370       delete arg1;
41371     } CALL_CATCH_EXCEPTION();
41372   }
41373
41374 }
41375
41376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
41377   void * jresult ;
41378   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
41379   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
41380
41381   arg1 = (Dali::Toolkit::Button *)jarg1;
41382   {
41383     try {
41384       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
41385     } CALL_CATCH_EXCEPTION(0);
41386   }
41387
41388   jresult = (void *)result;
41389   return jresult;
41390 }
41391
41392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
41393   void * jresult ;
41394   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
41395   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
41396
41397   arg1 = (Dali::Toolkit::Button *)jarg1;
41398   {
41399     try {
41400       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
41401     } CALL_CATCH_EXCEPTION(0);
41402   }
41403
41404   jresult = (void *)result;
41405   return jresult;
41406 }
41407
41408
41409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
41410   void * jresult ;
41411   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
41412   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
41413
41414   arg1 = (Dali::Toolkit::Button *)jarg1;
41415   {
41416     try {
41417       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
41418     } CALL_CATCH_EXCEPTION(0);
41419   }
41420
41421   jresult = (void *)result;
41422   return jresult;
41423 }
41424
41425
41426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
41427   void * jresult ;
41428   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
41429   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
41430
41431   arg1 = (Dali::Toolkit::Button *)jarg1;
41432   {
41433     try {
41434       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
41435     } CALL_CATCH_EXCEPTION(0);
41436   }
41437
41438   jresult = (void *)result;
41439   return jresult;
41440 }
41441
41442
41443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
41444   void * jresult ;
41445   Dali::Toolkit::CheckBoxButton *result = 0 ;
41446
41447   {
41448     try {
41449       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
41450     } CALL_CATCH_EXCEPTION(0);
41451   }
41452
41453   jresult = (void *)result;
41454   return jresult;
41455 }
41456
41457
41458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
41459   void * jresult ;
41460   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
41461   Dali::Toolkit::CheckBoxButton *result = 0 ;
41462
41463   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
41464   if (!arg1) {
41465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
41466     return 0;
41467   }
41468   {
41469     try {
41470       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
41471     } CALL_CATCH_EXCEPTION(0);
41472   }
41473
41474   jresult = (void *)result;
41475   return jresult;
41476 }
41477
41478
41479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
41480   void * jresult ;
41481   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
41482   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
41483   Dali::Toolkit::CheckBoxButton *result = 0 ;
41484
41485   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
41486   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
41487   if (!arg2) {
41488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
41489     return 0;
41490   }
41491   {
41492     try {
41493       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
41494     } CALL_CATCH_EXCEPTION(0);
41495   }
41496
41497   jresult = (void *)result;
41498   return jresult;
41499 }
41500
41501
41502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
41503   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
41504
41505   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
41506   {
41507     try {
41508       delete arg1;
41509     } CALL_CATCH_EXCEPTION();
41510   }
41511
41512 }
41513
41514
41515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
41516   void * jresult ;
41517   Dali::Toolkit::CheckBoxButton result;
41518
41519   {
41520     try {
41521       result = Dali::Toolkit::CheckBoxButton::New();
41522     } CALL_CATCH_EXCEPTION(0);
41523   }
41524
41525   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
41526   return jresult;
41527 }
41528
41529
41530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
41531   void * jresult ;
41532   Dali::BaseHandle arg1 ;
41533   Dali::BaseHandle *argp1 ;
41534   Dali::Toolkit::CheckBoxButton result;
41535
41536   argp1 = (Dali::BaseHandle *)jarg1;
41537   if (!argp1) {
41538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41539     return 0;
41540   }
41541   arg1 = *argp1;
41542   {
41543     try {
41544       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
41545     } CALL_CATCH_EXCEPTION(0);
41546   }
41547
41548   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
41549   return jresult;
41550 }
41551
41552
41553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
41554   int jresult ;
41555   int result;
41556
41557   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
41558   jresult = (int)result;
41559   return jresult;
41560 }
41561
41562
41563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
41564   int jresult ;
41565   int result;
41566
41567   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
41568   jresult = (int)result;
41569   return jresult;
41570 }
41571
41572
41573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
41574   void * jresult ;
41575   Dali::Toolkit::PushButton::Property *result = 0 ;
41576
41577   {
41578     try {
41579       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
41580     } CALL_CATCH_EXCEPTION(0);
41581   }
41582
41583   jresult = (void *)result;
41584   return jresult;
41585 }
41586
41587
41588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
41589   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
41590
41591   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
41592   {
41593     try {
41594       delete arg1;
41595     } CALL_CATCH_EXCEPTION();
41596   }
41597
41598 }
41599
41600
41601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
41602   void * jresult ;
41603   Dali::Toolkit::PushButton *result = 0 ;
41604
41605   {
41606     try {
41607       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
41608     } CALL_CATCH_EXCEPTION(0);
41609   }
41610
41611   jresult = (void *)result;
41612   return jresult;
41613 }
41614
41615
41616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
41617   void * jresult ;
41618   Dali::Toolkit::PushButton *arg1 = 0 ;
41619   Dali::Toolkit::PushButton *result = 0 ;
41620
41621   arg1 = (Dali::Toolkit::PushButton *)jarg1;
41622   if (!arg1) {
41623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
41624     return 0;
41625   }
41626   {
41627     try {
41628       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
41629     } CALL_CATCH_EXCEPTION(0);
41630   }
41631
41632   jresult = (void *)result;
41633   return jresult;
41634 }
41635
41636
41637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
41638   void * jresult ;
41639   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
41640   Dali::Toolkit::PushButton *arg2 = 0 ;
41641   Dali::Toolkit::PushButton *result = 0 ;
41642
41643   arg1 = (Dali::Toolkit::PushButton *)jarg1;
41644   arg2 = (Dali::Toolkit::PushButton *)jarg2;
41645   if (!arg2) {
41646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
41647     return 0;
41648   }
41649   {
41650     try {
41651       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
41652     } CALL_CATCH_EXCEPTION(0);
41653   }
41654
41655   jresult = (void *)result;
41656   return jresult;
41657 }
41658
41659
41660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
41661   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
41662
41663   arg1 = (Dali::Toolkit::PushButton *)jarg1;
41664   {
41665     try {
41666       delete arg1;
41667     } CALL_CATCH_EXCEPTION();
41668   }
41669
41670 }
41671
41672
41673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
41674   void * jresult ;
41675   Dali::Toolkit::PushButton result;
41676
41677   {
41678     try {
41679       result = Dali::Toolkit::PushButton::New();
41680     } CALL_CATCH_EXCEPTION(0);
41681   }
41682
41683   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
41684   return jresult;
41685 }
41686
41687
41688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
41689   void * jresult ;
41690   Dali::BaseHandle arg1 ;
41691   Dali::BaseHandle *argp1 ;
41692   Dali::Toolkit::PushButton result;
41693
41694   argp1 = (Dali::BaseHandle *)jarg1;
41695   if (!argp1) {
41696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41697     return 0;
41698   }
41699   arg1 = *argp1;
41700   {
41701     try {
41702       result = Dali::Toolkit::PushButton::DownCast(arg1);
41703     } CALL_CATCH_EXCEPTION(0);
41704   }
41705
41706   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
41707   return jresult;
41708 }
41709
41710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
41711   void * jresult ;
41712   Dali::Toolkit::RadioButton *result = 0 ;
41713
41714   {
41715     try {
41716       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
41717     } CALL_CATCH_EXCEPTION(0);
41718   }
41719
41720   jresult = (void *)result;
41721   return jresult;
41722 }
41723
41724
41725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
41726   void * jresult ;
41727   Dali::Toolkit::RadioButton *arg1 = 0 ;
41728   Dali::Toolkit::RadioButton *result = 0 ;
41729
41730   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
41731   if (!arg1) {
41732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
41733     return 0;
41734   }
41735   {
41736     try {
41737       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
41738     } CALL_CATCH_EXCEPTION(0);
41739   }
41740
41741   jresult = (void *)result;
41742   return jresult;
41743 }
41744
41745
41746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
41747   void * jresult ;
41748   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
41749   Dali::Toolkit::RadioButton *arg2 = 0 ;
41750   Dali::Toolkit::RadioButton *result = 0 ;
41751
41752   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
41753   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
41754   if (!arg2) {
41755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
41756     return 0;
41757   }
41758   {
41759     try {
41760       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
41761     } CALL_CATCH_EXCEPTION(0);
41762   }
41763
41764   jresult = (void *)result;
41765   return jresult;
41766 }
41767
41768
41769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
41770   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
41771
41772   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
41773   {
41774     try {
41775       delete arg1;
41776     } CALL_CATCH_EXCEPTION();
41777   }
41778
41779 }
41780
41781
41782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
41783   void * jresult ;
41784   Dali::Toolkit::RadioButton result;
41785
41786   {
41787     try {
41788       result = Dali::Toolkit::RadioButton::New();
41789     } CALL_CATCH_EXCEPTION(0);
41790   }
41791
41792   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
41793   return jresult;
41794 }
41795
41796
41797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
41798   void * jresult ;
41799   std::string *arg1 = 0 ;
41800   Dali::Toolkit::RadioButton result;
41801
41802   if (!jarg1) {
41803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
41804     return 0;
41805   }
41806   std::string arg1_str(jarg1);
41807   arg1 = &arg1_str;
41808   {
41809     try {
41810       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
41811     } CALL_CATCH_EXCEPTION(0);
41812   }
41813
41814   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
41815
41816   //argout typemap for const std::string&
41817
41818   return jresult;
41819 }
41820
41821
41822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
41823   void * jresult ;
41824   Dali::BaseHandle arg1 ;
41825   Dali::BaseHandle *argp1 ;
41826   Dali::Toolkit::RadioButton result;
41827
41828   argp1 = (Dali::BaseHandle *)jarg1;
41829   if (!argp1) {
41830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41831     return 0;
41832   }
41833   arg1 = *argp1;
41834   {
41835     try {
41836       result = Dali::Toolkit::RadioButton::DownCast(arg1);
41837     } CALL_CATCH_EXCEPTION(0);
41838   }
41839
41840   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
41841   return jresult;
41842 }
41843
41844
41845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
41846   int jresult ;
41847   int result;
41848
41849   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
41850   jresult = (int)result;
41851   return jresult;
41852 }
41853
41854
41855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
41856   int jresult ;
41857   int result;
41858
41859   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
41860   jresult = (int)result;
41861   return jresult;
41862 }
41863
41864
41865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
41866   int jresult ;
41867   int result;
41868
41869   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
41870   jresult = (int)result;
41871   return jresult;
41872 }
41873
41874
41875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
41876   int jresult ;
41877   int result;
41878
41879   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
41880   jresult = (int)result;
41881   return jresult;
41882 }
41883
41884
41885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
41886   int jresult ;
41887   int result;
41888
41889   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
41890   jresult = (int)result;
41891   return jresult;
41892 }
41893
41894
41895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
41896   int jresult ;
41897   int result;
41898
41899   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
41900   jresult = (int)result;
41901   return jresult;
41902 }
41903
41904
41905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
41906   void * jresult ;
41907   Dali::Toolkit::FlexContainer::Property *result = 0 ;
41908
41909   {
41910     try {
41911       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
41912     } CALL_CATCH_EXCEPTION(0);
41913   }
41914
41915   jresult = (void *)result;
41916   return jresult;
41917 }
41918
41919
41920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
41921   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
41922
41923   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
41924   {
41925     try {
41926       delete arg1;
41927     } CALL_CATCH_EXCEPTION();
41928   }
41929
41930 }
41931
41932
41933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
41934   int jresult ;
41935   int result;
41936
41937   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
41938   jresult = (int)result;
41939   return jresult;
41940 }
41941
41942
41943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
41944   int jresult ;
41945   int result;
41946
41947   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
41948   jresult = (int)result;
41949   return jresult;
41950 }
41951
41952
41953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
41954   int jresult ;
41955   int result;
41956
41957   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
41958   jresult = (int)result;
41959   return jresult;
41960 }
41961
41962
41963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
41964   void * jresult ;
41965   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
41966
41967   {
41968     try {
41969       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
41970     } CALL_CATCH_EXCEPTION(0);
41971   }
41972
41973   jresult = (void *)result;
41974   return jresult;
41975 }
41976
41977
41978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
41979   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
41980
41981   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
41982   {
41983     try {
41984       delete arg1;
41985     } CALL_CATCH_EXCEPTION();
41986   }
41987
41988 }
41989
41990
41991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
41992   void * jresult ;
41993   Dali::Toolkit::FlexContainer *result = 0 ;
41994
41995   {
41996     try {
41997       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
41998     } CALL_CATCH_EXCEPTION(0);
41999   }
42000
42001   jresult = (void *)result;
42002   return jresult;
42003 }
42004
42005
42006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
42007   void * jresult ;
42008   Dali::Toolkit::FlexContainer *arg1 = 0 ;
42009   Dali::Toolkit::FlexContainer *result = 0 ;
42010
42011   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
42012   if (!arg1) {
42013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
42014     return 0;
42015   }
42016   {
42017     try {
42018       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
42019     } CALL_CATCH_EXCEPTION(0);
42020   }
42021
42022   jresult = (void *)result;
42023   return jresult;
42024 }
42025
42026
42027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
42028   void * jresult ;
42029   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
42030   Dali::Toolkit::FlexContainer *arg2 = 0 ;
42031   Dali::Toolkit::FlexContainer *result = 0 ;
42032
42033   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
42034   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
42035   if (!arg2) {
42036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
42037     return 0;
42038   }
42039   {
42040     try {
42041       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
42042     } CALL_CATCH_EXCEPTION(0);
42043   }
42044
42045   jresult = (void *)result;
42046   return jresult;
42047 }
42048
42049
42050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
42051   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
42052
42053   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
42054   {
42055     try {
42056       delete arg1;
42057     } CALL_CATCH_EXCEPTION();
42058   }
42059
42060 }
42061
42062
42063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
42064   void * jresult ;
42065   Dali::Toolkit::FlexContainer result;
42066
42067   {
42068     try {
42069       result = Dali::Toolkit::FlexContainer::New();
42070     } CALL_CATCH_EXCEPTION(0);
42071   }
42072
42073   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
42074   return jresult;
42075 }
42076
42077
42078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
42079   void * jresult ;
42080   Dali::BaseHandle arg1 ;
42081   Dali::BaseHandle *argp1 ;
42082   Dali::Toolkit::FlexContainer result;
42083
42084   argp1 = (Dali::BaseHandle *)jarg1;
42085   if (!argp1) {
42086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42087     return 0;
42088   }
42089   arg1 = *argp1;
42090   {
42091     try {
42092       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
42093     } CALL_CATCH_EXCEPTION(0);
42094   }
42095
42096   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
42097   return jresult;
42098 }
42099
42100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
42101   int jresult ;
42102   int result;
42103
42104   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
42105   jresult = (int)result;
42106   return jresult;
42107 }
42108
42109
42110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
42111   int jresult ;
42112   int result;
42113
42114   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
42115   jresult = (int)result;
42116   return jresult;
42117 }
42118
42119
42120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
42121   int jresult ;
42122   int result;
42123
42124   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
42125   jresult = (int)result;
42126   return jresult;
42127 }
42128
42129
42130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
42131   void * jresult ;
42132   Dali::Toolkit::ImageView::Property *result = 0 ;
42133
42134   {
42135     try {
42136       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
42137     } CALL_CATCH_EXCEPTION(0);
42138   }
42139
42140   jresult = (void *)result;
42141   return jresult;
42142 }
42143
42144
42145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
42146   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
42147
42148   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
42149   {
42150     try {
42151       delete arg1;
42152     } CALL_CATCH_EXCEPTION();
42153   }
42154
42155 }
42156
42157
42158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
42159   void * jresult ;
42160   Dali::Toolkit::ImageView *result = 0 ;
42161
42162   {
42163     try {
42164       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
42165     } CALL_CATCH_EXCEPTION(0);
42166   }
42167
42168   jresult = (void *)result;
42169   return jresult;
42170 }
42171
42172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0_With_Behaviour(int behaviour) {
42173   void * jresult ;
42174   Dali::Toolkit::ImageView result;
42175
42176   {
42177     try {
42178       result = Dali::Toolkit::ImageView::New((Dali::Toolkit::Control::ControlBehaviour)behaviour);
42179     } CALL_CATCH_EXCEPTION(0);
42180   }
42181
42182   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
42183   return jresult;
42184 }
42185
42186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
42187   return CSharp_Dali_ImageView_New__SWIG_0_With_Behaviour((int)Dali::Toolkit::Control::ControlBehaviour::CONTROL_BEHAVIOUR_DEFAULT);
42188 }
42189
42190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2_With_Behaviour(int behaviour, char * jarg1) {
42191   void * jresult ;
42192   std::string *arg1 = 0 ;
42193   Dali::Toolkit::ImageView result;
42194
42195   if (!jarg1) {
42196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42197     return 0;
42198   }
42199   std::string arg1_str(jarg1);
42200   arg1 = &arg1_str;
42201   {
42202     try {
42203       result = Dali::Toolkit::ImageView::New((Dali::Toolkit::Control::ControlBehaviour)behaviour, (std::string const &)*arg1);
42204     } CALL_CATCH_EXCEPTION(0);
42205   }
42206
42207   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
42208
42209   //argout typemap for const std::string&
42210
42211   return jresult;
42212 }
42213
42214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
42215   return CSharp_Dali_ImageView_New__SWIG_2_With_Behaviour((int)Dali::Toolkit::Control::ControlBehaviour::CONTROL_BEHAVIOUR_DEFAULT, jarg1);
42216 }
42217
42218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3_With_Behaviour(int behaviour, char * jarg1, void * jarg2) {
42219   void * jresult ;
42220   std::string *arg1 = 0 ;
42221   Dali::ImageDimensions arg2 ;
42222   Dali::ImageDimensions *argp2 ;
42223   Dali::Toolkit::ImageView result;
42224
42225   if (!jarg1) {
42226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42227     return 0;
42228   }
42229   std::string arg1_str(jarg1);
42230   arg1 = &arg1_str;
42231   argp2 = (Dali::ImageDimensions *)jarg2;
42232   if (!argp2) {
42233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42234     return 0;
42235   }
42236   arg2 = *argp2;
42237   {
42238     try {
42239       result = Dali::Toolkit::ImageView::New((Dali::Toolkit::Control::ControlBehaviour)behaviour, (std::string const &)*arg1,arg2);
42240     } CALL_CATCH_EXCEPTION(0);
42241   }
42242
42243   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
42244
42245   //argout typemap for const std::string&
42246
42247   return jresult;
42248 }
42249
42250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
42251   return CSharp_Dali_ImageView_New__SWIG_3_With_Behaviour((int)Dali::Toolkit::Control::ControlBehaviour::CONTROL_BEHAVIOUR_DEFAULT, jarg1, jarg2);
42252 }
42253
42254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
42255   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
42256
42257   arg1 = (Dali::Toolkit::ImageView *)jarg1;
42258   {
42259     try {
42260       delete arg1;
42261     } CALL_CATCH_EXCEPTION();
42262   }
42263
42264 }
42265
42266
42267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
42268   void * jresult ;
42269   Dali::Toolkit::ImageView *arg1 = 0 ;
42270   Dali::Toolkit::ImageView *result = 0 ;
42271
42272   arg1 = (Dali::Toolkit::ImageView *)jarg1;
42273   if (!arg1) {
42274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
42275     return 0;
42276   }
42277   {
42278     try {
42279       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
42280     } CALL_CATCH_EXCEPTION(0);
42281   }
42282
42283   jresult = (void *)result;
42284   return jresult;
42285 }
42286
42287
42288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
42289   void * jresult ;
42290   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
42291   Dali::Toolkit::ImageView *arg2 = 0 ;
42292   Dali::Toolkit::ImageView *result = 0 ;
42293
42294   arg1 = (Dali::Toolkit::ImageView *)jarg1;
42295   arg2 = (Dali::Toolkit::ImageView *)jarg2;
42296   if (!arg2) {
42297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
42298     return 0;
42299   }
42300   {
42301     try {
42302       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
42303     } CALL_CATCH_EXCEPTION(0);
42304   }
42305
42306   jresult = (void *)result;
42307   return jresult;
42308 }
42309
42310
42311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
42312   void * jresult ;
42313   Dali::BaseHandle arg1 ;
42314   Dali::BaseHandle *argp1 ;
42315   Dali::Toolkit::ImageView result;
42316
42317   argp1 = (Dali::BaseHandle *)jarg1;
42318   if (!argp1) {
42319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42320     return 0;
42321   }
42322   arg1 = *argp1;
42323   {
42324     try {
42325       result = Dali::Toolkit::ImageView::DownCast(arg1);
42326     } CALL_CATCH_EXCEPTION(0);
42327   }
42328
42329   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
42330   return jresult;
42331 }
42332
42333
42334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
42335   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
42336   std::string *arg2 = 0 ;
42337
42338   arg1 = (Dali::Toolkit::ImageView *)jarg1;
42339   if (!jarg2) {
42340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42341     return ;
42342   }
42343   std::string arg2_str(jarg2);
42344   arg2 = &arg2_str;
42345   {
42346     try {
42347       (arg1)->SetImage((std::string const &)*arg2);
42348     } CALL_CATCH_EXCEPTION();
42349   }
42350
42351
42352   //argout typemap for const std::string&
42353
42354 }
42355
42356
42357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
42358   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
42359   std::string *arg2 = 0 ;
42360   Dali::ImageDimensions arg3 ;
42361   Dali::ImageDimensions *argp3 ;
42362
42363   arg1 = (Dali::Toolkit::ImageView *)jarg1;
42364   if (!jarg2) {
42365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42366     return ;
42367   }
42368   std::string arg2_str(jarg2);
42369   arg2 = &arg2_str;
42370   argp3 = (Dali::ImageDimensions *)jarg3;
42371   if (!argp3) {
42372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42373     return ;
42374   }
42375   arg3 = *argp3;
42376   {
42377     try {
42378       (arg1)->SetImage((std::string const &)*arg2,arg3);
42379     } CALL_CATCH_EXCEPTION();
42380   }
42381
42382
42383   //argout typemap for const std::string&
42384
42385 }
42386
42387
42388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
42389   int jresult ;
42390   int result;
42391
42392   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
42393   jresult = (int)result;
42394   return jresult;
42395 }
42396
42397
42398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
42399   int jresult ;
42400   int result;
42401
42402   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
42403   jresult = (int)result;
42404   return jresult;
42405 }
42406
42407
42408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
42409   int jresult ;
42410   int result;
42411
42412   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
42413   jresult = (int)result;
42414   return jresult;
42415 }
42416
42417
42418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
42419   int jresult ;
42420   int result;
42421
42422   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
42423   jresult = (int)result;
42424   return jresult;
42425 }
42426
42427
42428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
42429   int jresult ;
42430   int result;
42431
42432   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
42433   jresult = (int)result;
42434   return jresult;
42435 }
42436
42437
42438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
42439   int jresult ;
42440   int result;
42441
42442   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
42443   jresult = (int)result;
42444   return jresult;
42445 }
42446
42447
42448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
42449   int jresult ;
42450   int result;
42451
42452   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
42453   jresult = (int)result;
42454   return jresult;
42455 }
42456
42457
42458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
42459   int jresult ;
42460   int result;
42461
42462   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
42463   jresult = (int)result;
42464   return jresult;
42465 }
42466
42467
42468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
42469   int jresult ;
42470   int result;
42471
42472   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
42473   jresult = (int)result;
42474   return jresult;
42475 }
42476
42477
42478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
42479   void * jresult ;
42480   Dali::Toolkit::ScrollBar::Property *result = 0 ;
42481
42482   {
42483     try {
42484       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
42485     } CALL_CATCH_EXCEPTION(0);
42486   }
42487
42488   jresult = (void *)result;
42489   return jresult;
42490 }
42491
42492
42493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
42494   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
42495
42496   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
42497   {
42498     try {
42499       delete arg1;
42500     } CALL_CATCH_EXCEPTION();
42501   }
42502
42503 }
42504
42505
42506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
42507   void * jresult ;
42508   Dali::Toolkit::ScrollBar *result = 0 ;
42509
42510   {
42511     try {
42512       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
42513     } CALL_CATCH_EXCEPTION(0);
42514   }
42515
42516   jresult = (void *)result;
42517   return jresult;
42518 }
42519
42520
42521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
42522   void * jresult ;
42523   Dali::Toolkit::ScrollBar *arg1 = 0 ;
42524   Dali::Toolkit::ScrollBar *result = 0 ;
42525
42526   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42527   if (!arg1) {
42528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
42529     return 0;
42530   }
42531   {
42532     try {
42533       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
42534     } CALL_CATCH_EXCEPTION(0);
42535   }
42536
42537   jresult = (void *)result;
42538   return jresult;
42539 }
42540
42541
42542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
42543   void * jresult ;
42544   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42545   Dali::Toolkit::ScrollBar *arg2 = 0 ;
42546   Dali::Toolkit::ScrollBar *result = 0 ;
42547
42548   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42549   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
42550   if (!arg2) {
42551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
42552     return 0;
42553   }
42554   {
42555     try {
42556       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
42557     } CALL_CATCH_EXCEPTION(0);
42558   }
42559
42560   jresult = (void *)result;
42561   return jresult;
42562 }
42563
42564
42565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
42566   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42567
42568   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42569   {
42570     try {
42571       delete arg1;
42572     } CALL_CATCH_EXCEPTION();
42573   }
42574
42575 }
42576
42577
42578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
42579   void * jresult ;
42580   Dali::Toolkit::ScrollBar::Direction arg1 ;
42581   Dali::Toolkit::ScrollBar result;
42582
42583   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
42584   {
42585     try {
42586       result = Dali::Toolkit::ScrollBar::New(arg1);
42587     } CALL_CATCH_EXCEPTION(0);
42588   }
42589
42590   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
42591   return jresult;
42592 }
42593
42594
42595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
42596   void * jresult ;
42597   Dali::Toolkit::ScrollBar result;
42598
42599   {
42600     try {
42601       result = Dali::Toolkit::ScrollBar::New();
42602     } CALL_CATCH_EXCEPTION(0);
42603   }
42604
42605   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
42606   return jresult;
42607 }
42608
42609
42610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
42611   void * jresult ;
42612   Dali::BaseHandle arg1 ;
42613   Dali::BaseHandle *argp1 ;
42614   Dali::Toolkit::ScrollBar result;
42615
42616   argp1 = (Dali::BaseHandle *)jarg1;
42617   if (!argp1) {
42618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42619     return 0;
42620   }
42621   arg1 = *argp1;
42622   {
42623     try {
42624       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
42625     } CALL_CATCH_EXCEPTION(0);
42626   }
42627
42628   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
42629   return jresult;
42630 }
42631
42632
42633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
42634   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42635   Dali::Handle arg2 ;
42636   Dali::Property::Index arg3 ;
42637   Dali::Property::Index arg4 ;
42638   Dali::Property::Index arg5 ;
42639   Dali::Property::Index arg6 ;
42640   Dali::Handle *argp2 ;
42641
42642   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42643   argp2 = (Dali::Handle *)jarg2;
42644   if (!argp2) {
42645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
42646     return ;
42647   }
42648   arg2 = *argp2;
42649   arg3 = (Dali::Property::Index)jarg3;
42650   arg4 = (Dali::Property::Index)jarg4;
42651   arg5 = (Dali::Property::Index)jarg5;
42652   arg6 = (Dali::Property::Index)jarg6;
42653   {
42654     try {
42655       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
42656     } CALL_CATCH_EXCEPTION();
42657   }
42658
42659 }
42660
42661
42662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
42663   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42664   Dali::Actor arg2 ;
42665   Dali::Actor *argp2 ;
42666
42667   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42668   argp2 = (Dali::Actor *)jarg2;
42669   if (!argp2) {
42670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
42671     return ;
42672   }
42673   arg2 = *argp2;
42674   {
42675     try {
42676       (arg1)->SetScrollIndicator(arg2);
42677     } CALL_CATCH_EXCEPTION();
42678   }
42679
42680 }
42681
42682
42683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
42684   void * jresult ;
42685   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42686   Dali::Actor result;
42687
42688   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42689   {
42690     try {
42691       result = (arg1)->GetScrollIndicator();
42692     } CALL_CATCH_EXCEPTION(0);
42693   }
42694
42695   jresult = new Dali::Actor((const Dali::Actor &)result);
42696   return jresult;
42697 }
42698
42699
42700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
42701   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42702   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
42703
42704   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42705   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
42706   if (!arg2) {
42707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
42708     return ;
42709   }
42710   {
42711     try {
42712       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
42713     } CALL_CATCH_EXCEPTION();
42714   }
42715
42716 }
42717
42718
42719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
42720   void * jresult ;
42721   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42722
42723   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42724   {
42725     try {
42726       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()));
42727     } CALL_CATCH_EXCEPTION(0);
42728   }
42729   return jresult;
42730 }
42731
42732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
42733   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42734   Dali::Toolkit::ScrollBar::Direction arg2 ;
42735
42736   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42737   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
42738   {
42739     try {
42740       (arg1)->SetScrollDirection(arg2);
42741     } CALL_CATCH_EXCEPTION();
42742   }
42743
42744 }
42745
42746
42747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
42748   int jresult ;
42749   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42750   Dali::Toolkit::ScrollBar::Direction result;
42751
42752   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42753   {
42754     try {
42755       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
42756     } CALL_CATCH_EXCEPTION(0);
42757   }
42758
42759   jresult = (int)result;
42760   return jresult;
42761 }
42762
42763
42764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
42765   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42766   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
42767
42768   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42769   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
42770   {
42771     try {
42772       (arg1)->SetIndicatorHeightPolicy(arg2);
42773     } CALL_CATCH_EXCEPTION();
42774   }
42775
42776 }
42777
42778
42779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
42780   int jresult ;
42781   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42782   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
42783
42784   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42785   {
42786     try {
42787       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
42788     } CALL_CATCH_EXCEPTION(0);
42789   }
42790
42791   jresult = (int)result;
42792   return jresult;
42793 }
42794
42795
42796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
42797   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42798   float arg2 ;
42799
42800   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42801   arg2 = (float)jarg2;
42802   {
42803     try {
42804       (arg1)->SetIndicatorFixedHeight(arg2);
42805     } CALL_CATCH_EXCEPTION();
42806   }
42807
42808 }
42809
42810
42811 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
42812   float jresult ;
42813   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42814   float result;
42815
42816   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42817   {
42818     try {
42819       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
42820     } CALL_CATCH_EXCEPTION(0);
42821   }
42822
42823   jresult = result;
42824   return jresult;
42825 }
42826
42827
42828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
42829   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42830   float arg2 ;
42831
42832   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42833   arg2 = (float)jarg2;
42834   {
42835     try {
42836       (arg1)->SetIndicatorShowDuration(arg2);
42837     } CALL_CATCH_EXCEPTION();
42838   }
42839
42840 }
42841
42842
42843 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
42844   float jresult ;
42845   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42846   float result;
42847
42848   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42849   {
42850     try {
42851       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
42852     } CALL_CATCH_EXCEPTION(0);
42853   }
42854
42855   jresult = result;
42856   return jresult;
42857 }
42858
42859
42860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
42861   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42862   float arg2 ;
42863
42864   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42865   arg2 = (float)jarg2;
42866   {
42867     try {
42868       (arg1)->SetIndicatorHideDuration(arg2);
42869     } CALL_CATCH_EXCEPTION();
42870   }
42871
42872 }
42873
42874
42875 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
42876   float jresult ;
42877   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42878   float result;
42879
42880   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42881   {
42882     try {
42883       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
42884     } CALL_CATCH_EXCEPTION(0);
42885   }
42886
42887   jresult = result;
42888   return jresult;
42889 }
42890
42891
42892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
42893   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42894
42895   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42896   {
42897     try {
42898       (arg1)->ShowIndicator();
42899     } CALL_CATCH_EXCEPTION();
42900   }
42901
42902 }
42903
42904
42905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
42906   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42907
42908   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42909   {
42910     try {
42911       (arg1)->HideIndicator();
42912     } CALL_CATCH_EXCEPTION();
42913   }
42914
42915 }
42916
42917
42918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
42919   void * jresult ;
42920   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42921   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
42922
42923   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42924   {
42925     try {
42926       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
42927     } CALL_CATCH_EXCEPTION(0);
42928   }
42929
42930   jresult = (void *)result;
42931   return jresult;
42932 }
42933
42934
42935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
42936   void * jresult ;
42937   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42938   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
42939
42940   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42941   {
42942     try {
42943       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
42944     } CALL_CATCH_EXCEPTION(0);
42945   }
42946
42947   jresult = (void *)result;
42948   return jresult;
42949 }
42950
42951
42952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
42953   int jresult ;
42954   int result;
42955
42956   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
42957   jresult = (int)result;
42958   return jresult;
42959 }
42960
42961
42962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
42963   int jresult ;
42964   int result;
42965
42966   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
42967   jresult = (int)result;
42968   return jresult;
42969 }
42970
42971
42972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
42973   int jresult ;
42974   int result;
42975
42976   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
42977   jresult = (int)result;
42978   return jresult;
42979 }
42980
42981
42982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
42983   int jresult ;
42984   int result;
42985
42986   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
42987   jresult = (int)result;
42988   return jresult;
42989 }
42990
42991
42992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
42993   int jresult ;
42994   int result;
42995
42996   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
42997   jresult = (int)result;
42998   return jresult;
42999 }
43000
43001
43002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
43003   int jresult ;
43004   int result;
43005
43006   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
43007   jresult = (int)result;
43008   return jresult;
43009 }
43010
43011
43012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
43013   int jresult ;
43014   int result;
43015
43016   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
43017   jresult = (int)result;
43018   return jresult;
43019 }
43020
43021
43022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
43023   int jresult ;
43024   int result;
43025
43026   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
43027   jresult = (int)result;
43028   return jresult;
43029 }
43030
43031
43032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
43033   int jresult ;
43034   int result;
43035
43036   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
43037   jresult = (int)result;
43038   return jresult;
43039 }
43040
43041
43042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
43043   int jresult ;
43044   int result;
43045
43046   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
43047   jresult = (int)result;
43048   return jresult;
43049 }
43050
43051
43052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
43053   int jresult ;
43054   int result;
43055
43056   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
43057   jresult = (int)result;
43058   return jresult;
43059 }
43060
43061
43062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
43063   int jresult ;
43064   int result;
43065
43066   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
43067   jresult = (int)result;
43068   return jresult;
43069 }
43070
43071
43072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
43073   int jresult ;
43074   int result;
43075
43076   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
43077   jresult = (int)result;
43078   return jresult;
43079 }
43080
43081
43082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
43083   int jresult ;
43084   int result;
43085
43086   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
43087   jresult = (int)result;
43088   return jresult;
43089 }
43090
43091
43092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
43093   void * jresult ;
43094   Dali::Toolkit::Scrollable::Property *result = 0 ;
43095
43096   {
43097     try {
43098       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
43099     } CALL_CATCH_EXCEPTION(0);
43100   }
43101
43102   jresult = (void *)result;
43103   return jresult;
43104 }
43105
43106
43107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
43108   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
43109
43110   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
43111   {
43112     try {
43113       delete arg1;
43114     } CALL_CATCH_EXCEPTION();
43115   }
43116
43117 }
43118
43119
43120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
43121   void * jresult ;
43122   Dali::Toolkit::Scrollable *result = 0 ;
43123
43124   {
43125     try {
43126       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
43127     } CALL_CATCH_EXCEPTION(0);
43128   }
43129
43130   jresult = (void *)result;
43131   return jresult;
43132 }
43133
43134
43135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
43136   void * jresult ;
43137   Dali::Toolkit::Scrollable *arg1 = 0 ;
43138   Dali::Toolkit::Scrollable *result = 0 ;
43139
43140   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
43141   if (!arg1) {
43142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
43143     return 0;
43144   }
43145   {
43146     try {
43147       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
43148     } CALL_CATCH_EXCEPTION(0);
43149   }
43150
43151   jresult = (void *)result;
43152   return jresult;
43153 }
43154
43155
43156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
43157   void * jresult ;
43158   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
43159   Dali::Toolkit::Scrollable *arg2 = 0 ;
43160   Dali::Toolkit::Scrollable *result = 0 ;
43161
43162   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
43163   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
43164   if (!arg2) {
43165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
43166     return 0;
43167   }
43168   {
43169     try {
43170       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
43171     } CALL_CATCH_EXCEPTION(0);
43172   }
43173
43174   jresult = (void *)result;
43175   return jresult;
43176 }
43177
43178
43179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
43180   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
43181
43182   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
43183   {
43184     try {
43185       delete arg1;
43186     } CALL_CATCH_EXCEPTION();
43187   }
43188
43189 }
43190
43191
43192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
43193   void * jresult ;
43194   Dali::BaseHandle arg1 ;
43195   Dali::BaseHandle *argp1 ;
43196   Dali::Toolkit::Scrollable result;
43197
43198   argp1 = (Dali::BaseHandle *)jarg1;
43199   if (!argp1) {
43200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43201     return 0;
43202   }
43203   arg1 = *argp1;
43204   {
43205     try {
43206       result = Dali::Toolkit::Scrollable::DownCast(arg1);
43207     } CALL_CATCH_EXCEPTION(0);
43208   }
43209
43210   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
43211   return jresult;
43212 }
43213
43214
43215 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
43216   bool jresult ;
43217   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
43218   bool result;
43219
43220   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
43221   {
43222     try {
43223       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
43224     } CALL_CATCH_EXCEPTION(0);
43225   }
43226
43227   jresult = result;
43228   return jresult;
43229 }
43230
43231
43232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, bool jarg2) {
43233   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
43234   bool arg2 ;
43235
43236   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
43237   arg2 = jarg2 ? true : false;
43238   {
43239     try {
43240       (arg1)->SetOvershootEnabled(arg2);
43241     } CALL_CATCH_EXCEPTION();
43242   }
43243
43244 }
43245
43246
43247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
43248   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
43249   Dali::Vector4 *arg2 = 0 ;
43250
43251   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
43252   arg2 = (Dali::Vector4 *)jarg2;
43253   if (!arg2) {
43254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
43255     return ;
43256   }
43257   {
43258     try {
43259       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
43260     } CALL_CATCH_EXCEPTION();
43261   }
43262
43263 }
43264
43265
43266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
43267   void * jresult ;
43268   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
43269   Dali::Vector4 result;
43270
43271   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
43272   {
43273     try {
43274       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
43275     } CALL_CATCH_EXCEPTION(0);
43276   }
43277
43278   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43279   return jresult;
43280 }
43281
43282
43283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
43284   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
43285   float arg2 ;
43286
43287   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
43288   arg2 = (float)jarg2;
43289   {
43290     try {
43291       (arg1)->SetOvershootAnimationSpeed(arg2);
43292     } CALL_CATCH_EXCEPTION();
43293   }
43294
43295 }
43296
43297
43298 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
43299   float jresult ;
43300   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
43301   float result;
43302
43303   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
43304   {
43305     try {
43306       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
43307     } CALL_CATCH_EXCEPTION(0);
43308   }
43309
43310   jresult = result;
43311   return jresult;
43312 }
43313
43314
43315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
43316   void * jresult ;
43317   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
43318   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
43319
43320   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
43321   {
43322     try {
43323       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
43324     } CALL_CATCH_EXCEPTION(0);
43325   }
43326
43327   jresult = (void *)result;
43328   return jresult;
43329 }
43330
43331
43332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
43333   void * jresult ;
43334   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
43335   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
43336
43337   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
43338   {
43339     try {
43340       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
43341     } CALL_CATCH_EXCEPTION(0);
43342   }
43343
43344   jresult = (void *)result;
43345   return jresult;
43346 }
43347
43348
43349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
43350   void * jresult ;
43351   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
43352   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
43353
43354   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
43355   {
43356     try {
43357       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
43358     } CALL_CATCH_EXCEPTION(0);
43359   }
43360
43361   jresult = (void *)result;
43362   return jresult;
43363 }
43364
43365
43366 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
43367   bool jresult ;
43368   Dali::Toolkit::ControlOrientation::Type arg1 ;
43369   bool result;
43370
43371   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
43372   {
43373     try {
43374       result = (bool)Dali::Toolkit::IsVertical(arg1);
43375     } CALL_CATCH_EXCEPTION(0);
43376   }
43377
43378   jresult = result;
43379   return jresult;
43380 }
43381
43382
43383 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
43384   bool jresult ;
43385   Dali::Toolkit::ControlOrientation::Type arg1 ;
43386   bool result;
43387
43388   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
43389   {
43390     try {
43391       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
43392     } CALL_CATCH_EXCEPTION(0);
43393   }
43394
43395   jresult = result;
43396   return jresult;
43397 }
43398
43399
43400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
43401   void * jresult ;
43402   unsigned int arg1 ;
43403   unsigned int arg2 ;
43404   Dali::Toolkit::ItemRange *result = 0 ;
43405
43406   arg1 = (unsigned int)jarg1;
43407   arg2 = (unsigned int)jarg2;
43408   {
43409     try {
43410       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
43411     } CALL_CATCH_EXCEPTION(0);
43412   }
43413
43414   jresult = (void *)result;
43415   return jresult;
43416 }
43417
43418
43419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
43420   void * jresult ;
43421   Dali::Toolkit::ItemRange *arg1 = 0 ;
43422   Dali::Toolkit::ItemRange *result = 0 ;
43423
43424   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
43425   if (!arg1) {
43426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
43427     return 0;
43428   }
43429   {
43430     try {
43431       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
43432     } CALL_CATCH_EXCEPTION(0);
43433   }
43434
43435   jresult = (void *)result;
43436   return jresult;
43437 }
43438
43439
43440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
43441   void * jresult ;
43442   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
43443   Dali::Toolkit::ItemRange *arg2 = 0 ;
43444   Dali::Toolkit::ItemRange *result = 0 ;
43445
43446   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
43447   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
43448   if (!arg2) {
43449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
43450     return 0;
43451   }
43452   {
43453     try {
43454       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
43455     } CALL_CATCH_EXCEPTION(0);
43456   }
43457
43458   jresult = (void *)result;
43459   return jresult;
43460 }
43461
43462
43463 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
43464   bool jresult ;
43465   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
43466   unsigned int arg2 ;
43467   bool result;
43468
43469   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
43470   arg2 = (unsigned int)jarg2;
43471   {
43472     try {
43473       result = (bool)(arg1)->Within(arg2);
43474     } CALL_CATCH_EXCEPTION(0);
43475   }
43476
43477   jresult = result;
43478   return jresult;
43479 }
43480
43481
43482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
43483   void * jresult ;
43484   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
43485   Dali::Toolkit::ItemRange *arg2 = 0 ;
43486   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
43487
43488   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
43489   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
43490   if (!arg2) {
43491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
43492     return 0;
43493   }
43494   {
43495     try {
43496       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
43497     } CALL_CATCH_EXCEPTION(0);
43498   }
43499
43500   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
43501   return jresult;
43502 }
43503
43504
43505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
43506   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
43507   unsigned int arg2 ;
43508
43509   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
43510   arg2 = (unsigned int)jarg2;
43511   if (arg1) (arg1)->begin = arg2;
43512 }
43513
43514
43515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
43516   unsigned int jresult ;
43517   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
43518   unsigned int result;
43519
43520   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
43521   result = (unsigned int) ((arg1)->begin);
43522   jresult = result;
43523   return jresult;
43524 }
43525
43526
43527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
43528   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
43529   unsigned int arg2 ;
43530
43531   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
43532   arg2 = (unsigned int)jarg2;
43533   if (arg1) (arg1)->end = arg2;
43534 }
43535
43536
43537 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
43538   unsigned int jresult ;
43539   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
43540   unsigned int result;
43541
43542   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
43543   result = (unsigned int) ((arg1)->end);
43544   jresult = result;
43545   return jresult;
43546 }
43547
43548
43549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
43550   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
43551
43552   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
43553   {
43554     try {
43555       delete arg1;
43556     } CALL_CATCH_EXCEPTION();
43557   }
43558
43559 }
43560
43561
43562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
43563   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43564
43565   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43566   {
43567     try {
43568       delete arg1;
43569     } CALL_CATCH_EXCEPTION();
43570   }
43571
43572 }
43573
43574
43575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
43576   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43577   Dali::Toolkit::ControlOrientation::Type arg2 ;
43578
43579   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43580   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
43581   {
43582     try {
43583       (arg1)->SetOrientation(arg2);
43584     } CALL_CATCH_EXCEPTION();
43585   }
43586
43587 }
43588
43589
43590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
43591   int jresult ;
43592   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43593   Dali::Toolkit::ControlOrientation::Type result;
43594
43595   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43596   {
43597     try {
43598       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
43599     } CALL_CATCH_EXCEPTION(0);
43600   }
43601
43602   jresult = (int)result;
43603   return jresult;
43604 }
43605
43606
43607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
43608   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43609   Dali::Property::Map *arg2 = 0 ;
43610
43611   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43612   arg2 = (Dali::Property::Map *)jarg2;
43613   if (!arg2) {
43614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
43615     return ;
43616   }
43617   {
43618     try {
43619       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
43620     } CALL_CATCH_EXCEPTION();
43621   }
43622
43623 }
43624
43625
43626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
43627   void * jresult ;
43628   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43629   Dali::Property::Map result;
43630
43631   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43632   {
43633     try {
43634       result = (arg1)->GetLayoutProperties();
43635     } CALL_CATCH_EXCEPTION(0);
43636   }
43637
43638   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
43639   return jresult;
43640 }
43641
43642
43643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
43644   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43645   unsigned int arg2 ;
43646   Dali::Vector3 *arg3 = 0 ;
43647   Dali::Vector3 *arg4 = 0 ;
43648
43649   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43650   arg2 = (unsigned int)jarg2;
43651   arg3 = (Dali::Vector3 *)jarg3;
43652   if (!arg3) {
43653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43654     return ;
43655   }
43656   arg4 = (Dali::Vector3 *)jarg4;
43657   if (!arg4) {
43658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43659     return ;
43660   }
43661   {
43662     try {
43663       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
43664     } CALL_CATCH_EXCEPTION();
43665   }
43666
43667 }
43668
43669
43670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
43671   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43672   Dali::Vector3 *arg2 = 0 ;
43673
43674   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43675   arg2 = (Dali::Vector3 *)jarg2;
43676   if (!arg2) {
43677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43678     return ;
43679   }
43680   {
43681     try {
43682       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
43683     } CALL_CATCH_EXCEPTION();
43684   }
43685
43686 }
43687
43688
43689 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
43690   float jresult ;
43691   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43692   unsigned int arg2 ;
43693   Dali::Vector3 arg3 ;
43694   Dali::Vector3 *argp3 ;
43695   float result;
43696
43697   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43698   arg2 = (unsigned int)jarg2;
43699   argp3 = (Dali::Vector3 *)jarg3;
43700   if (!argp3) {
43701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
43702     return 0;
43703   }
43704   arg3 = *argp3;
43705   {
43706     try {
43707       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
43708     } CALL_CATCH_EXCEPTION(0);
43709   }
43710
43711   jresult = result;
43712   return jresult;
43713 }
43714
43715
43716 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
43717   float jresult ;
43718   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43719   float arg2 ;
43720   float result;
43721
43722   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43723   arg2 = (float)jarg2;
43724   {
43725     try {
43726       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
43727     } CALL_CATCH_EXCEPTION(0);
43728   }
43729
43730   jresult = result;
43731   return jresult;
43732 }
43733
43734
43735 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
43736   float jresult ;
43737   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43738   unsigned int arg2 ;
43739   float result;
43740
43741   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43742   arg2 = (unsigned int)jarg2;
43743   {
43744     try {
43745       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
43746     } CALL_CATCH_EXCEPTION(0);
43747   }
43748
43749   jresult = result;
43750   return jresult;
43751 }
43752
43753
43754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
43755   void * jresult ;
43756   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43757   float arg2 ;
43758   Dali::Vector3 arg3 ;
43759   Dali::Vector3 *argp3 ;
43760   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
43761
43762   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43763   arg2 = (float)jarg2;
43764   argp3 = (Dali::Vector3 *)jarg3;
43765   if (!argp3) {
43766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
43767     return 0;
43768   }
43769   arg3 = *argp3;
43770   {
43771     try {
43772       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
43773     } CALL_CATCH_EXCEPTION(0);
43774   }
43775
43776   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
43777   return jresult;
43778 }
43779
43780
43781 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
43782   float jresult ;
43783   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43784   int arg2 ;
43785   float arg3 ;
43786   Dali::Vector3 *arg4 = 0 ;
43787   float result;
43788
43789   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43790   arg2 = (int)jarg2;
43791   arg3 = (float)jarg3;
43792   arg4 = (Dali::Vector3 *)jarg4;
43793   if (!arg4) {
43794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43795     return 0;
43796   }
43797   {
43798     try {
43799       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
43800     } CALL_CATCH_EXCEPTION(0);
43801   }
43802
43803   jresult = result;
43804   return jresult;
43805 }
43806
43807
43808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
43809   unsigned int jresult ;
43810   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43811   Dali::Vector3 arg2 ;
43812   Dali::Vector3 *argp2 ;
43813   unsigned int result;
43814
43815   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43816   argp2 = (Dali::Vector3 *)jarg2;
43817   if (!argp2) {
43818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
43819     return 0;
43820   }
43821   arg2 = *argp2;
43822   {
43823     try {
43824       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
43825     } CALL_CATCH_EXCEPTION(0);
43826   }
43827
43828   jresult = result;
43829   return jresult;
43830 }
43831
43832
43833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
43834   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43835   unsigned int arg2 ;
43836   Dali::Vector3 *arg3 = 0 ;
43837   Dali::Vector3 *arg4 = 0 ;
43838
43839   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43840   arg2 = (unsigned int)jarg2;
43841   arg3 = (Dali::Vector3 *)jarg3;
43842   if (!arg3) {
43843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43844     return ;
43845   }
43846   arg4 = (Dali::Vector3 *)jarg4;
43847   if (!arg4) {
43848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43849     return ;
43850   }
43851   {
43852     try {
43853       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
43854     } CALL_CATCH_EXCEPTION();
43855   }
43856
43857 }
43858
43859
43860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
43861   void * jresult ;
43862   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43863   Dali::Degree result;
43864
43865   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43866   {
43867     try {
43868       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
43869     } CALL_CATCH_EXCEPTION(0);
43870   }
43871
43872   jresult = new Dali::Degree((const Dali::Degree &)result);
43873   return jresult;
43874 }
43875
43876
43877 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
43878   float jresult ;
43879   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43880   float result;
43881
43882   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43883   {
43884     try {
43885       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
43886     } CALL_CATCH_EXCEPTION(0);
43887   }
43888
43889   jresult = result;
43890   return jresult;
43891 }
43892
43893
43894 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
43895   float jresult ;
43896   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43897   float result;
43898
43899   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43900   {
43901     try {
43902       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
43903     } CALL_CATCH_EXCEPTION(0);
43904   }
43905
43906   jresult = result;
43907   return jresult;
43908 }
43909
43910
43911 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
43912   float jresult ;
43913   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43914   float result;
43915
43916   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43917   {
43918     try {
43919       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
43920     } CALL_CATCH_EXCEPTION(0);
43921   }
43922
43923   jresult = result;
43924   return jresult;
43925 }
43926
43927
43928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, bool jarg5) {
43929   int jresult ;
43930   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43931   int arg2 ;
43932   int arg3 ;
43933   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
43934   bool arg5 ;
43935   int result;
43936
43937   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43938   arg2 = (int)jarg2;
43939   arg3 = (int)jarg3;
43940   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
43941   arg5 = jarg5 ? true : false;
43942   {
43943     try {
43944       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
43945     } CALL_CATCH_EXCEPTION(0);
43946   }
43947
43948   jresult = result;
43949   return jresult;
43950 }
43951
43952
43953 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
43954   float jresult ;
43955   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43956   float result;
43957
43958   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43959   {
43960     try {
43961       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
43962     } CALL_CATCH_EXCEPTION(0);
43963   }
43964
43965   jresult = result;
43966   return jresult;
43967 }
43968
43969
43970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
43971   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43972   Dali::Actor *arg2 = 0 ;
43973   int arg3 ;
43974   Dali::Vector3 *arg4 = 0 ;
43975   Dali::Actor *arg5 = 0 ;
43976
43977   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43978   arg2 = (Dali::Actor *)jarg2;
43979   if (!arg2) {
43980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
43981     return ;
43982   }
43983   arg3 = (int)jarg3;
43984   arg4 = (Dali::Vector3 *)jarg4;
43985   if (!arg4) {
43986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43987     return ;
43988   }
43989   arg5 = (Dali::Actor *)jarg5;
43990   if (!arg5) {
43991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
43992     return ;
43993   }
43994   {
43995     try {
43996       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
43997     } CALL_CATCH_EXCEPTION();
43998   }
43999
44000 }
44001
44002
44003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
44004   void * jresult ;
44005   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
44006   int arg2 ;
44007   float arg3 ;
44008   Dali::Vector3 *arg4 = 0 ;
44009   Dali::Vector3 result;
44010
44011   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
44012   arg2 = (int)jarg2;
44013   arg3 = (float)jarg3;
44014   arg4 = (Dali::Vector3 *)jarg4;
44015   if (!arg4) {
44016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44017     return 0;
44018   }
44019   {
44020     try {
44021       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
44022     } CALL_CATCH_EXCEPTION(0);
44023   }
44024
44025   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
44026   return jresult;
44027 }
44028
44029
44030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
44031   void * jresult ;
44032   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
44033   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
44034
44035   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
44036   {
44037     try {
44038       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
44039     } CALL_CATCH_EXCEPTION(0);
44040   }
44041
44042   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
44043   return jresult;
44044 }
44045
44046
44047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
44048   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
44049
44050   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
44051   {
44052     try {
44053       delete arg1;
44054     } CALL_CATCH_EXCEPTION();
44055   }
44056
44057 }
44058
44059
44060 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
44061   unsigned int jresult ;
44062   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
44063   unsigned int result;
44064
44065   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
44066   {
44067     try {
44068       result = (unsigned int)(arg1)->GetNumberOfItems();
44069     } CALL_CATCH_EXCEPTION(0);
44070   }
44071
44072   jresult = result;
44073   return jresult;
44074 }
44075
44076
44077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
44078   void * jresult ;
44079   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
44080   unsigned int arg2 ;
44081   Dali::Actor result;
44082
44083   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
44084   arg2 = (unsigned int)jarg2;
44085   {
44086     try {
44087       result = (arg1)->NewItem(arg2);
44088     } CALL_CATCH_EXCEPTION(0);
44089   }
44090
44091   jresult = new Dali::Actor((const Dali::Actor &)result);
44092   return jresult;
44093 }
44094
44095
44096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
44097   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
44098   unsigned int arg2 ;
44099   Dali::Actor arg3 ;
44100   Dali::Actor *argp3 ;
44101
44102   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
44103   arg2 = (unsigned int)jarg2;
44104   argp3 = (Dali::Actor *)jarg3;
44105   if (!argp3) {
44106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
44107     return ;
44108   }
44109   arg3 = *argp3;
44110   {
44111     try {
44112       (arg1)->ItemReleased(arg2,arg3);
44113     } CALL_CATCH_EXCEPTION();
44114   }
44115
44116 }
44117
44118
44119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
44120   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
44121   unsigned int arg2 ;
44122   Dali::Actor arg3 ;
44123   Dali::Actor *argp3 ;
44124
44125   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
44126   arg2 = (unsigned int)jarg2;
44127   argp3 = (Dali::Actor *)jarg3;
44128   if (!argp3) {
44129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
44130     return ;
44131   }
44132   arg3 = *argp3;
44133   {
44134     try {
44135       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
44136     } CALL_CATCH_EXCEPTION();
44137   }
44138
44139 }
44140
44141
44142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
44143   void * jresult ;
44144   Dali::Toolkit::ItemFactory *result = 0 ;
44145
44146   {
44147     try {
44148       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
44149     } CALL_CATCH_EXCEPTION(0);
44150   }
44151
44152   jresult = (void *)result;
44153   return jresult;
44154 }
44155
44156
44157 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) {
44158   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
44159   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
44160   if (director) {
44161     director->swig_connect_director(callback0, callback1, callback2);
44162   }
44163 }
44164
44165
44166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
44167   int jresult ;
44168   int result;
44169
44170   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
44171   jresult = (int)result;
44172   return jresult;
44173 }
44174
44175
44176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
44177   int jresult ;
44178   int result;
44179
44180   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
44181   jresult = (int)result;
44182   return jresult;
44183 }
44184
44185
44186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
44187   int jresult ;
44188   int result;
44189
44190   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
44191   jresult = (int)result;
44192   return jresult;
44193 }
44194
44195
44196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
44197   int jresult ;
44198   int result;
44199
44200   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
44201   jresult = (int)result;
44202   return jresult;
44203 }
44204
44205
44206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
44207   int jresult ;
44208   int result;
44209
44210   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
44211   jresult = (int)result;
44212   return jresult;
44213 }
44214
44215
44216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
44217   int jresult ;
44218   int result;
44219
44220   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
44221   jresult = (int)result;
44222   return jresult;
44223 }
44224
44225
44226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
44227   int jresult ;
44228   int result;
44229
44230   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
44231   jresult = (int)result;
44232   return jresult;
44233 }
44234
44235
44236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
44237   int jresult ;
44238   int result;
44239
44240   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
44241   jresult = (int)result;
44242   return jresult;
44243 }
44244
44245
44246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
44247   int jresult ;
44248   int result;
44249
44250   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
44251   jresult = (int)result;
44252   return jresult;
44253 }
44254
44255
44256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
44257   int jresult ;
44258   int result;
44259
44260   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
44261   jresult = (int)result;
44262   return jresult;
44263 }
44264
44265
44266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
44267   int jresult ;
44268   int result;
44269
44270   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
44271   jresult = (int)result;
44272   return jresult;
44273 }
44274
44275
44276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
44277   void * jresult ;
44278   Dali::Toolkit::ItemView::Property *result = 0 ;
44279
44280   {
44281     try {
44282       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
44283     } CALL_CATCH_EXCEPTION(0);
44284   }
44285
44286   jresult = (void *)result;
44287   return jresult;
44288 }
44289
44290
44291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
44292   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
44293
44294   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
44295   {
44296     try {
44297       delete arg1;
44298     } CALL_CATCH_EXCEPTION();
44299   }
44300
44301 }
44302
44303
44304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
44305   void * jresult ;
44306   Dali::Toolkit::ItemView *result = 0 ;
44307
44308   {
44309     try {
44310       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
44311     } CALL_CATCH_EXCEPTION(0);
44312   }
44313
44314   jresult = (void *)result;
44315   return jresult;
44316 }
44317
44318
44319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
44320   void * jresult ;
44321   Dali::Toolkit::ItemView *arg1 = 0 ;
44322   Dali::Toolkit::ItemView *result = 0 ;
44323
44324   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44325   if (!arg1) {
44326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
44327     return 0;
44328   }
44329   {
44330     try {
44331       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
44332     } CALL_CATCH_EXCEPTION(0);
44333   }
44334
44335   jresult = (void *)result;
44336   return jresult;
44337 }
44338
44339
44340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
44341   void * jresult ;
44342   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44343   Dali::Toolkit::ItemView *arg2 = 0 ;
44344   Dali::Toolkit::ItemView *result = 0 ;
44345
44346   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44347   arg2 = (Dali::Toolkit::ItemView *)jarg2;
44348   if (!arg2) {
44349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
44350     return 0;
44351   }
44352   {
44353     try {
44354       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
44355     } CALL_CATCH_EXCEPTION(0);
44356   }
44357
44358   jresult = (void *)result;
44359   return jresult;
44360 }
44361
44362
44363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
44364   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44365
44366   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44367   {
44368     try {
44369       delete arg1;
44370     } CALL_CATCH_EXCEPTION();
44371   }
44372
44373 }
44374
44375
44376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
44377   void * jresult ;
44378   Dali::Toolkit::ItemFactory *arg1 = 0 ;
44379   Dali::Toolkit::ItemView result;
44380
44381   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
44382   if (!arg1) {
44383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
44384     return 0;
44385   }
44386   {
44387     try {
44388       result = Dali::Toolkit::ItemView::New(*arg1);
44389     } CALL_CATCH_EXCEPTION(0);
44390   }
44391
44392   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
44393   return jresult;
44394 }
44395
44396
44397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
44398   void * jresult ;
44399   Dali::BaseHandle arg1 ;
44400   Dali::BaseHandle *argp1 ;
44401   Dali::Toolkit::ItemView result;
44402
44403   argp1 = (Dali::BaseHandle *)jarg1;
44404   if (!argp1) {
44405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44406     return 0;
44407   }
44408   arg1 = *argp1;
44409   {
44410     try {
44411       result = Dali::Toolkit::ItemView::DownCast(arg1);
44412     } CALL_CATCH_EXCEPTION(0);
44413   }
44414
44415   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
44416   return jresult;
44417 }
44418
44419
44420 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
44421   unsigned int jresult ;
44422   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44423   unsigned int result;
44424
44425   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44426   {
44427     try {
44428       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
44429     } CALL_CATCH_EXCEPTION(0);
44430   }
44431
44432   jresult = result;
44433   return jresult;
44434 }
44435
44436
44437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
44438   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44439   Dali::Toolkit::ItemLayout *arg2 = 0 ;
44440
44441   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44442   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
44443   if (!arg2) {
44444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
44445     return ;
44446   }
44447   {
44448     try {
44449       (arg1)->AddLayout(*arg2);
44450     } CALL_CATCH_EXCEPTION();
44451   }
44452
44453 }
44454
44455
44456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
44457   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44458   unsigned int arg2 ;
44459
44460   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44461   arg2 = (unsigned int)jarg2;
44462   {
44463     try {
44464       (arg1)->RemoveLayout(arg2);
44465     } CALL_CATCH_EXCEPTION();
44466   }
44467
44468 }
44469
44470
44471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
44472   void * jresult ;
44473   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44474   unsigned int arg2 ;
44475   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
44476
44477   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44478   arg2 = (unsigned int)jarg2;
44479   {
44480     try {
44481       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
44482     } CALL_CATCH_EXCEPTION(0);
44483   }
44484
44485   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
44486   return jresult;
44487 }
44488
44489
44490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
44491   void * jresult ;
44492   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44493   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
44494
44495   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44496   {
44497     try {
44498       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
44499     } CALL_CATCH_EXCEPTION(0);
44500   }
44501
44502   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
44503   return jresult;
44504 }
44505
44506
44507 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
44508   float jresult ;
44509   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44510   Dali::Toolkit::ItemId arg2 ;
44511   float result;
44512
44513   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44514   arg2 = (Dali::Toolkit::ItemId)jarg2;
44515   {
44516     try {
44517       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
44518     } CALL_CATCH_EXCEPTION(0);
44519   }
44520
44521   jresult = result;
44522   return jresult;
44523 }
44524
44525
44526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
44527   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44528   unsigned int arg2 ;
44529   Dali::Vector3 arg3 ;
44530   float arg4 ;
44531   Dali::Vector3 *argp3 ;
44532
44533   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44534   arg2 = (unsigned int)jarg2;
44535   argp3 = (Dali::Vector3 *)jarg3;
44536   if (!argp3) {
44537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
44538     return ;
44539   }
44540   arg3 = *argp3;
44541   arg4 = (float)jarg4;
44542   {
44543     try {
44544       (arg1)->ActivateLayout(arg2,arg3,arg4);
44545     } CALL_CATCH_EXCEPTION();
44546   }
44547
44548 }
44549
44550
44551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
44552   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44553
44554   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44555   {
44556     try {
44557       (arg1)->DeactivateCurrentLayout();
44558     } CALL_CATCH_EXCEPTION();
44559   }
44560
44561 }
44562
44563
44564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
44565   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44566   float arg2 ;
44567
44568   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44569   arg2 = (float)jarg2;
44570   {
44571     try {
44572       (arg1)->SetMinimumSwipeSpeed(arg2);
44573     } CALL_CATCH_EXCEPTION();
44574   }
44575
44576 }
44577
44578
44579 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
44580   float jresult ;
44581   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44582   float result;
44583
44584   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44585   {
44586     try {
44587       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
44588     } CALL_CATCH_EXCEPTION(0);
44589   }
44590
44591   jresult = result;
44592   return jresult;
44593 }
44594
44595
44596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
44597   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44598   float arg2 ;
44599
44600   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44601   arg2 = (float)jarg2;
44602   {
44603     try {
44604       (arg1)->SetMinimumSwipeDistance(arg2);
44605     } CALL_CATCH_EXCEPTION();
44606   }
44607
44608 }
44609
44610
44611 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
44612   float jresult ;
44613   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44614   float result;
44615
44616   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44617   {
44618     try {
44619       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
44620     } CALL_CATCH_EXCEPTION(0);
44621   }
44622
44623   jresult = result;
44624   return jresult;
44625 }
44626
44627
44628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
44629   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44630   float arg2 ;
44631
44632   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44633   arg2 = (float)jarg2;
44634   {
44635     try {
44636       (arg1)->SetWheelScrollDistanceStep(arg2);
44637     } CALL_CATCH_EXCEPTION();
44638   }
44639
44640 }
44641
44642
44643 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
44644   float jresult ;
44645   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44646   float result;
44647
44648   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44649   {
44650     try {
44651       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
44652     } CALL_CATCH_EXCEPTION(0);
44653   }
44654
44655   jresult = result;
44656   return jresult;
44657 }
44658
44659
44660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, bool jarg2) {
44661   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44662   bool arg2 ;
44663
44664   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44665   arg2 = jarg2 ? true : false;
44666   {
44667     try {
44668       (arg1)->SetAnchoring(arg2);
44669     } CALL_CATCH_EXCEPTION();
44670   }
44671
44672 }
44673
44674 //// ========================= end of part 3 =============================
44675
44676 //// ========================== start part 4 ===============================
44677
44678
44679 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
44680   bool jresult ;
44681   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44682   bool result;
44683
44684   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44685   {
44686     try {
44687       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
44688     } CALL_CATCH_EXCEPTION(0);
44689   }
44690
44691   jresult = result;
44692   return jresult;
44693 }
44694
44695
44696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
44697   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44698   float arg2 ;
44699
44700   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44701   arg2 = (float)jarg2;
44702   {
44703     try {
44704       (arg1)->SetAnchoringDuration(arg2);
44705     } CALL_CATCH_EXCEPTION();
44706   }
44707
44708 }
44709
44710
44711 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
44712   float jresult ;
44713   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44714   float result;
44715
44716   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44717   {
44718     try {
44719       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
44720     } CALL_CATCH_EXCEPTION(0);
44721   }
44722
44723   jresult = result;
44724   return jresult;
44725 }
44726
44727
44728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
44729   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44730   Dali::Toolkit::ItemId arg2 ;
44731   float arg3 ;
44732
44733   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44734   arg2 = (Dali::Toolkit::ItemId)jarg2;
44735   arg3 = (float)jarg3;
44736   {
44737     try {
44738       (arg1)->ScrollToItem(arg2,arg3);
44739     } CALL_CATCH_EXCEPTION();
44740   }
44741
44742 }
44743
44744
44745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
44746   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44747   float arg2 ;
44748
44749   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44750   arg2 = (float)jarg2;
44751   {
44752     try {
44753       (arg1)->SetRefreshInterval(arg2);
44754     } CALL_CATCH_EXCEPTION();
44755   }
44756
44757 }
44758
44759
44760 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
44761   float jresult ;
44762   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44763   float result;
44764
44765   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44766   {
44767     try {
44768       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
44769     } CALL_CATCH_EXCEPTION(0);
44770   }
44771
44772   jresult = result;
44773   return jresult;
44774 }
44775
44776
44777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
44778   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44779
44780   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44781   {
44782     try {
44783       (arg1)->Refresh();
44784     } CALL_CATCH_EXCEPTION();
44785   }
44786
44787 }
44788
44789
44790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
44791   void * jresult ;
44792   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44793   Dali::Toolkit::ItemId arg2 ;
44794   Dali::Actor result;
44795
44796   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44797   arg2 = (Dali::Toolkit::ItemId)jarg2;
44798   {
44799     try {
44800       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
44801     } CALL_CATCH_EXCEPTION(0);
44802   }
44803
44804   jresult = new Dali::Actor((const Dali::Actor &)result);
44805   return jresult;
44806 }
44807
44808
44809 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
44810   unsigned int jresult ;
44811   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44812   Dali::Actor arg2 ;
44813   Dali::Actor *argp2 ;
44814   Dali::Toolkit::ItemId result;
44815
44816   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44817   argp2 = (Dali::Actor *)jarg2;
44818   if (!argp2) {
44819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
44820     return 0;
44821   }
44822   arg2 = *argp2;
44823   {
44824     try {
44825       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
44826     } CALL_CATCH_EXCEPTION(0);
44827   }
44828
44829   jresult = result;
44830   return jresult;
44831 }
44832
44833
44834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
44835   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44836   Dali::Toolkit::Item arg2 ;
44837   float arg3 ;
44838   Dali::Toolkit::Item *argp2 ;
44839
44840   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44841   argp2 = (Dali::Toolkit::Item *)jarg2;
44842   if (!argp2) {
44843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
44844     return ;
44845   }
44846   arg2 = *argp2;
44847   arg3 = (float)jarg3;
44848   {
44849     try {
44850       (arg1)->InsertItem(arg2,arg3);
44851     } CALL_CATCH_EXCEPTION();
44852   }
44853
44854 }
44855
44856
44857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
44858   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44859   Dali::Toolkit::ItemContainer *arg2 = 0 ;
44860   float arg3 ;
44861
44862   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44863   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
44864   if (!arg2) {
44865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
44866     return ;
44867   }
44868   arg3 = (float)jarg3;
44869   {
44870     try {
44871       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
44872     } CALL_CATCH_EXCEPTION();
44873   }
44874
44875 }
44876
44877
44878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
44879   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44880   Dali::Toolkit::ItemId arg2 ;
44881   float arg3 ;
44882
44883   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44884   arg2 = (Dali::Toolkit::ItemId)jarg2;
44885   arg3 = (float)jarg3;
44886   {
44887     try {
44888       (arg1)->RemoveItem(arg2,arg3);
44889     } CALL_CATCH_EXCEPTION();
44890   }
44891
44892 }
44893
44894
44895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
44896   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44897   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
44898   float arg3 ;
44899
44900   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44901   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
44902   if (!arg2) {
44903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
44904     return ;
44905   }
44906   arg3 = (float)jarg3;
44907   {
44908     try {
44909       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
44910     } CALL_CATCH_EXCEPTION();
44911   }
44912
44913 }
44914
44915
44916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
44917   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44918   Dali::Toolkit::Item arg2 ;
44919   float arg3 ;
44920   Dali::Toolkit::Item *argp2 ;
44921
44922   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44923   argp2 = (Dali::Toolkit::Item *)jarg2;
44924   if (!argp2) {
44925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
44926     return ;
44927   }
44928   arg2 = *argp2;
44929   arg3 = (float)jarg3;
44930   {
44931     try {
44932       (arg1)->ReplaceItem(arg2,arg3);
44933     } CALL_CATCH_EXCEPTION();
44934   }
44935
44936 }
44937
44938
44939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
44940   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44941   Dali::Toolkit::ItemContainer *arg2 = 0 ;
44942   float arg3 ;
44943
44944   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44945   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
44946   if (!arg2) {
44947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
44948     return ;
44949   }
44950   arg3 = (float)jarg3;
44951   {
44952     try {
44953       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
44954     } CALL_CATCH_EXCEPTION();
44955   }
44956
44957 }
44958
44959
44960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
44961   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44962   Dali::Vector3 *arg2 = 0 ;
44963
44964   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44965   arg2 = (Dali::Vector3 *)jarg2;
44966   if (!arg2) {
44967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44968     return ;
44969   }
44970   {
44971     try {
44972       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
44973     } CALL_CATCH_EXCEPTION();
44974   }
44975
44976 }
44977
44978
44979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
44980   void * jresult ;
44981   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44982   Dali::Vector3 result;
44983
44984   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44985   {
44986     try {
44987       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
44988     } CALL_CATCH_EXCEPTION(0);
44989   }
44990
44991   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
44992   return jresult;
44993 }
44994
44995
44996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
44997   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44998   Dali::Vector3 *arg2 = 0 ;
44999
45000   arg1 = (Dali::Toolkit::ItemView *)jarg1;
45001   arg2 = (Dali::Vector3 *)jarg2;
45002   if (!arg2) {
45003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
45004     return ;
45005   }
45006   {
45007     try {
45008       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
45009     } CALL_CATCH_EXCEPTION();
45010   }
45011
45012 }
45013
45014
45015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
45016   void * jresult ;
45017   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
45018   Dali::Vector3 result;
45019
45020   arg1 = (Dali::Toolkit::ItemView *)jarg1;
45021   {
45022     try {
45023       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
45024     } CALL_CATCH_EXCEPTION(0);
45025   }
45026
45027   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
45028   return jresult;
45029 }
45030
45031
45032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
45033   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
45034   Dali::Toolkit::ItemRange *arg2 = 0 ;
45035
45036   arg1 = (Dali::Toolkit::ItemView *)jarg1;
45037   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
45038   if (!arg2) {
45039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
45040     return ;
45041   }
45042   {
45043     try {
45044       (arg1)->GetItemsRange(*arg2);
45045     } CALL_CATCH_EXCEPTION();
45046   }
45047
45048 }
45049
45050
45051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
45052   void * jresult ;
45053   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
45054   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
45055
45056   arg1 = (Dali::Toolkit::ItemView *)jarg1;
45057   {
45058     try {
45059       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
45060     } CALL_CATCH_EXCEPTION(0);
45061   }
45062
45063   jresult = (void *)result;
45064   return jresult;
45065 }
45066
45067
45068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
45069   Dali::Vector3 *arg1 = 0 ;
45070   PropertyInputContainer *arg2 = 0 ;
45071
45072   arg1 = (Dali::Vector3 *)jarg1;
45073   if (!arg1) {
45074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
45075     return ;
45076   }
45077   arg2 = (PropertyInputContainer *)jarg2;
45078   if (!arg2) {
45079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
45080     return ;
45081   }
45082   {
45083     try {
45084       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
45085     } CALL_CATCH_EXCEPTION();
45086   }
45087
45088 }
45089
45090
45091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
45092   Dali::Vector3 *arg1 = 0 ;
45093   PropertyInputContainer *arg2 = 0 ;
45094
45095   arg1 = (Dali::Vector3 *)jarg1;
45096   if (!arg1) {
45097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
45098     return ;
45099   }
45100   arg2 = (PropertyInputContainer *)jarg2;
45101   if (!arg2) {
45102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
45103     return ;
45104   }
45105   {
45106     try {
45107       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
45108     } CALL_CATCH_EXCEPTION();
45109   }
45110
45111 }
45112
45113
45114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
45115   void * jresult ;
45116   Dali::Toolkit::ScrollViewEffect *result = 0 ;
45117
45118   {
45119     try {
45120       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
45121     } CALL_CATCH_EXCEPTION(0);
45122   }
45123
45124   jresult = (void *)result;
45125   return jresult;
45126 }
45127
45128
45129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
45130   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
45131
45132   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
45133   {
45134     try {
45135       delete arg1;
45136     } CALL_CATCH_EXCEPTION();
45137   }
45138
45139 }
45140
45141
45142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
45143   void * jresult ;
45144   Dali::Path arg1 ;
45145   Dali::Vector3 *arg2 = 0 ;
45146   Dali::Property::Index arg3 ;
45147   Dali::Vector3 *arg4 = 0 ;
45148   unsigned int arg5 ;
45149   Dali::Path *argp1 ;
45150   Dali::Toolkit::ScrollViewPagePathEffect result;
45151
45152   argp1 = (Dali::Path *)jarg1;
45153   if (!argp1) {
45154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
45155     return 0;
45156   }
45157   arg1 = *argp1;
45158   arg2 = (Dali::Vector3 *)jarg2;
45159   if (!arg2) {
45160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
45161     return 0;
45162   }
45163   arg3 = (Dali::Property::Index)jarg3;
45164   arg4 = (Dali::Vector3 *)jarg4;
45165   if (!arg4) {
45166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
45167     return 0;
45168   }
45169   arg5 = (unsigned int)jarg5;
45170   {
45171     try {
45172       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
45173     } CALL_CATCH_EXCEPTION(0);
45174   }
45175
45176   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
45177   return jresult;
45178 }
45179
45180
45181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
45182   void * jresult ;
45183   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
45184
45185   {
45186     try {
45187       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
45188     } CALL_CATCH_EXCEPTION(0);
45189   }
45190
45191   jresult = (void *)result;
45192   return jresult;
45193 }
45194
45195
45196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
45197   void * jresult ;
45198   Dali::BaseHandle arg1 ;
45199   Dali::BaseHandle *argp1 ;
45200   Dali::Toolkit::ScrollViewPagePathEffect result;
45201
45202   argp1 = (Dali::BaseHandle *)jarg1;
45203   if (!argp1) {
45204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45205     return 0;
45206   }
45207   arg1 = *argp1;
45208   {
45209     try {
45210       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
45211     } CALL_CATCH_EXCEPTION(0);
45212   }
45213
45214   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
45215   return jresult;
45216 }
45217
45218
45219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
45220   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
45221   Dali::Actor arg2 ;
45222   unsigned int arg3 ;
45223   Dali::Actor *argp2 ;
45224
45225   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
45226   argp2 = (Dali::Actor *)jarg2;
45227   if (!argp2) {
45228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
45229     return ;
45230   }
45231   arg2 = *argp2;
45232   arg3 = (unsigned int)jarg3;
45233   {
45234     try {
45235       (arg1)->ApplyToPage(arg2,arg3);
45236     } CALL_CATCH_EXCEPTION();
45237   }
45238
45239 }
45240
45241
45242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
45243   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
45244
45245   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
45246   {
45247     try {
45248       delete arg1;
45249     } CALL_CATCH_EXCEPTION();
45250   }
45251
45252 }
45253
45254
45255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
45256   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
45257   Dali::Toolkit::ClampState arg2 ;
45258
45259   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
45260   arg2 = (Dali::Toolkit::ClampState)jarg2;
45261   if (arg1) (arg1)->x = arg2;
45262 }
45263
45264
45265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
45266   int jresult ;
45267   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
45268   Dali::Toolkit::ClampState result;
45269
45270   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
45271   result = (Dali::Toolkit::ClampState) ((arg1)->x);
45272   jresult = (int)result;
45273   return jresult;
45274 }
45275
45276
45277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
45278   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
45279   Dali::Toolkit::ClampState arg2 ;
45280
45281   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
45282   arg2 = (Dali::Toolkit::ClampState)jarg2;
45283   if (arg1) (arg1)->y = arg2;
45284 }
45285
45286
45287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
45288   int jresult ;
45289   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
45290   Dali::Toolkit::ClampState result;
45291
45292   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
45293   result = (Dali::Toolkit::ClampState) ((arg1)->y);
45294   jresult = (int)result;
45295   return jresult;
45296 }
45297
45298
45299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
45300   void * jresult ;
45301   Dali::Toolkit::ClampState2D *result = 0 ;
45302
45303   {
45304     try {
45305       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
45306     } CALL_CATCH_EXCEPTION(0);
45307   }
45308
45309   jresult = (void *)result;
45310   return jresult;
45311 }
45312
45313
45314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
45315   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
45316
45317   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
45318   {
45319     try {
45320       delete arg1;
45321     } CALL_CATCH_EXCEPTION();
45322   }
45323
45324 }
45325
45326
45327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, bool jarg3) {
45328   void * jresult ;
45329   float arg1 ;
45330   float arg2 ;
45331   bool arg3 ;
45332   Dali::Toolkit::RulerDomain *result = 0 ;
45333
45334   arg1 = (float)jarg1;
45335   arg2 = (float)jarg2;
45336   arg3 = jarg3 ? true : false;
45337   {
45338     try {
45339       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
45340     } CALL_CATCH_EXCEPTION(0);
45341   }
45342
45343   jresult = (void *)result;
45344   return jresult;
45345 }
45346
45347
45348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
45349   void * jresult ;
45350   float arg1 ;
45351   float arg2 ;
45352   Dali::Toolkit::RulerDomain *result = 0 ;
45353
45354   arg1 = (float)jarg1;
45355   arg2 = (float)jarg2;
45356   {
45357     try {
45358       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
45359     } CALL_CATCH_EXCEPTION(0);
45360   }
45361
45362   jresult = (void *)result;
45363   return jresult;
45364 }
45365
45366
45367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
45368   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
45369   float arg2 ;
45370
45371   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
45372   arg2 = (float)jarg2;
45373   if (arg1) (arg1)->min = arg2;
45374 }
45375
45376
45377 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
45378   float jresult ;
45379   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
45380   float result;
45381
45382   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
45383   result = (float) ((arg1)->min);
45384   jresult = result;
45385   return jresult;
45386 }
45387
45388
45389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
45390   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
45391   float arg2 ;
45392
45393   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
45394   arg2 = (float)jarg2;
45395   if (arg1) (arg1)->max = arg2;
45396 }
45397
45398
45399 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
45400   float jresult ;
45401   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
45402   float result;
45403
45404   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
45405   result = (float) ((arg1)->max);
45406   jresult = result;
45407   return jresult;
45408 }
45409
45410
45411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, bool jarg2) {
45412   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
45413   bool arg2 ;
45414
45415   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
45416   arg2 = jarg2 ? true : false;
45417   if (arg1) (arg1)->enabled = arg2;
45418 }
45419
45420
45421 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
45422   bool jresult ;
45423   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
45424   bool result;
45425
45426   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
45427   result = (bool) ((arg1)->enabled);
45428   jresult = result;
45429   return jresult;
45430 }
45431
45432
45433 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
45434   float jresult ;
45435   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
45436   float arg2 ;
45437   float arg3 ;
45438   float arg4 ;
45439   float result;
45440
45441   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
45442   arg2 = (float)jarg2;
45443   arg3 = (float)jarg3;
45444   arg4 = (float)jarg4;
45445   {
45446     try {
45447       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
45448     } CALL_CATCH_EXCEPTION(0);
45449   }
45450
45451   jresult = result;
45452   return jresult;
45453 }
45454
45455
45456 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
45457   float jresult ;
45458   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
45459   float arg2 ;
45460   float arg3 ;
45461   float result;
45462
45463   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
45464   arg2 = (float)jarg2;
45465   arg3 = (float)jarg3;
45466   {
45467     try {
45468       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
45469     } CALL_CATCH_EXCEPTION(0);
45470   }
45471
45472   jresult = result;
45473   return jresult;
45474 }
45475
45476
45477 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
45478   float jresult ;
45479   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
45480   float arg2 ;
45481   float result;
45482
45483   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
45484   arg2 = (float)jarg2;
45485   {
45486     try {
45487       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
45488     } CALL_CATCH_EXCEPTION(0);
45489   }
45490
45491   jresult = result;
45492   return jresult;
45493 }
45494
45495
45496 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
45497   float jresult ;
45498   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
45499   float arg2 ;
45500   float arg3 ;
45501   float arg4 ;
45502   Dali::Toolkit::ClampState *arg5 = 0 ;
45503   float result;
45504
45505   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
45506   arg2 = (float)jarg2;
45507   arg3 = (float)jarg3;
45508   arg4 = (float)jarg4;
45509   arg5 = (Dali::Toolkit::ClampState *)jarg5;
45510   if (!arg5) {
45511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
45512     return 0;
45513   }
45514   {
45515     try {
45516       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
45517     } CALL_CATCH_EXCEPTION(0);
45518   }
45519
45520   jresult = result;
45521   return jresult;
45522 }
45523
45524
45525 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
45526   float jresult ;
45527   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
45528   float result;
45529
45530   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
45531   {
45532     try {
45533       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
45534     } CALL_CATCH_EXCEPTION(0);
45535   }
45536
45537   jresult = result;
45538   return jresult;
45539 }
45540
45541
45542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
45543   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
45544
45545   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
45546   {
45547     try {
45548       delete arg1;
45549     } CALL_CATCH_EXCEPTION();
45550   }
45551
45552 }
45553
45554
45555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
45556   float jresult ;
45557   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45558   float arg2 ;
45559   float arg3 ;
45560   float result;
45561
45562   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45563   arg2 = (float)jarg2;
45564   arg3 = (float)jarg3;
45565   {
45566     try {
45567       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
45568     } CALL_CATCH_EXCEPTION(0);
45569   }
45570
45571   jresult = result;
45572   return jresult;
45573 }
45574
45575
45576 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
45577   float jresult ;
45578   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45579   float arg2 ;
45580   float result;
45581
45582   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45583   arg2 = (float)jarg2;
45584   {
45585     try {
45586       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
45587     } CALL_CATCH_EXCEPTION(0);
45588   }
45589
45590   jresult = result;
45591   return jresult;
45592 }
45593
45594
45595 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) {
45596   float jresult ;
45597   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45598   unsigned int arg2 ;
45599   unsigned int *arg3 = 0 ;
45600   bool arg4 ;
45601   float result;
45602
45603   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45604   arg2 = (unsigned int)jarg2;
45605   arg3 = (unsigned int *)jarg3;
45606   arg4 = jarg4 ? true : false;
45607   {
45608     try {
45609       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
45610     } CALL_CATCH_EXCEPTION(0);
45611   }
45612
45613   jresult = result;
45614   return jresult;
45615 }
45616
45617
45618 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) {
45619   unsigned int jresult ;
45620   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45621   float arg2 ;
45622   bool arg3 ;
45623   unsigned int result;
45624
45625   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45626   arg2 = (float)jarg2;
45627   arg3 = jarg3 ? true : false;
45628   {
45629     try {
45630       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
45631     } CALL_CATCH_EXCEPTION(0);
45632   }
45633
45634   jresult = result;
45635   return jresult;
45636 }
45637
45638
45639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
45640   unsigned int jresult ;
45641   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45642   unsigned int result;
45643
45644   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45645   {
45646     try {
45647       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
45648     } CALL_CATCH_EXCEPTION(0);
45649   }
45650
45651   jresult = result;
45652   return jresult;
45653 }
45654
45655
45656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
45657   int jresult ;
45658   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45659   Dali::Toolkit::Ruler::RulerType result;
45660
45661   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45662   {
45663     try {
45664       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
45665     } CALL_CATCH_EXCEPTION(0);
45666   }
45667
45668   jresult = (int)result;
45669   return jresult;
45670 }
45671
45672
45673 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
45674   bool jresult ;
45675   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45676   bool result;
45677
45678   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45679   {
45680     try {
45681       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
45682     } CALL_CATCH_EXCEPTION(0);
45683   }
45684
45685   jresult = result;
45686   return jresult;
45687 }
45688
45689
45690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
45691   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45692
45693   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45694   {
45695     try {
45696       (arg1)->Enable();
45697     } CALL_CATCH_EXCEPTION();
45698   }
45699
45700 }
45701
45702
45703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
45704   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45705
45706   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45707   {
45708     try {
45709       (arg1)->Disable();
45710     } CALL_CATCH_EXCEPTION();
45711   }
45712
45713 }
45714
45715
45716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
45717   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45718   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
45719   Dali::Toolkit::RulerDomain *argp2 ;
45720
45721   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45722   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
45723   if (!argp2) {
45724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
45725     return ;
45726   }
45727   arg2 = *argp2;
45728   {
45729     try {
45730       (arg1)->SetDomain(arg2);
45731     } CALL_CATCH_EXCEPTION();
45732   }
45733
45734 }
45735
45736
45737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
45738   void * jresult ;
45739   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45740   Dali::Toolkit::RulerDomain *result = 0 ;
45741
45742   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45743   {
45744     try {
45745       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
45746     } CALL_CATCH_EXCEPTION(0);
45747   }
45748
45749   jresult = (void *)result;
45750   return jresult;
45751 }
45752
45753
45754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
45755   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45756
45757   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45758   {
45759     try {
45760       (arg1)->DisableDomain();
45761     } CALL_CATCH_EXCEPTION();
45762   }
45763
45764 }
45765
45766
45767 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
45768   float jresult ;
45769   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45770   float arg2 ;
45771   float arg3 ;
45772   float arg4 ;
45773   float result;
45774
45775   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45776   arg2 = (float)jarg2;
45777   arg3 = (float)jarg3;
45778   arg4 = (float)jarg4;
45779   {
45780     try {
45781       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
45782     } CALL_CATCH_EXCEPTION(0);
45783   }
45784
45785   jresult = result;
45786   return jresult;
45787 }
45788
45789
45790 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
45791   float jresult ;
45792   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45793   float arg2 ;
45794   float arg3 ;
45795   float result;
45796
45797   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45798   arg2 = (float)jarg2;
45799   arg3 = (float)jarg3;
45800   {
45801     try {
45802       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
45803     } CALL_CATCH_EXCEPTION(0);
45804   }
45805
45806   jresult = result;
45807   return jresult;
45808 }
45809
45810
45811 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
45812   float jresult ;
45813   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45814   float arg2 ;
45815   float result;
45816
45817   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45818   arg2 = (float)jarg2;
45819   {
45820     try {
45821       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
45822     } CALL_CATCH_EXCEPTION(0);
45823   }
45824
45825   jresult = result;
45826   return jresult;
45827 }
45828
45829
45830 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
45831   float jresult ;
45832   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45833   float arg2 ;
45834   float arg3 ;
45835   float arg4 ;
45836   Dali::Toolkit::ClampState *arg5 = 0 ;
45837   float result;
45838
45839   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45840   arg2 = (float)jarg2;
45841   arg3 = (float)jarg3;
45842   arg4 = (float)jarg4;
45843   arg5 = (Dali::Toolkit::ClampState *)jarg5;
45844   if (!arg5) {
45845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
45846     return 0;
45847   }
45848   {
45849     try {
45850       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
45851     } CALL_CATCH_EXCEPTION(0);
45852   }
45853
45854   jresult = result;
45855   return jresult;
45856 }
45857
45858
45859 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
45860   float jresult ;
45861   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45862   float arg2 ;
45863   float arg3 ;
45864   float arg4 ;
45865   float arg5 ;
45866   float result;
45867
45868   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45869   arg2 = (float)jarg2;
45870   arg3 = (float)jarg3;
45871   arg4 = (float)jarg4;
45872   arg5 = (float)jarg5;
45873   {
45874     try {
45875       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
45876     } CALL_CATCH_EXCEPTION(0);
45877   }
45878
45879   jresult = result;
45880   return jresult;
45881 }
45882
45883
45884 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
45885   float jresult ;
45886   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45887   float arg2 ;
45888   float arg3 ;
45889   float arg4 ;
45890   float result;
45891
45892   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45893   arg2 = (float)jarg2;
45894   arg3 = (float)jarg3;
45895   arg4 = (float)jarg4;
45896   {
45897     try {
45898       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
45899     } CALL_CATCH_EXCEPTION(0);
45900   }
45901
45902   jresult = result;
45903   return jresult;
45904 }
45905
45906
45907 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
45908   float jresult ;
45909   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45910   float arg2 ;
45911   float arg3 ;
45912   float result;
45913
45914   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45915   arg2 = (float)jarg2;
45916   arg3 = (float)jarg3;
45917   {
45918     try {
45919       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
45920     } CALL_CATCH_EXCEPTION(0);
45921   }
45922
45923   jresult = result;
45924   return jresult;
45925 }
45926
45927
45928 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
45929   float jresult ;
45930   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45931   float arg2 ;
45932   float result;
45933
45934   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45935   arg2 = (float)jarg2;
45936   {
45937     try {
45938       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
45939     } CALL_CATCH_EXCEPTION(0);
45940   }
45941
45942   jresult = result;
45943   return jresult;
45944 }
45945
45946
45947 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
45948   float jresult ;
45949   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45950   float arg2 ;
45951   float arg3 ;
45952   float arg4 ;
45953   float arg5 ;
45954   Dali::Toolkit::ClampState *arg6 = 0 ;
45955   float result;
45956
45957   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45958   arg2 = (float)jarg2;
45959   arg3 = (float)jarg3;
45960   arg4 = (float)jarg4;
45961   arg5 = (float)jarg5;
45962   arg6 = (Dali::Toolkit::ClampState *)jarg6;
45963   if (!arg6) {
45964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
45965     return 0;
45966   }
45967   {
45968     try {
45969       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
45970     } CALL_CATCH_EXCEPTION(0);
45971   }
45972
45973   jresult = result;
45974   return jresult;
45975 }
45976
45977
45978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
45979   void * jresult ;
45980   Dali::Toolkit::DefaultRuler *result = 0 ;
45981
45982   {
45983     try {
45984       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
45985     } CALL_CATCH_EXCEPTION(0);
45986   }
45987
45988   jresult = (void *)result;
45989   return jresult;
45990 }
45991
45992
45993 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
45994   float jresult ;
45995   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
45996   float arg2 ;
45997   float arg3 ;
45998   float result;
45999
46000   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
46001   arg2 = (float)jarg2;
46002   arg3 = (float)jarg3;
46003   {
46004     try {
46005       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
46006     } CALL_CATCH_EXCEPTION(0);
46007   }
46008
46009   jresult = result;
46010   return jresult;
46011 }
46012
46013
46014 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) {
46015   float jresult ;
46016   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
46017   unsigned int arg2 ;
46018   unsigned int *arg3 = 0 ;
46019   bool arg4 ;
46020   float result;
46021
46022   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
46023   arg2 = (unsigned int)jarg2;
46024   arg3 = (unsigned int *)jarg3;
46025   arg4 = jarg4 ? true : false;
46026   {
46027     try {
46028       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
46029     } CALL_CATCH_EXCEPTION(0);
46030   }
46031
46032   jresult = result;
46033   return jresult;
46034 }
46035
46036
46037 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) {
46038   unsigned int jresult ;
46039   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
46040   float arg2 ;
46041   bool arg3 ;
46042   unsigned int result;
46043
46044   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
46045   arg2 = (float)jarg2;
46046   arg3 = jarg3 ? true : false;
46047   {
46048     try {
46049       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
46050     } CALL_CATCH_EXCEPTION(0);
46051   }
46052
46053   jresult = result;
46054   return jresult;
46055 }
46056
46057
46058 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
46059   unsigned int jresult ;
46060   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
46061   unsigned int result;
46062
46063   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
46064   {
46065     try {
46066       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
46067     } CALL_CATCH_EXCEPTION(0);
46068   }
46069
46070   jresult = result;
46071   return jresult;
46072 }
46073
46074
46075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
46076   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
46077
46078   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
46079   {
46080     try {
46081       delete arg1;
46082     } CALL_CATCH_EXCEPTION();
46083   }
46084
46085 }
46086
46087
46088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
46089   void * jresult ;
46090   float arg1 ;
46091   Dali::Toolkit::FixedRuler *result = 0 ;
46092
46093   arg1 = (float)jarg1;
46094   {
46095     try {
46096       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
46097     } CALL_CATCH_EXCEPTION(0);
46098   }
46099
46100   jresult = (void *)result;
46101   return jresult;
46102 }
46103
46104
46105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
46106   void * jresult ;
46107   Dali::Toolkit::FixedRuler *result = 0 ;
46108
46109   {
46110     try {
46111       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
46112     } CALL_CATCH_EXCEPTION(0);
46113   }
46114
46115   jresult = (void *)result;
46116   return jresult;
46117 }
46118
46119
46120 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
46121   float jresult ;
46122   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
46123   float arg2 ;
46124   float arg3 ;
46125   float result;
46126
46127   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
46128   arg2 = (float)jarg2;
46129   arg3 = (float)jarg3;
46130   {
46131     try {
46132       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
46133     } CALL_CATCH_EXCEPTION(0);
46134   }
46135
46136   jresult = result;
46137   return jresult;
46138 }
46139
46140
46141 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) {
46142   float jresult ;
46143   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
46144   unsigned int arg2 ;
46145   unsigned int *arg3 = 0 ;
46146   bool arg4 ;
46147   float result;
46148
46149   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
46150   arg2 = (unsigned int)jarg2;
46151   arg3 = (unsigned int *)jarg3;
46152   arg4 = jarg4 ? true : false;
46153   {
46154     try {
46155       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
46156     } CALL_CATCH_EXCEPTION(0);
46157   }
46158
46159   jresult = result;
46160   return jresult;
46161 }
46162
46163
46164 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) {
46165   unsigned int jresult ;
46166   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
46167   float arg2 ;
46168   bool arg3 ;
46169   unsigned int result;
46170
46171   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
46172   arg2 = (float)jarg2;
46173   arg3 = jarg3 ? true : false;
46174   {
46175     try {
46176       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
46177     } CALL_CATCH_EXCEPTION(0);
46178   }
46179
46180   jresult = result;
46181   return jresult;
46182 }
46183
46184
46185 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
46186   unsigned int jresult ;
46187   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
46188   unsigned int result;
46189
46190   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
46191   {
46192     try {
46193       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
46194     } CALL_CATCH_EXCEPTION(0);
46195   }
46196
46197   jresult = result;
46198   return jresult;
46199 }
46200
46201
46202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
46203   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
46204
46205   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
46206   {
46207     try {
46208       delete arg1;
46209     } CALL_CATCH_EXCEPTION();
46210   }
46211
46212 }
46213
46214
46215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
46216   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
46217   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
46218
46219   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
46220   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
46221   if (arg1) (arg1)->scale = *arg2;
46222 }
46223
46224
46225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
46226   void * jresult ;
46227   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
46228   Dali::Toolkit::ClampState2D *result = 0 ;
46229
46230   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
46231   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
46232   jresult = (void *)result;
46233   return jresult;
46234 }
46235
46236
46237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
46238   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
46239   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
46240
46241   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
46242   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
46243   if (arg1) (arg1)->position = *arg2;
46244 }
46245
46246
46247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
46248   void * jresult ;
46249   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
46250   Dali::Toolkit::ClampState2D *result = 0 ;
46251
46252   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
46253   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
46254   jresult = (void *)result;
46255   return jresult;
46256 }
46257
46258
46259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
46260   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
46261   Dali::Toolkit::ClampState arg2 ;
46262
46263   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
46264   arg2 = (Dali::Toolkit::ClampState)jarg2;
46265   if (arg1) (arg1)->rotation = arg2;
46266 }
46267
46268
46269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
46270   int jresult ;
46271   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
46272   Dali::Toolkit::ClampState result;
46273
46274   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
46275   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
46276   jresult = (int)result;
46277   return jresult;
46278 }
46279
46280
46281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
46282   void * jresult ;
46283   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
46284
46285   {
46286     try {
46287       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
46288     } CALL_CATCH_EXCEPTION(0);
46289   }
46290
46291   jresult = (void *)result;
46292   return jresult;
46293 }
46294
46295
46296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
46297   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
46298
46299   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
46300   {
46301     try {
46302       delete arg1;
46303     } CALL_CATCH_EXCEPTION();
46304   }
46305
46306 }
46307
46308
46309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
46310   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
46311   Dali::Toolkit::SnapType arg2 ;
46312
46313   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
46314   arg2 = (Dali::Toolkit::SnapType)jarg2;
46315   if (arg1) (arg1)->type = arg2;
46316 }
46317
46318
46319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
46320   int jresult ;
46321   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
46322   Dali::Toolkit::SnapType result;
46323
46324   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
46325   result = (Dali::Toolkit::SnapType) ((arg1)->type);
46326   jresult = (int)result;
46327   return jresult;
46328 }
46329
46330
46331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
46332   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
46333   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
46334
46335   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
46336   arg2 = (Dali::Vector2 *)jarg2;
46337   if (arg1) (arg1)->position = *arg2;
46338 }
46339
46340
46341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
46342   void * jresult ;
46343   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
46344   Dali::Vector2 *result = 0 ;
46345
46346   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
46347   result = (Dali::Vector2 *)& ((arg1)->position);
46348   jresult = (void *)result;
46349   return jresult;
46350 }
46351
46352
46353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
46354   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
46355   float arg2 ;
46356
46357   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
46358   arg2 = (float)jarg2;
46359   if (arg1) (arg1)->duration = arg2;
46360 }
46361
46362
46363 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
46364   float jresult ;
46365   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
46366   float result;
46367
46368   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
46369   result = (float) ((arg1)->duration);
46370   jresult = result;
46371   return jresult;
46372 }
46373
46374
46375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
46376   void * jresult ;
46377   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
46378
46379   {
46380     try {
46381       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
46382     } CALL_CATCH_EXCEPTION(0);
46383   }
46384
46385   jresult = (void *)result;
46386   return jresult;
46387 }
46388
46389
46390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
46391   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
46392
46393   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
46394   {
46395     try {
46396       delete arg1;
46397     } CALL_CATCH_EXCEPTION();
46398   }
46399
46400 }
46401
46402
46403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
46404   int jresult ;
46405   int result;
46406
46407   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
46408   jresult = (int)result;
46409   return jresult;
46410 }
46411
46412
46413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
46414   int jresult ;
46415   int result;
46416
46417   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
46418   jresult = (int)result;
46419   return jresult;
46420 }
46421
46422
46423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
46424   int jresult ;
46425   int result;
46426
46427   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
46428   jresult = (int)result;
46429   return jresult;
46430 }
46431
46432
46433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
46434   int jresult ;
46435   int result;
46436
46437   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
46438   jresult = (int)result;
46439   return jresult;
46440 }
46441
46442
46443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
46444   int jresult ;
46445   int result;
46446
46447   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
46448   jresult = (int)result;
46449   return jresult;
46450 }
46451
46452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
46453   int jresult ;
46454   int result;
46455
46456   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
46457   jresult = (int)result;
46458   return jresult;
46459 }
46460
46461
46462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
46463   int jresult ;
46464   int result;
46465
46466   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
46467   jresult = (int)result;
46468   return jresult;
46469 }
46470
46471
46472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
46473   int jresult ;
46474   int result;
46475
46476   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
46477   jresult = (int)result;
46478   return jresult;
46479 }
46480
46481
46482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
46483   int jresult ;
46484   int result;
46485
46486   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
46487   jresult = (int)result;
46488   return jresult;
46489 }
46490
46491
46492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
46493   int jresult ;
46494   int result;
46495
46496   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
46497   jresult = (int)result;
46498   return jresult;
46499 }
46500
46501
46502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
46503   int jresult ;
46504   int result;
46505
46506   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
46507   jresult = (int)result;
46508   return jresult;
46509 }
46510
46511
46512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
46513   int jresult ;
46514   int result;
46515
46516   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
46517   jresult = (int)result;
46518   return jresult;
46519 }
46520
46521
46522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
46523   int jresult ;
46524   int result;
46525
46526   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
46527   jresult = (int)result;
46528   return jresult;
46529 }
46530
46531
46532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
46533   int jresult ;
46534   int result;
46535
46536   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
46537   jresult = (int)result;
46538   return jresult;
46539 }
46540
46541
46542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
46543   int jresult ;
46544   int result;
46545
46546   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
46547   jresult = (int)result;
46548   return jresult;
46549 }
46550
46551
46552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
46553   int jresult ;
46554   int result;
46555
46556   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
46557   jresult = (int)result;
46558   return jresult;
46559 }
46560
46561
46562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
46563   int jresult ;
46564   int result;
46565
46566   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
46567   jresult = (int)result;
46568   return jresult;
46569 }
46570
46571
46572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
46573   int jresult ;
46574   int result;
46575
46576   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
46577   jresult = (int)result;
46578   return jresult;
46579 }
46580
46581
46582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
46583   int jresult ;
46584   int result;
46585
46586   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
46587   jresult = (int)result;
46588   return jresult;
46589 }
46590
46591
46592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
46593   int jresult ;
46594   int result;
46595
46596   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
46597   jresult = (int)result;
46598   return jresult;
46599 }
46600
46601
46602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
46603   int jresult ;
46604   int result;
46605
46606   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
46607   jresult = (int)result;
46608   return jresult;
46609 }
46610
46611
46612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
46613   int jresult ;
46614   int result;
46615
46616   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
46617   jresult = (int)result;
46618   return jresult;
46619 }
46620
46621
46622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
46623   int jresult ;
46624   int result;
46625
46626   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
46627   jresult = (int)result;
46628   return jresult;
46629 }
46630
46631
46632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
46633   int jresult ;
46634   int result;
46635
46636   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
46637   jresult = (int)result;
46638   return jresult;
46639 }
46640
46641
46642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
46643   int jresult ;
46644   int result;
46645
46646   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
46647   jresult = (int)result;
46648   return jresult;
46649 }
46650
46651
46652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
46653   int jresult ;
46654   int result;
46655
46656   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
46657   jresult = (int)result;
46658   return jresult;
46659 }
46660
46661
46662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
46663   void * jresult ;
46664   Dali::Toolkit::ScrollView::Property *result = 0 ;
46665
46666   {
46667     try {
46668       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
46669     } CALL_CATCH_EXCEPTION(0);
46670   }
46671
46672   jresult = (void *)result;
46673   return jresult;
46674 }
46675
46676
46677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
46678   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
46679
46680   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
46681   {
46682     try {
46683       delete arg1;
46684     } CALL_CATCH_EXCEPTION();
46685   }
46686
46687 }
46688
46689
46690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
46691   void * jresult ;
46692   Dali::Toolkit::ScrollView *result = 0 ;
46693
46694   {
46695     try {
46696       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
46697     } CALL_CATCH_EXCEPTION(0);
46698   }
46699
46700   jresult = (void *)result;
46701   return jresult;
46702 }
46703
46704
46705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
46706   void * jresult ;
46707   Dali::Toolkit::ScrollView *arg1 = 0 ;
46708   Dali::Toolkit::ScrollView *result = 0 ;
46709
46710   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46711   if (!arg1) {
46712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
46713     return 0;
46714   }
46715   {
46716     try {
46717       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
46718     } CALL_CATCH_EXCEPTION(0);
46719   }
46720
46721   jresult = (void *)result;
46722   return jresult;
46723 }
46724
46725
46726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
46727   void * jresult ;
46728   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46729   Dali::Toolkit::ScrollView *arg2 = 0 ;
46730   Dali::Toolkit::ScrollView *result = 0 ;
46731
46732   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46733   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
46734   if (!arg2) {
46735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
46736     return 0;
46737   }
46738   {
46739     try {
46740       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
46741     } CALL_CATCH_EXCEPTION(0);
46742   }
46743
46744   jresult = (void *)result;
46745   return jresult;
46746 }
46747
46748
46749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
46750   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46751
46752   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46753   {
46754     try {
46755       delete arg1;
46756     } CALL_CATCH_EXCEPTION();
46757   }
46758
46759 }
46760
46761
46762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
46763   void * jresult ;
46764   Dali::Toolkit::ScrollView result;
46765
46766   {
46767     try {
46768       result = Dali::Toolkit::ScrollView::New();
46769     } CALL_CATCH_EXCEPTION(0);
46770   }
46771
46772   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
46773   return jresult;
46774 }
46775
46776
46777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
46778   void * jresult ;
46779   Dali::BaseHandle arg1 ;
46780   Dali::BaseHandle *argp1 ;
46781   Dali::Toolkit::ScrollView result;
46782
46783   argp1 = (Dali::BaseHandle *)jarg1;
46784   if (!argp1) {
46785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46786     return 0;
46787   }
46788   arg1 = *argp1;
46789   {
46790     try {
46791       result = Dali::Toolkit::ScrollView::DownCast(arg1);
46792     } CALL_CATCH_EXCEPTION(0);
46793   }
46794
46795   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
46796   return jresult;
46797 }
46798
46799
46800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
46801   void * jresult ;
46802   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46803   Dali::AlphaFunction result;
46804
46805   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46806   {
46807     try {
46808       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
46809     } CALL_CATCH_EXCEPTION(0);
46810   }
46811
46812   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
46813   return jresult;
46814 }
46815
46816
46817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
46818   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46819   Dali::AlphaFunction arg2 ;
46820   Dali::AlphaFunction *argp2 ;
46821
46822   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46823   argp2 = (Dali::AlphaFunction *)jarg2;
46824   if (!argp2) {
46825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
46826     return ;
46827   }
46828   arg2 = *argp2;
46829   {
46830     try {
46831       (arg1)->SetScrollSnapAlphaFunction(arg2);
46832     } CALL_CATCH_EXCEPTION();
46833   }
46834
46835 }
46836
46837
46838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
46839   void * jresult ;
46840   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46841   Dali::AlphaFunction result;
46842
46843   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46844   {
46845     try {
46846       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
46847     } CALL_CATCH_EXCEPTION(0);
46848   }
46849
46850   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
46851   return jresult;
46852 }
46853
46854
46855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
46856   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46857   Dali::AlphaFunction arg2 ;
46858   Dali::AlphaFunction *argp2 ;
46859
46860   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46861   argp2 = (Dali::AlphaFunction *)jarg2;
46862   if (!argp2) {
46863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
46864     return ;
46865   }
46866   arg2 = *argp2;
46867   {
46868     try {
46869       (arg1)->SetScrollFlickAlphaFunction(arg2);
46870     } CALL_CATCH_EXCEPTION();
46871   }
46872
46873 }
46874
46875
46876 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
46877   float jresult ;
46878   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46879   float result;
46880
46881   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46882   {
46883     try {
46884       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
46885     } CALL_CATCH_EXCEPTION(0);
46886   }
46887
46888   jresult = result;
46889   return jresult;
46890 }
46891
46892
46893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
46894   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46895   float arg2 ;
46896
46897   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46898   arg2 = (float)jarg2;
46899   {
46900     try {
46901       (arg1)->SetScrollSnapDuration(arg2);
46902     } CALL_CATCH_EXCEPTION();
46903   }
46904
46905 }
46906
46907
46908 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
46909   float jresult ;
46910   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46911   float result;
46912
46913   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46914   {
46915     try {
46916       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
46917     } CALL_CATCH_EXCEPTION(0);
46918   }
46919
46920   jresult = result;
46921   return jresult;
46922 }
46923
46924
46925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
46926   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46927   float arg2 ;
46928
46929   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46930   arg2 = (float)jarg2;
46931   {
46932     try {
46933       (arg1)->SetScrollFlickDuration(arg2);
46934     } CALL_CATCH_EXCEPTION();
46935   }
46936
46937 }
46938
46939
46940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
46941   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46942   Dali::Toolkit::RulerPtr arg2 ;
46943   Dali::Toolkit::RulerPtr *argp2 ;
46944
46945   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46946   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
46947   if (!argp2) {
46948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
46949     return ;
46950   }
46951   arg2 = *argp2;
46952   {
46953     try {
46954       (arg1)->SetRulerX(arg2);
46955     } CALL_CATCH_EXCEPTION();
46956   }
46957
46958 }
46959
46960
46961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
46962   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46963   Dali::Toolkit::RulerPtr arg2 ;
46964   Dali::Toolkit::RulerPtr *argp2 ;
46965
46966   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46967   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
46968   if (!argp2) {
46969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
46970     return ;
46971   }
46972   arg2 = *argp2;
46973   {
46974     try {
46975       (arg1)->SetRulerY(arg2);
46976     } CALL_CATCH_EXCEPTION();
46977   }
46978
46979 }
46980
46981
46982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, bool jarg2) {
46983   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46984   bool arg2 ;
46985
46986   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46987   arg2 = jarg2 ? true : false;
46988   {
46989     try {
46990       (arg1)->SetScrollSensitive(arg2);
46991     } CALL_CATCH_EXCEPTION();
46992   }
46993
46994 }
46995
46996
46997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
46998   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46999   float arg2 ;
47000   float arg3 ;
47001
47002   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47003   arg2 = (float)jarg2;
47004   arg3 = (float)jarg3;
47005   {
47006     try {
47007       (arg1)->SetMaxOvershoot(arg2,arg3);
47008     } CALL_CATCH_EXCEPTION();
47009   }
47010
47011 }
47012
47013
47014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
47015   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47016   Dali::AlphaFunction arg2 ;
47017   Dali::AlphaFunction *argp2 ;
47018
47019   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47020   argp2 = (Dali::AlphaFunction *)jarg2;
47021   if (!argp2) {
47022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
47023     return ;
47024   }
47025   arg2 = *argp2;
47026   {
47027     try {
47028       (arg1)->SetSnapOvershootAlphaFunction(arg2);
47029     } CALL_CATCH_EXCEPTION();
47030   }
47031
47032 }
47033
47034
47035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
47036   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47037   float arg2 ;
47038
47039   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47040   arg2 = (float)jarg2;
47041   {
47042     try {
47043       (arg1)->SetSnapOvershootDuration(arg2);
47044     } CALL_CATCH_EXCEPTION();
47045   }
47046
47047 }
47048
47049
47050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, bool jarg2) {
47051   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47052   bool arg2 ;
47053
47054   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47055   arg2 = jarg2 ? true : false;
47056   {
47057     try {
47058       (arg1)->SetActorAutoSnap(arg2);
47059     } CALL_CATCH_EXCEPTION();
47060   }
47061
47062 }
47063
47064
47065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, bool jarg2) {
47066   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47067   bool arg2 ;
47068
47069   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47070   arg2 = jarg2 ? true : false;
47071   {
47072     try {
47073       (arg1)->SetWrapMode(arg2);
47074     } CALL_CATCH_EXCEPTION();
47075   }
47076
47077 }
47078
47079
47080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
47081   int jresult ;
47082   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47083   int result;
47084
47085   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47086   {
47087     try {
47088       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
47089     } CALL_CATCH_EXCEPTION(0);
47090   }
47091
47092   jresult = result;
47093   return jresult;
47094 }
47095
47096
47097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
47098   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47099   int arg2 ;
47100
47101   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47102   arg2 = (int)jarg2;
47103   {
47104     try {
47105       (arg1)->SetScrollUpdateDistance(arg2);
47106     } CALL_CATCH_EXCEPTION();
47107   }
47108
47109 }
47110
47111
47112 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
47113   bool jresult ;
47114   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47115   bool result;
47116
47117   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47118   {
47119     try {
47120       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
47121     } CALL_CATCH_EXCEPTION(0);
47122   }
47123
47124   jresult = result;
47125   return jresult;
47126 }
47127
47128
47129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, bool jarg2) {
47130   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47131   bool arg2 ;
47132
47133   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47134   arg2 = jarg2 ? true : false;
47135   {
47136     try {
47137       (arg1)->SetAxisAutoLock(arg2);
47138     } CALL_CATCH_EXCEPTION();
47139   }
47140
47141 }
47142
47143
47144 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
47145   float jresult ;
47146   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47147   float result;
47148
47149   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47150   {
47151     try {
47152       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
47153     } CALL_CATCH_EXCEPTION(0);
47154   }
47155
47156   jresult = result;
47157   return jresult;
47158 }
47159
47160
47161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
47162   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47163   float arg2 ;
47164
47165   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47166   arg2 = (float)jarg2;
47167   {
47168     try {
47169       (arg1)->SetAxisAutoLockGradient(arg2);
47170     } CALL_CATCH_EXCEPTION();
47171   }
47172
47173 }
47174
47175
47176 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
47177   float jresult ;
47178   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47179   float result;
47180
47181   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47182   {
47183     try {
47184       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
47185     } CALL_CATCH_EXCEPTION(0);
47186   }
47187
47188   jresult = result;
47189   return jresult;
47190 }
47191
47192
47193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
47194   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47195   float arg2 ;
47196
47197   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47198   arg2 = (float)jarg2;
47199   {
47200     try {
47201       (arg1)->SetFrictionCoefficient(arg2);
47202     } CALL_CATCH_EXCEPTION();
47203   }
47204
47205 }
47206
47207
47208 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
47209   float jresult ;
47210   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47211   float result;
47212
47213   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47214   {
47215     try {
47216       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
47217     } CALL_CATCH_EXCEPTION(0);
47218   }
47219
47220   jresult = result;
47221   return jresult;
47222 }
47223
47224
47225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
47226   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47227   float arg2 ;
47228
47229   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47230   arg2 = (float)jarg2;
47231   {
47232     try {
47233       (arg1)->SetFlickSpeedCoefficient(arg2);
47234     } CALL_CATCH_EXCEPTION();
47235   }
47236
47237 }
47238
47239
47240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
47241   void * jresult ;
47242   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47243   Dali::Vector2 result;
47244
47245   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47246   {
47247     try {
47248       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
47249     } CALL_CATCH_EXCEPTION(0);
47250   }
47251
47252   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
47253   return jresult;
47254 }
47255
47256
47257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
47258   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47259   Dali::Vector2 *arg2 = 0 ;
47260
47261   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47262   arg2 = (Dali::Vector2 *)jarg2;
47263   if (!arg2) {
47264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
47265     return ;
47266   }
47267   {
47268     try {
47269       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
47270     } CALL_CATCH_EXCEPTION();
47271   }
47272
47273 }
47274
47275
47276 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
47277   float jresult ;
47278   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47279   float result;
47280
47281   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47282   {
47283     try {
47284       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
47285     } CALL_CATCH_EXCEPTION(0);
47286   }
47287
47288   jresult = result;
47289   return jresult;
47290 }
47291
47292
47293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
47294   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47295   float arg2 ;
47296
47297   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47298   arg2 = (float)jarg2;
47299   {
47300     try {
47301       (arg1)->SetMinimumSpeedForFlick(arg2);
47302     } CALL_CATCH_EXCEPTION();
47303   }
47304
47305 }
47306
47307
47308 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
47309   float jresult ;
47310   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47311   float result;
47312
47313   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47314   {
47315     try {
47316       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
47317     } CALL_CATCH_EXCEPTION(0);
47318   }
47319
47320   jresult = result;
47321   return jresult;
47322 }
47323
47324
47325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
47326   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47327   float arg2 ;
47328
47329   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47330   arg2 = (float)jarg2;
47331   {
47332     try {
47333       (arg1)->SetMaxFlickSpeed(arg2);
47334     } CALL_CATCH_EXCEPTION();
47335   }
47336
47337 }
47338
47339
47340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
47341   void * jresult ;
47342   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47343   Dali::Vector2 result;
47344
47345   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47346   {
47347     try {
47348       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
47349     } CALL_CATCH_EXCEPTION(0);
47350   }
47351
47352   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
47353   return jresult;
47354 }
47355
47356
47357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
47358   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47359   Dali::Vector2 arg2 ;
47360   Dali::Vector2 *argp2 ;
47361
47362   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47363   argp2 = (Dali::Vector2 *)jarg2;
47364   if (!argp2) {
47365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
47366     return ;
47367   }
47368   arg2 = *argp2;
47369   {
47370     try {
47371       (arg1)->SetWheelScrollDistanceStep(arg2);
47372     } CALL_CATCH_EXCEPTION();
47373   }
47374
47375 }
47376
47377
47378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
47379   void * jresult ;
47380   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47381   Dali::Vector2 result;
47382
47383   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47384   {
47385     try {
47386       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
47387     } CALL_CATCH_EXCEPTION(0);
47388   }
47389
47390   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
47391   return jresult;
47392 }
47393
47394
47395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
47396   unsigned int jresult ;
47397   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47398   unsigned int result;
47399
47400   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47401   {
47402     try {
47403       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
47404     } CALL_CATCH_EXCEPTION(0);
47405   }
47406
47407   jresult = result;
47408   return jresult;
47409 }
47410
47411
47412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
47413   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47414   Dali::Vector2 *arg2 = 0 ;
47415
47416   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47417   arg2 = (Dali::Vector2 *)jarg2;
47418   if (!arg2) {
47419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
47420     return ;
47421   }
47422   {
47423     try {
47424       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
47425     } CALL_CATCH_EXCEPTION();
47426   }
47427
47428 }
47429
47430
47431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
47432   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47433   Dali::Vector2 *arg2 = 0 ;
47434   float arg3 ;
47435
47436   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47437   arg2 = (Dali::Vector2 *)jarg2;
47438   if (!arg2) {
47439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
47440     return ;
47441   }
47442   arg3 = (float)jarg3;
47443   {
47444     try {
47445       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
47446     } CALL_CATCH_EXCEPTION();
47447   }
47448
47449 }
47450
47451
47452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
47453   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47454   Dali::Vector2 *arg2 = 0 ;
47455   float arg3 ;
47456   Dali::AlphaFunction arg4 ;
47457   Dali::AlphaFunction *argp4 ;
47458
47459   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47460   arg2 = (Dali::Vector2 *)jarg2;
47461   if (!arg2) {
47462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
47463     return ;
47464   }
47465   arg3 = (float)jarg3;
47466   argp4 = (Dali::AlphaFunction *)jarg4;
47467   if (!argp4) {
47468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
47469     return ;
47470   }
47471   arg4 = *argp4;
47472   {
47473     try {
47474       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
47475     } CALL_CATCH_EXCEPTION();
47476   }
47477
47478 }
47479
47480
47481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
47482   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47483   Dali::Vector2 *arg2 = 0 ;
47484   float arg3 ;
47485   Dali::Toolkit::DirectionBias arg4 ;
47486   Dali::Toolkit::DirectionBias arg5 ;
47487
47488   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47489   arg2 = (Dali::Vector2 *)jarg2;
47490   if (!arg2) {
47491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
47492     return ;
47493   }
47494   arg3 = (float)jarg3;
47495   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
47496   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
47497   {
47498     try {
47499       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
47500     } CALL_CATCH_EXCEPTION();
47501   }
47502
47503 }
47504
47505
47506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
47507   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47508   Dali::Vector2 *arg2 = 0 ;
47509   float arg3 ;
47510   Dali::AlphaFunction arg4 ;
47511   Dali::Toolkit::DirectionBias arg5 ;
47512   Dali::Toolkit::DirectionBias arg6 ;
47513   Dali::AlphaFunction *argp4 ;
47514
47515   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47516   arg2 = (Dali::Vector2 *)jarg2;
47517   if (!arg2) {
47518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
47519     return ;
47520   }
47521   arg3 = (float)jarg3;
47522   argp4 = (Dali::AlphaFunction *)jarg4;
47523   if (!argp4) {
47524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
47525     return ;
47526   }
47527   arg4 = *argp4;
47528   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
47529   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
47530   {
47531     try {
47532       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
47533     } CALL_CATCH_EXCEPTION();
47534   }
47535
47536 }
47537
47538
47539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
47540   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47541   unsigned int arg2 ;
47542
47543   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47544   arg2 = (unsigned int)jarg2;
47545   {
47546     try {
47547       (arg1)->ScrollTo(arg2);
47548     } CALL_CATCH_EXCEPTION();
47549   }
47550
47551 }
47552
47553
47554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
47555   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47556   unsigned int arg2 ;
47557   float arg3 ;
47558
47559   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47560   arg2 = (unsigned int)jarg2;
47561   arg3 = (float)jarg3;
47562   {
47563     try {
47564       (arg1)->ScrollTo(arg2,arg3);
47565     } CALL_CATCH_EXCEPTION();
47566   }
47567
47568 }
47569
47570
47571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
47572   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47573   unsigned int arg2 ;
47574   float arg3 ;
47575   Dali::Toolkit::DirectionBias arg4 ;
47576
47577   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47578   arg2 = (unsigned int)jarg2;
47579   arg3 = (float)jarg3;
47580   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
47581   {
47582     try {
47583       (arg1)->ScrollTo(arg2,arg3,arg4);
47584     } CALL_CATCH_EXCEPTION();
47585   }
47586
47587 }
47588
47589
47590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
47591   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47592   Dali::Actor *arg2 = 0 ;
47593
47594   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47595   arg2 = (Dali::Actor *)jarg2;
47596   if (!arg2) {
47597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
47598     return ;
47599   }
47600   {
47601     try {
47602       (arg1)->ScrollTo(*arg2);
47603     } CALL_CATCH_EXCEPTION();
47604   }
47605
47606 }
47607
47608
47609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
47610   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47611   Dali::Actor *arg2 = 0 ;
47612   float arg3 ;
47613
47614   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47615   arg2 = (Dali::Actor *)jarg2;
47616   if (!arg2) {
47617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
47618     return ;
47619   }
47620   arg3 = (float)jarg3;
47621   {
47622     try {
47623       (arg1)->ScrollTo(*arg2,arg3);
47624     } CALL_CATCH_EXCEPTION();
47625   }
47626
47627 }
47628
47629
47630 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
47631   bool jresult ;
47632   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47633   bool result;
47634
47635   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47636   {
47637     try {
47638       result = (bool)(arg1)->ScrollToSnapPoint();
47639     } CALL_CATCH_EXCEPTION(0);
47640   }
47641
47642   jresult = result;
47643   return jresult;
47644 }
47645
47646
47647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
47648   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47649   Dali::Constraint arg2 ;
47650   Dali::Constraint *argp2 ;
47651
47652   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47653   argp2 = (Dali::Constraint *)jarg2;
47654   if (!argp2) {
47655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
47656     return ;
47657   }
47658   arg2 = *argp2;
47659   {
47660     try {
47661       (arg1)->ApplyConstraintToChildren(arg2);
47662     } CALL_CATCH_EXCEPTION();
47663   }
47664
47665 }
47666
47667
47668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
47669   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47670
47671   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47672   {
47673     try {
47674       (arg1)->RemoveConstraintsFromChildren();
47675     } CALL_CATCH_EXCEPTION();
47676   }
47677
47678 }
47679
47680
47681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
47682   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47683   Dali::Toolkit::ScrollViewEffect arg2 ;
47684   Dali::Toolkit::ScrollViewEffect *argp2 ;
47685
47686   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47687   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
47688   if (!argp2) {
47689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
47690     return ;
47691   }
47692   arg2 = *argp2;
47693   {
47694     try {
47695       (arg1)->ApplyEffect(arg2);
47696     } CALL_CATCH_EXCEPTION();
47697   }
47698
47699 }
47700
47701
47702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
47703   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47704   Dali::Toolkit::ScrollViewEffect arg2 ;
47705   Dali::Toolkit::ScrollViewEffect *argp2 ;
47706
47707   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47708   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
47709   if (!argp2) {
47710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
47711     return ;
47712   }
47713   arg2 = *argp2;
47714   {
47715     try {
47716       (arg1)->RemoveEffect(arg2);
47717     } CALL_CATCH_EXCEPTION();
47718   }
47719
47720 }
47721
47722
47723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
47724   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47725
47726   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47727   {
47728     try {
47729       (arg1)->RemoveAllEffects();
47730     } CALL_CATCH_EXCEPTION();
47731   }
47732
47733 }
47734
47735
47736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
47737   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47738   Dali::Actor arg2 ;
47739   Dali::Actor *argp2 ;
47740
47741   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47742   argp2 = (Dali::Actor *)jarg2;
47743   if (!argp2) {
47744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47745     return ;
47746   }
47747   arg2 = *argp2;
47748   {
47749     try {
47750       (arg1)->BindActor(arg2);
47751     } CALL_CATCH_EXCEPTION();
47752   }
47753
47754 }
47755
47756
47757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
47758   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47759   Dali::Actor arg2 ;
47760   Dali::Actor *argp2 ;
47761
47762   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47763   argp2 = (Dali::Actor *)jarg2;
47764   if (!argp2) {
47765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47766     return ;
47767   }
47768   arg2 = *argp2;
47769   {
47770     try {
47771       (arg1)->UnbindActor(arg2);
47772     } CALL_CATCH_EXCEPTION();
47773   }
47774
47775 }
47776
47777
47778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
47779   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47780   Dali::Radian arg2 ;
47781   Dali::Radian arg3 ;
47782   Dali::Radian *argp2 ;
47783   Dali::Radian *argp3 ;
47784
47785   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47786   argp2 = (Dali::Radian *)jarg2;
47787   if (!argp2) {
47788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
47789     return ;
47790   }
47791   arg2 = *argp2;
47792   argp3 = (Dali::Radian *)jarg3;
47793   if (!argp3) {
47794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
47795     return ;
47796   }
47797   arg3 = *argp3;
47798   {
47799     try {
47800       (arg1)->SetScrollingDirection(arg2,arg3);
47801     } CALL_CATCH_EXCEPTION();
47802   }
47803
47804 }
47805
47806
47807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
47808   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47809   Dali::Radian arg2 ;
47810   Dali::Radian *argp2 ;
47811
47812   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47813   argp2 = (Dali::Radian *)jarg2;
47814   if (!argp2) {
47815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
47816     return ;
47817   }
47818   arg2 = *argp2;
47819   {
47820     try {
47821       (arg1)->SetScrollingDirection(arg2);
47822     } CALL_CATCH_EXCEPTION();
47823   }
47824
47825 }
47826
47827
47828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
47829   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47830   Dali::Radian arg2 ;
47831   Dali::Radian *argp2 ;
47832
47833   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47834   argp2 = (Dali::Radian *)jarg2;
47835   if (!argp2) {
47836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
47837     return ;
47838   }
47839   arg2 = *argp2;
47840   {
47841     try {
47842       (arg1)->RemoveScrollingDirection(arg2);
47843     } CALL_CATCH_EXCEPTION();
47844   }
47845
47846 }
47847
47848
47849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
47850   void * jresult ;
47851   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47852   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
47853
47854   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47855   {
47856     try {
47857       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
47858     } CALL_CATCH_EXCEPTION(0);
47859   }
47860
47861   jresult = (void *)result;
47862   return jresult;
47863 }
47864
47865
47866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
47867   int jresult ;
47868   int result;
47869
47870   result = (int)Dali::Toolkit::TableView::Property::ROWS;
47871   jresult = (int)result;
47872   return jresult;
47873 }
47874
47875
47876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
47877   int jresult ;
47878   int result;
47879
47880   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
47881   jresult = (int)result;
47882   return jresult;
47883 }
47884
47885
47886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
47887   int jresult ;
47888   int result;
47889
47890   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
47891   jresult = (int)result;
47892   return jresult;
47893 }
47894
47895
47896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
47897   int jresult ;
47898   int result;
47899
47900   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
47901   jresult = (int)result;
47902   return jresult;
47903 }
47904
47905
47906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
47907   int jresult ;
47908   int result;
47909
47910   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
47911   jresult = (int)result;
47912   return jresult;
47913 }
47914
47915
47916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
47917   void * jresult ;
47918   Dali::Toolkit::TableView::Property *result = 0 ;
47919
47920   {
47921     try {
47922       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
47923     } CALL_CATCH_EXCEPTION(0);
47924   }
47925
47926   jresult = (void *)result;
47927   return jresult;
47928 }
47929
47930
47931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
47932   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
47933
47934   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
47935   {
47936     try {
47937       delete arg1;
47938     } CALL_CATCH_EXCEPTION();
47939   }
47940
47941 }
47942
47943
47944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
47945   int jresult ;
47946   int result;
47947
47948   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
47949   jresult = (int)result;
47950   return jresult;
47951 }
47952
47953
47954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
47955   int jresult ;
47956   int result;
47957
47958   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
47959   jresult = (int)result;
47960   return jresult;
47961 }
47962
47963
47964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
47965   int jresult ;
47966   int result;
47967
47968   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
47969   jresult = (int)result;
47970   return jresult;
47971 }
47972
47973
47974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
47975   int jresult ;
47976   int result;
47977
47978   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
47979   jresult = (int)result;
47980   return jresult;
47981 }
47982
47983
47984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
47985   int jresult ;
47986   int result;
47987
47988   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
47989   jresult = (int)result;
47990   return jresult;
47991 }
47992
47993
47994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
47995   void * jresult ;
47996   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
47997
47998   {
47999     try {
48000       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
48001     } CALL_CATCH_EXCEPTION(0);
48002   }
48003
48004   jresult = (void *)result;
48005   return jresult;
48006 }
48007
48008
48009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
48010   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
48011
48012   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
48013   {
48014     try {
48015       delete arg1;
48016     } CALL_CATCH_EXCEPTION();
48017   }
48018
48019 }
48020
48021
48022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
48023   void * jresult ;
48024   unsigned int arg1 ;
48025   unsigned int arg2 ;
48026   unsigned int arg3 ;
48027   unsigned int arg4 ;
48028   Dali::Toolkit::TableView::CellPosition *result = 0 ;
48029
48030   arg1 = (unsigned int)jarg1;
48031   arg2 = (unsigned int)jarg2;
48032   arg3 = (unsigned int)jarg3;
48033   arg4 = (unsigned int)jarg4;
48034   {
48035     try {
48036       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
48037     } CALL_CATCH_EXCEPTION(0);
48038   }
48039
48040   jresult = (void *)result;
48041   return jresult;
48042 }
48043
48044
48045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
48046   void * jresult ;
48047   unsigned int arg1 ;
48048   unsigned int arg2 ;
48049   unsigned int arg3 ;
48050   Dali::Toolkit::TableView::CellPosition *result = 0 ;
48051
48052   arg1 = (unsigned int)jarg1;
48053   arg2 = (unsigned int)jarg2;
48054   arg3 = (unsigned int)jarg3;
48055   {
48056     try {
48057       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
48058     } CALL_CATCH_EXCEPTION(0);
48059   }
48060
48061   jresult = (void *)result;
48062   return jresult;
48063 }
48064
48065
48066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
48067   void * jresult ;
48068   unsigned int arg1 ;
48069   unsigned int arg2 ;
48070   Dali::Toolkit::TableView::CellPosition *result = 0 ;
48071
48072   arg1 = (unsigned int)jarg1;
48073   arg2 = (unsigned int)jarg2;
48074   {
48075     try {
48076       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
48077     } CALL_CATCH_EXCEPTION(0);
48078   }
48079
48080   jresult = (void *)result;
48081   return jresult;
48082 }
48083
48084
48085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
48086   void * jresult ;
48087   unsigned int arg1 ;
48088   Dali::Toolkit::TableView::CellPosition *result = 0 ;
48089
48090   arg1 = (unsigned int)jarg1;
48091   {
48092     try {
48093       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
48094     } CALL_CATCH_EXCEPTION(0);
48095   }
48096
48097   jresult = (void *)result;
48098   return jresult;
48099 }
48100
48101
48102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
48103   void * jresult ;
48104   Dali::Toolkit::TableView::CellPosition *result = 0 ;
48105
48106   {
48107     try {
48108       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
48109     } CALL_CATCH_EXCEPTION(0);
48110   }
48111
48112   jresult = (void *)result;
48113   return jresult;
48114 }
48115
48116
48117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
48118   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
48119   unsigned int arg2 ;
48120
48121   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
48122   arg2 = (unsigned int)jarg2;
48123   if (arg1) (arg1)->rowIndex = arg2;
48124 }
48125
48126
48127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
48128   unsigned int jresult ;
48129   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
48130   unsigned int result;
48131
48132   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
48133   result = (unsigned int) ((arg1)->rowIndex);
48134   jresult = result;
48135   return jresult;
48136 }
48137
48138
48139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
48140   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
48141   unsigned int arg2 ;
48142
48143   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
48144   arg2 = (unsigned int)jarg2;
48145   if (arg1) (arg1)->columnIndex = arg2;
48146 }
48147
48148
48149 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
48150   unsigned int jresult ;
48151   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
48152   unsigned int result;
48153
48154   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
48155   result = (unsigned int) ((arg1)->columnIndex);
48156   jresult = result;
48157   return jresult;
48158 }
48159
48160
48161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
48162   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
48163   unsigned int arg2 ;
48164
48165   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
48166   arg2 = (unsigned int)jarg2;
48167   if (arg1) (arg1)->rowSpan = arg2;
48168 }
48169
48170
48171 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
48172   unsigned int jresult ;
48173   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
48174   unsigned int result;
48175
48176   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
48177   result = (unsigned int) ((arg1)->rowSpan);
48178   jresult = result;
48179   return jresult;
48180 }
48181
48182
48183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
48184   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
48185   unsigned int arg2 ;
48186
48187   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
48188   arg2 = (unsigned int)jarg2;
48189   if (arg1) (arg1)->columnSpan = arg2;
48190 }
48191
48192
48193 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
48194   unsigned int jresult ;
48195   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
48196   unsigned int result;
48197
48198   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
48199   result = (unsigned int) ((arg1)->columnSpan);
48200   jresult = result;
48201   return jresult;
48202 }
48203
48204
48205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
48206   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
48207
48208   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
48209   {
48210     try {
48211       delete arg1;
48212     } CALL_CATCH_EXCEPTION();
48213   }
48214
48215 }
48216
48217
48218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
48219   void * jresult ;
48220   Dali::Toolkit::TableView *result = 0 ;
48221
48222   {
48223     try {
48224       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
48225     } CALL_CATCH_EXCEPTION(0);
48226   }
48227
48228   jresult = (void *)result;
48229   return jresult;
48230 }
48231
48232
48233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
48234   void * jresult ;
48235   Dali::Toolkit::TableView *arg1 = 0 ;
48236   Dali::Toolkit::TableView *result = 0 ;
48237
48238   arg1 = (Dali::Toolkit::TableView *)jarg1;
48239   if (!arg1) {
48240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
48241     return 0;
48242   }
48243   {
48244     try {
48245       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
48246     } CALL_CATCH_EXCEPTION(0);
48247   }
48248
48249   jresult = (void *)result;
48250   return jresult;
48251 }
48252
48253
48254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
48255   void * jresult ;
48256   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48257   Dali::Toolkit::TableView *arg2 = 0 ;
48258   Dali::Toolkit::TableView *result = 0 ;
48259
48260   arg1 = (Dali::Toolkit::TableView *)jarg1;
48261   arg2 = (Dali::Toolkit::TableView *)jarg2;
48262   if (!arg2) {
48263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
48264     return 0;
48265   }
48266   {
48267     try {
48268       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
48269     } CALL_CATCH_EXCEPTION(0);
48270   }
48271
48272   jresult = (void *)result;
48273   return jresult;
48274 }
48275
48276
48277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
48278   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48279
48280   arg1 = (Dali::Toolkit::TableView *)jarg1;
48281   {
48282     try {
48283       delete arg1;
48284     } CALL_CATCH_EXCEPTION();
48285   }
48286
48287 }
48288
48289
48290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
48291   void * jresult ;
48292   unsigned int arg1 ;
48293   unsigned int arg2 ;
48294   Dali::Toolkit::TableView result;
48295
48296   arg1 = (unsigned int)jarg1;
48297   arg2 = (unsigned int)jarg2;
48298   {
48299     try {
48300       result = Dali::Toolkit::TableView::New(arg1,arg2);
48301     } CALL_CATCH_EXCEPTION(0);
48302   }
48303
48304   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
48305   return jresult;
48306 }
48307
48308
48309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
48310   void * jresult ;
48311   Dali::BaseHandle arg1 ;
48312   Dali::BaseHandle *argp1 ;
48313   Dali::Toolkit::TableView result;
48314
48315   argp1 = (Dali::BaseHandle *)jarg1;
48316   if (!argp1) {
48317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48318     return 0;
48319   }
48320   arg1 = *argp1;
48321   {
48322     try {
48323       result = Dali::Toolkit::TableView::DownCast(arg1);
48324     } CALL_CATCH_EXCEPTION(0);
48325   }
48326
48327   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
48328   return jresult;
48329 }
48330
48331
48332 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
48333   bool jresult ;
48334   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48335   Dali::Actor arg2 ;
48336   Dali::Toolkit::TableView::CellPosition arg3 ;
48337   Dali::Actor *argp2 ;
48338   Dali::Toolkit::TableView::CellPosition *argp3 ;
48339   bool result;
48340
48341   arg1 = (Dali::Toolkit::TableView *)jarg1;
48342   argp2 = (Dali::Actor *)jarg2;
48343   if (!argp2) {
48344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48345     return 0;
48346   }
48347   arg2 = *argp2;
48348   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
48349   if (!argp3) {
48350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
48351     return 0;
48352   }
48353   arg3 = *argp3;
48354   {
48355     try {
48356       result = (bool)(arg1)->AddChild(arg2,arg3);
48357     } CALL_CATCH_EXCEPTION(0);
48358   }
48359
48360   jresult = result;
48361   return jresult;
48362 }
48363
48364
48365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
48366   void * jresult ;
48367   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48368   Dali::Toolkit::TableView::CellPosition arg2 ;
48369   Dali::Toolkit::TableView::CellPosition *argp2 ;
48370   Dali::Actor result;
48371
48372   arg1 = (Dali::Toolkit::TableView *)jarg1;
48373   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
48374   if (!argp2) {
48375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
48376     return 0;
48377   }
48378   arg2 = *argp2;
48379   {
48380     try {
48381       result = (arg1)->GetChildAt(arg2);
48382     } CALL_CATCH_EXCEPTION(0);
48383   }
48384
48385   jresult = new Dali::Actor((const Dali::Actor &)result);
48386   return jresult;
48387 }
48388
48389
48390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
48391   void * jresult ;
48392   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48393   Dali::Toolkit::TableView::CellPosition arg2 ;
48394   Dali::Toolkit::TableView::CellPosition *argp2 ;
48395   Dali::Actor result;
48396
48397   arg1 = (Dali::Toolkit::TableView *)jarg1;
48398   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
48399   if (!argp2) {
48400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
48401     return 0;
48402   }
48403   arg2 = *argp2;
48404   {
48405     try {
48406       result = (arg1)->RemoveChildAt(arg2);
48407     } CALL_CATCH_EXCEPTION(0);
48408   }
48409
48410   jresult = new Dali::Actor((const Dali::Actor &)result);
48411   return jresult;
48412 }
48413
48414
48415 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
48416   bool jresult ;
48417   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48418   Dali::Actor arg2 ;
48419   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
48420   Dali::Actor *argp2 ;
48421   bool result;
48422
48423   arg1 = (Dali::Toolkit::TableView *)jarg1;
48424   argp2 = (Dali::Actor *)jarg2;
48425   if (!argp2) {
48426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48427     return 0;
48428   }
48429   arg2 = *argp2;
48430   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
48431   if (!arg3) {
48432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
48433     return 0;
48434   }
48435   {
48436     try {
48437       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
48438     } CALL_CATCH_EXCEPTION(0);
48439   }
48440
48441   jresult = result;
48442   return jresult;
48443 }
48444
48445
48446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
48447   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48448   unsigned int arg2 ;
48449
48450   arg1 = (Dali::Toolkit::TableView *)jarg1;
48451   arg2 = (unsigned int)jarg2;
48452   {
48453     try {
48454       (arg1)->InsertRow(arg2);
48455     } CALL_CATCH_EXCEPTION();
48456   }
48457
48458 }
48459
48460
48461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
48462   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48463   unsigned int arg2 ;
48464
48465   arg1 = (Dali::Toolkit::TableView *)jarg1;
48466   arg2 = (unsigned int)jarg2;
48467   {
48468     try {
48469       (arg1)->DeleteRow(arg2);
48470     } CALL_CATCH_EXCEPTION();
48471   }
48472
48473 }
48474
48475
48476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
48477   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48478   unsigned int arg2 ;
48479   std::vector< Dali::Actor > *arg3 = 0 ;
48480
48481   arg1 = (Dali::Toolkit::TableView *)jarg1;
48482   arg2 = (unsigned int)jarg2;
48483   arg3 = (std::vector< Dali::Actor > *)jarg3;
48484   if (!arg3) {
48485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
48486     return ;
48487   }
48488   {
48489     try {
48490       (arg1)->DeleteRow(arg2,*arg3);
48491     } CALL_CATCH_EXCEPTION();
48492   }
48493
48494 }
48495
48496
48497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
48498   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48499   unsigned int arg2 ;
48500
48501   arg1 = (Dali::Toolkit::TableView *)jarg1;
48502   arg2 = (unsigned int)jarg2;
48503   {
48504     try {
48505       (arg1)->InsertColumn(arg2);
48506     } CALL_CATCH_EXCEPTION();
48507   }
48508
48509 }
48510
48511
48512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
48513   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48514   unsigned int arg2 ;
48515
48516   arg1 = (Dali::Toolkit::TableView *)jarg1;
48517   arg2 = (unsigned int)jarg2;
48518   {
48519     try {
48520       (arg1)->DeleteColumn(arg2);
48521     } CALL_CATCH_EXCEPTION();
48522   }
48523
48524 }
48525
48526
48527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
48528   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48529   unsigned int arg2 ;
48530   std::vector< Dali::Actor > *arg3 = 0 ;
48531
48532   arg1 = (Dali::Toolkit::TableView *)jarg1;
48533   arg2 = (unsigned int)jarg2;
48534   arg3 = (std::vector< Dali::Actor > *)jarg3;
48535   if (!arg3) {
48536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
48537     return ;
48538   }
48539   {
48540     try {
48541       (arg1)->DeleteColumn(arg2,*arg3);
48542     } CALL_CATCH_EXCEPTION();
48543   }
48544
48545 }
48546
48547
48548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
48549   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48550   unsigned int arg2 ;
48551   unsigned int arg3 ;
48552
48553   arg1 = (Dali::Toolkit::TableView *)jarg1;
48554   arg2 = (unsigned int)jarg2;
48555   arg3 = (unsigned int)jarg3;
48556   {
48557     try {
48558       (arg1)->Resize(arg2,arg3);
48559     } CALL_CATCH_EXCEPTION();
48560   }
48561
48562 }
48563
48564
48565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
48566   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48567   unsigned int arg2 ;
48568   unsigned int arg3 ;
48569   std::vector< Dali::Actor > *arg4 = 0 ;
48570
48571   arg1 = (Dali::Toolkit::TableView *)jarg1;
48572   arg2 = (unsigned int)jarg2;
48573   arg3 = (unsigned int)jarg3;
48574   arg4 = (std::vector< Dali::Actor > *)jarg4;
48575   if (!arg4) {
48576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
48577     return ;
48578   }
48579   {
48580     try {
48581       (arg1)->Resize(arg2,arg3,*arg4);
48582     } CALL_CATCH_EXCEPTION();
48583   }
48584
48585 }
48586
48587
48588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
48589   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48590   Dali::Size arg2 ;
48591   Dali::Size *argp2 ;
48592
48593   arg1 = (Dali::Toolkit::TableView *)jarg1;
48594   argp2 = (Dali::Size *)jarg2;
48595   if (!argp2) {
48596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
48597     return ;
48598   }
48599   arg2 = *argp2;
48600   {
48601     try {
48602       (arg1)->SetCellPadding(arg2);
48603     } CALL_CATCH_EXCEPTION();
48604   }
48605
48606 }
48607
48608
48609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
48610   void * jresult ;
48611   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48612   Dali::Size result;
48613
48614   arg1 = (Dali::Toolkit::TableView *)jarg1;
48615   {
48616     try {
48617       result = (arg1)->GetCellPadding();
48618     } CALL_CATCH_EXCEPTION(0);
48619   }
48620
48621   jresult = new Dali::Size((const Dali::Size &)result);
48622   return jresult;
48623 }
48624
48625
48626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
48627   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48628   unsigned int arg2 ;
48629
48630   arg1 = (Dali::Toolkit::TableView *)jarg1;
48631   arg2 = (unsigned int)jarg2;
48632   {
48633     try {
48634       (arg1)->SetFitHeight(arg2);
48635     } CALL_CATCH_EXCEPTION();
48636   }
48637
48638 }
48639
48640
48641 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
48642   bool jresult ;
48643   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48644   unsigned int arg2 ;
48645   bool result;
48646
48647   arg1 = (Dali::Toolkit::TableView *)jarg1;
48648   arg2 = (unsigned int)jarg2;
48649   {
48650     try {
48651       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
48652     } CALL_CATCH_EXCEPTION(0);
48653   }
48654
48655   jresult = result;
48656   return jresult;
48657 }
48658
48659
48660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
48661   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48662   unsigned int arg2 ;
48663
48664   arg1 = (Dali::Toolkit::TableView *)jarg1;
48665   arg2 = (unsigned int)jarg2;
48666   {
48667     try {
48668       (arg1)->SetFitWidth(arg2);
48669     } CALL_CATCH_EXCEPTION();
48670   }
48671
48672 }
48673
48674
48675 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
48676   bool jresult ;
48677   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48678   unsigned int arg2 ;
48679   bool result;
48680
48681   arg1 = (Dali::Toolkit::TableView *)jarg1;
48682   arg2 = (unsigned int)jarg2;
48683   {
48684     try {
48685       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
48686     } CALL_CATCH_EXCEPTION(0);
48687   }
48688
48689   jresult = result;
48690   return jresult;
48691 }
48692
48693
48694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
48695   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48696   unsigned int arg2 ;
48697   float arg3 ;
48698
48699   arg1 = (Dali::Toolkit::TableView *)jarg1;
48700   arg2 = (unsigned int)jarg2;
48701   arg3 = (float)jarg3;
48702   {
48703     try {
48704       (arg1)->SetFixedHeight(arg2,arg3);
48705     } CALL_CATCH_EXCEPTION();
48706   }
48707
48708 }
48709
48710
48711 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
48712   float jresult ;
48713   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48714   unsigned int arg2 ;
48715   float result;
48716
48717   arg1 = (Dali::Toolkit::TableView *)jarg1;
48718   arg2 = (unsigned int)jarg2;
48719   {
48720     try {
48721       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
48722     } CALL_CATCH_EXCEPTION(0);
48723   }
48724
48725   jresult = result;
48726   return jresult;
48727 }
48728
48729
48730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
48731   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48732   unsigned int arg2 ;
48733   float arg3 ;
48734
48735   arg1 = (Dali::Toolkit::TableView *)jarg1;
48736   arg2 = (unsigned int)jarg2;
48737   arg3 = (float)jarg3;
48738   {
48739     try {
48740       (arg1)->SetRelativeHeight(arg2,arg3);
48741     } CALL_CATCH_EXCEPTION();
48742   }
48743
48744 }
48745
48746
48747 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
48748   float jresult ;
48749   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48750   unsigned int arg2 ;
48751   float result;
48752
48753   arg1 = (Dali::Toolkit::TableView *)jarg1;
48754   arg2 = (unsigned int)jarg2;
48755   {
48756     try {
48757       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
48758     } CALL_CATCH_EXCEPTION(0);
48759   }
48760
48761   jresult = result;
48762   return jresult;
48763 }
48764
48765
48766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
48767   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48768   unsigned int arg2 ;
48769   float arg3 ;
48770
48771   arg1 = (Dali::Toolkit::TableView *)jarg1;
48772   arg2 = (unsigned int)jarg2;
48773   arg3 = (float)jarg3;
48774   {
48775     try {
48776       (arg1)->SetFixedWidth(arg2,arg3);
48777     } CALL_CATCH_EXCEPTION();
48778   }
48779
48780 }
48781
48782
48783 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
48784   float jresult ;
48785   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48786   unsigned int arg2 ;
48787   float result;
48788
48789   arg1 = (Dali::Toolkit::TableView *)jarg1;
48790   arg2 = (unsigned int)jarg2;
48791   {
48792     try {
48793       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
48794     } CALL_CATCH_EXCEPTION(0);
48795   }
48796
48797   jresult = result;
48798   return jresult;
48799 }
48800
48801
48802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
48803   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48804   unsigned int arg2 ;
48805   float arg3 ;
48806
48807   arg1 = (Dali::Toolkit::TableView *)jarg1;
48808   arg2 = (unsigned int)jarg2;
48809   arg3 = (float)jarg3;
48810   {
48811     try {
48812       (arg1)->SetRelativeWidth(arg2,arg3);
48813     } CALL_CATCH_EXCEPTION();
48814   }
48815
48816 }
48817
48818
48819 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
48820   float jresult ;
48821   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48822   unsigned int arg2 ;
48823   float result;
48824
48825   arg1 = (Dali::Toolkit::TableView *)jarg1;
48826   arg2 = (unsigned int)jarg2;
48827   {
48828     try {
48829       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
48830     } CALL_CATCH_EXCEPTION(0);
48831   }
48832
48833   jresult = result;
48834   return jresult;
48835 }
48836
48837
48838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
48839   unsigned int jresult ;
48840   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48841   unsigned int result;
48842
48843   arg1 = (Dali::Toolkit::TableView *)jarg1;
48844   {
48845     try {
48846       result = (unsigned int)(arg1)->GetRows();
48847     } CALL_CATCH_EXCEPTION(0);
48848   }
48849
48850   jresult = result;
48851   return jresult;
48852 }
48853
48854
48855 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
48856   unsigned int jresult ;
48857   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48858   unsigned int result;
48859
48860   arg1 = (Dali::Toolkit::TableView *)jarg1;
48861   {
48862     try {
48863       result = (unsigned int)(arg1)->GetColumns();
48864     } CALL_CATCH_EXCEPTION(0);
48865   }
48866
48867   jresult = result;
48868   return jresult;
48869 }
48870
48871
48872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
48873   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48874   Dali::Toolkit::TableView::CellPosition arg2 ;
48875   Dali::HorizontalAlignment::Type arg3 ;
48876   Dali::VerticalAlignment::Type arg4 ;
48877   Dali::Toolkit::TableView::CellPosition *argp2 ;
48878
48879   arg1 = (Dali::Toolkit::TableView *)jarg1;
48880   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
48881   if (!argp2) {
48882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
48883     return ;
48884   }
48885   arg2 = *argp2;
48886   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
48887   arg4 = (Dali::VerticalAlignment::Type)jarg4;
48888   {
48889     try {
48890       (arg1)->SetCellAlignment(arg2,arg3,arg4);
48891     } CALL_CATCH_EXCEPTION();
48892   }
48893
48894 }
48895
48896
48897 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
48898   unsigned int jresult ;
48899   unsigned int result;
48900
48901   result = (unsigned int)(unsigned int)Dali::Toolkit::DevelText::DEFAULT_RENDERING_BACKEND;
48902   jresult = result;
48903   return jresult;
48904 }
48905
48906
48907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
48908   int jresult ;
48909   int result;
48910
48911   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
48912   jresult = (int)result;
48913   return jresult;
48914 }
48915
48916
48917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
48918   int jresult ;
48919   int result;
48920
48921   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
48922   jresult = (int)result;
48923   return jresult;
48924 }
48925
48926
48927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
48928   int jresult ;
48929   int result;
48930
48931   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
48932   jresult = (int)result;
48933   return jresult;
48934 }
48935
48936
48937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
48938   int jresult ;
48939   int result;
48940
48941   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
48942   jresult = (int)result;
48943   return jresult;
48944 }
48945
48946
48947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
48948   int jresult ;
48949   int result;
48950
48951   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
48952   jresult = (int)result;
48953   return jresult;
48954 }
48955
48956
48957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
48958   int jresult ;
48959   int result;
48960
48961   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
48962   jresult = (int)result;
48963   return jresult;
48964 }
48965
48966
48967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
48968   int jresult ;
48969   int result;
48970
48971   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
48972   jresult = (int)result;
48973   return jresult;
48974 }
48975
48976
48977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
48978   int jresult ;
48979   int result;
48980
48981   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
48982   jresult = (int)result;
48983   return jresult;
48984 }
48985
48986
48987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
48988   int jresult ;
48989   int result;
48990
48991   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
48992   jresult = (int)result;
48993   return jresult;
48994 }
48995
48996
48997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
48998   int jresult ;
48999   int result;
49000
49001   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
49002   jresult = (int)result;
49003   return jresult;
49004 }
49005
49006
49007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
49008   int jresult ;
49009   int result;
49010
49011   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
49012   jresult = (int)result;
49013   return jresult;
49014 }
49015
49016
49017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
49018   int jresult ;
49019   int result;
49020
49021   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
49022   jresult = (int)result;
49023   return jresult;
49024 }
49025
49026
49027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
49028   int jresult ;
49029   int result;
49030
49031   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
49032   jresult = (int)result;
49033   return jresult;
49034 }
49035
49036
49037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
49038   int jresult ;
49039   int result;
49040
49041   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
49042   jresult = (int)result;
49043   return jresult;
49044 }
49045
49046
49047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
49048   int jresult ;
49049   int result;
49050
49051   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
49052   jresult = (int)result;
49053   return jresult;
49054 }
49055
49056
49057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
49058   int jresult ;
49059   int result;
49060
49061   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
49062   jresult = (int)result;
49063   return jresult;
49064 }
49065
49066
49067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
49068   int jresult ;
49069   int result;
49070
49071   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
49072   jresult = (int)result;
49073   return jresult;
49074 }
49075
49076
49077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
49078   int jresult ;
49079   int result;
49080
49081   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
49082   jresult = (int)result;
49083   return jresult;
49084 }
49085
49086
49087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
49088   void * jresult ;
49089   Dali::Toolkit::TextLabel::Property *result = 0 ;
49090
49091   {
49092     try {
49093       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
49094     } CALL_CATCH_EXCEPTION(0);
49095   }
49096
49097   jresult = (void *)result;
49098   return jresult;
49099 }
49100
49101
49102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
49103   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
49104
49105   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
49106   {
49107     try {
49108       delete arg1;
49109     } CALL_CATCH_EXCEPTION();
49110   }
49111
49112 }
49113
49114
49115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
49116   void * jresult ;
49117   Dali::Toolkit::TextLabel result;
49118
49119   {
49120     try {
49121       result = Dali::Toolkit::TextLabel::New();
49122     } CALL_CATCH_EXCEPTION(0);
49123   }
49124
49125   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
49126   return jresult;
49127 }
49128
49129
49130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * text) {
49131   void * jresult ;
49132   std::string *arg1 = 0 ;
49133   Dali::Toolkit::TextLabel result;
49134
49135   if (!text) {
49136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49137     return 0;
49138   }
49139   std::string arg1_str(text);
49140   arg1 = &arg1_str;
49141   {
49142     try {
49143       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
49144     } CALL_CATCH_EXCEPTION(0);
49145   }
49146
49147   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
49148
49149   //argout typemap for const std::string&
49150
49151   return jresult;
49152 }
49153
49154
49155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New_With_Style(bool hasStyle) {
49156   void * jresult ;
49157   Dali::Toolkit::TextLabel result;
49158
49159   {
49160     try {
49161       if (hasStyle) {
49162         result = Dali::Toolkit::TextLabel::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
49163       } else {
49164         result = Dali::Toolkit::TextLabel::New();
49165       }
49166     } CALL_CATCH_EXCEPTION(0);
49167   }
49168
49169   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
49170   return jresult;
49171 }
49172
49173
49174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New_With_String_Style(char * text, bool hasStyle) {
49175   void * jresult ;
49176   std::string *arg1 = 0 ;
49177   Dali::Toolkit::TextLabel result;
49178
49179   if (!text) {
49180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49181     return 0;
49182   }
49183   std::string arg1_str(text);
49184   arg1 = &arg1_str;
49185   {
49186     try {
49187       if (hasStyle) {
49188         result = Dali::Toolkit::TextLabel::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS, (std::string const &)*arg1);
49189       } else {
49190         result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
49191       }
49192     } CALL_CATCH_EXCEPTION(0);
49193   }
49194
49195   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
49196
49197   //argout typemap for const std::string&
49198
49199   return jresult;
49200 }
49201
49202
49203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
49204   void * jresult ;
49205   Dali::Toolkit::TextLabel *result = 0 ;
49206
49207   {
49208     try {
49209       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
49210     } CALL_CATCH_EXCEPTION(0);
49211   }
49212
49213   jresult = (void *)result;
49214   return jresult;
49215 }
49216
49217
49218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
49219   void * jresult ;
49220   Dali::Toolkit::TextLabel *arg1 = 0 ;
49221   Dali::Toolkit::TextLabel *result = 0 ;
49222
49223   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
49224   if (!arg1) {
49225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
49226     return 0;
49227   }
49228   {
49229     try {
49230       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
49231     } CALL_CATCH_EXCEPTION(0);
49232   }
49233
49234   jresult = (void *)result;
49235   return jresult;
49236 }
49237
49238
49239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
49240   void * jresult ;
49241   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
49242   Dali::Toolkit::TextLabel *arg2 = 0 ;
49243   Dali::Toolkit::TextLabel *result = 0 ;
49244
49245   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
49246   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
49247   if (!arg2) {
49248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
49249     return 0;
49250   }
49251   {
49252     try {
49253       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
49254     } CALL_CATCH_EXCEPTION(0);
49255   }
49256
49257   jresult = (void *)result;
49258   return jresult;
49259 }
49260
49261
49262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
49263   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
49264
49265   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
49266   {
49267     try {
49268       delete arg1;
49269     } CALL_CATCH_EXCEPTION();
49270   }
49271
49272 }
49273
49274
49275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
49276   void * jresult ;
49277   Dali::BaseHandle arg1 ;
49278   Dali::BaseHandle *argp1 ;
49279   Dali::Toolkit::TextLabel result;
49280
49281   argp1 = (Dali::BaseHandle *)jarg1;
49282   if (!argp1) {
49283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49284     return 0;
49285   }
49286   arg1 = *argp1;
49287   {
49288     try {
49289       result = Dali::Toolkit::TextLabel::DownCast(arg1);
49290     } CALL_CATCH_EXCEPTION(0);
49291   }
49292
49293   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
49294   return jresult;
49295 }
49296
49297
49298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
49299   void * jresult ;
49300   Dali::Toolkit::AccessibilityManager *result = 0 ;
49301
49302   {
49303     try {
49304       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
49305     } CALL_CATCH_EXCEPTION(0);
49306   }
49307
49308   jresult = (void *)result;
49309   return jresult;
49310 }
49311
49312
49313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
49314   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49315
49316   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49317   {
49318     try {
49319       delete arg1;
49320     } CALL_CATCH_EXCEPTION();
49321   }
49322
49323 }
49324
49325
49326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
49327   void * jresult ;
49328   Dali::Toolkit::AccessibilityManager result;
49329
49330   {
49331     try {
49332       result = Dali::Toolkit::AccessibilityManager::Get();
49333     } CALL_CATCH_EXCEPTION(0);
49334   }
49335
49336   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
49337   return jresult;
49338 }
49339
49340
49341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
49342   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49343   Dali::Actor arg2 ;
49344   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
49345   std::string *arg4 = 0 ;
49346   Dali::Actor *argp2 ;
49347
49348   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49349   argp2 = (Dali::Actor *)jarg2;
49350   if (!argp2) {
49351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49352     return ;
49353   }
49354   arg2 = *argp2;
49355   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
49356   if (!jarg4) {
49357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49358     return ;
49359   }
49360   std::string arg4_str(jarg4);
49361   arg4 = &arg4_str;
49362   {
49363     try {
49364       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
49365     } CALL_CATCH_EXCEPTION();
49366   }
49367
49368
49369   //argout typemap for const std::string&
49370
49371 }
49372
49373
49374 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
49375   char * jresult ;
49376   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49377   Dali::Actor arg2 ;
49378   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
49379   Dali::Actor *argp2 ;
49380   std::string result;
49381
49382   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49383   argp2 = (Dali::Actor *)jarg2;
49384   if (!argp2) {
49385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49386     return 0;
49387   }
49388   arg2 = *argp2;
49389   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
49390   {
49391     try {
49392       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
49393     } CALL_CATCH_EXCEPTION(0);
49394   }
49395
49396   jresult = SWIG_csharp_string_callback((&result)->c_str());
49397   return jresult;
49398 }
49399
49400
49401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
49402   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49403   Dali::Actor arg2 ;
49404   unsigned int arg3 ;
49405   Dali::Actor *argp2 ;
49406
49407   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49408   argp2 = (Dali::Actor *)jarg2;
49409   if (!argp2) {
49410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49411     return ;
49412   }
49413   arg2 = *argp2;
49414   arg3 = (unsigned int)jarg3;
49415   {
49416     try {
49417       (arg1)->SetFocusOrder(arg2,arg3);
49418     } CALL_CATCH_EXCEPTION();
49419   }
49420
49421 }
49422
49423
49424 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
49425   unsigned int jresult ;
49426   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49427   Dali::Actor arg2 ;
49428   Dali::Actor *argp2 ;
49429   unsigned int result;
49430
49431   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49432   argp2 = (Dali::Actor *)jarg2;
49433   if (!argp2) {
49434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49435     return 0;
49436   }
49437   arg2 = *argp2;
49438   {
49439     try {
49440       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
49441     } CALL_CATCH_EXCEPTION(0);
49442   }
49443
49444   jresult = result;
49445   return jresult;
49446 }
49447
49448
49449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
49450   unsigned int jresult ;
49451   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49452   unsigned int result;
49453
49454   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49455   {
49456     try {
49457       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
49458     } CALL_CATCH_EXCEPTION(0);
49459   }
49460
49461   jresult = result;
49462   return jresult;
49463 }
49464
49465
49466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
49467   void * jresult ;
49468   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49469   unsigned int arg2 ;
49470   Dali::Actor result;
49471
49472   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49473   arg2 = (unsigned int)jarg2;
49474   {
49475     try {
49476       result = (arg1)->GetActorByFocusOrder(arg2);
49477     } CALL_CATCH_EXCEPTION(0);
49478   }
49479
49480   jresult = new Dali::Actor((const Dali::Actor &)result);
49481   return jresult;
49482 }
49483
49484
49485 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
49486   bool jresult ;
49487   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49488   Dali::Actor arg2 ;
49489   Dali::Actor *argp2 ;
49490   bool result;
49491
49492   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49493   argp2 = (Dali::Actor *)jarg2;
49494   if (!argp2) {
49495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49496     return 0;
49497   }
49498   arg2 = *argp2;
49499   {
49500     try {
49501       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
49502     } CALL_CATCH_EXCEPTION(0);
49503   }
49504
49505   jresult = result;
49506   return jresult;
49507 }
49508
49509
49510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
49511   void * jresult ;
49512   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49513   Dali::Actor result;
49514
49515   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49516   {
49517     try {
49518       result = (arg1)->GetCurrentFocusActor();
49519     } CALL_CATCH_EXCEPTION(0);
49520   }
49521
49522   jresult = new Dali::Actor((const Dali::Actor &)result);
49523   return jresult;
49524 }
49525
49526
49527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
49528   void * jresult ;
49529   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49530   Dali::Actor result;
49531
49532   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49533   {
49534     try {
49535       result = (arg1)->GetCurrentFocusGroup();
49536     } CALL_CATCH_EXCEPTION(0);
49537   }
49538
49539   jresult = new Dali::Actor((const Dali::Actor &)result);
49540   return jresult;
49541 }
49542
49543
49544 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
49545   unsigned int jresult ;
49546   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49547   unsigned int result;
49548
49549   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49550   {
49551     try {
49552       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
49553     } CALL_CATCH_EXCEPTION(0);
49554   }
49555
49556   jresult = result;
49557   return jresult;
49558 }
49559
49560
49561 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
49562   bool jresult ;
49563   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49564   bool result;
49565
49566   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49567   {
49568     try {
49569       result = (bool)(arg1)->MoveFocusForward();
49570     } CALL_CATCH_EXCEPTION(0);
49571   }
49572
49573   jresult = result;
49574   return jresult;
49575 }
49576
49577
49578 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
49579   bool jresult ;
49580   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49581   bool result;
49582
49583   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49584   {
49585     try {
49586       result = (bool)(arg1)->MoveFocusBackward();
49587     } CALL_CATCH_EXCEPTION(0);
49588   }
49589
49590   jresult = result;
49591   return jresult;
49592 }
49593
49594
49595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
49596   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49597
49598   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49599   {
49600     try {
49601       (arg1)->ClearFocus();
49602     } CALL_CATCH_EXCEPTION();
49603   }
49604
49605 }
49606
49607
49608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
49609   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49610
49611   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49612   {
49613     try {
49614       (arg1)->Reset();
49615     } CALL_CATCH_EXCEPTION();
49616   }
49617
49618 }
49619
49620
49621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, bool jarg3) {
49622   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49623   Dali::Actor arg2 ;
49624   bool arg3 ;
49625   Dali::Actor *argp2 ;
49626
49627   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49628   argp2 = (Dali::Actor *)jarg2;
49629   if (!argp2) {
49630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49631     return ;
49632   }
49633   arg2 = *argp2;
49634   arg3 = jarg3 ? true : false;
49635   {
49636     try {
49637       (arg1)->SetFocusGroup(arg2,arg3);
49638     } CALL_CATCH_EXCEPTION();
49639   }
49640
49641 }
49642
49643
49644 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
49645   bool jresult ;
49646   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49647   Dali::Actor arg2 ;
49648   Dali::Actor *argp2 ;
49649   bool result;
49650
49651   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49652   argp2 = (Dali::Actor *)jarg2;
49653   if (!argp2) {
49654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49655     return 0;
49656   }
49657   arg2 = *argp2;
49658   {
49659     try {
49660       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
49661     } CALL_CATCH_EXCEPTION(0);
49662   }
49663
49664   jresult = result;
49665   return jresult;
49666 }
49667
49668
49669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, bool jarg2) {
49670   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49671   bool arg2 ;
49672
49673   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49674   arg2 = jarg2 ? true : false;
49675   {
49676     try {
49677       (arg1)->SetGroupMode(arg2);
49678     } CALL_CATCH_EXCEPTION();
49679   }
49680
49681 }
49682
49683
49684 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
49685   bool jresult ;
49686   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49687   bool result;
49688
49689   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49690   {
49691     try {
49692       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
49693     } CALL_CATCH_EXCEPTION(0);
49694   }
49695
49696   jresult = result;
49697   return jresult;
49698 }
49699
49700
49701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, bool jarg2) {
49702   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49703   bool arg2 ;
49704
49705   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49706   arg2 = jarg2 ? true : false;
49707   {
49708     try {
49709       (arg1)->SetWrapMode(arg2);
49710     } CALL_CATCH_EXCEPTION();
49711   }
49712
49713 }
49714
49715
49716 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
49717   bool jresult ;
49718   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49719   bool result;
49720
49721   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49722   {
49723     try {
49724       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
49725     } CALL_CATCH_EXCEPTION(0);
49726   }
49727
49728   jresult = result;
49729   return jresult;
49730 }
49731
49732
49733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
49734   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49735   Dali::Actor arg2 ;
49736   Dali::Actor *argp2 ;
49737
49738   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49739   argp2 = (Dali::Actor *)jarg2;
49740   if (!argp2) {
49741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49742     return ;
49743   }
49744   arg2 = *argp2;
49745   {
49746     try {
49747       (arg1)->SetFocusIndicatorActor(arg2);
49748     } CALL_CATCH_EXCEPTION();
49749   }
49750
49751 }
49752
49753
49754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
49755   void * jresult ;
49756   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49757   Dali::Actor result;
49758
49759   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49760   {
49761     try {
49762       result = (arg1)->GetFocusIndicatorActor();
49763     } CALL_CATCH_EXCEPTION(0);
49764   }
49765
49766   jresult = new Dali::Actor((const Dali::Actor &)result);
49767   return jresult;
49768 }
49769
49770
49771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
49772   void * jresult ;
49773   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49774   Dali::Actor arg2 ;
49775   Dali::Actor *argp2 ;
49776   Dali::Actor result;
49777
49778   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49779   argp2 = (Dali::Actor *)jarg2;
49780   if (!argp2) {
49781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49782     return 0;
49783   }
49784   arg2 = *argp2;
49785   {
49786     try {
49787       result = (arg1)->GetFocusGroup(arg2);
49788     } CALL_CATCH_EXCEPTION(0);
49789   }
49790
49791   jresult = new Dali::Actor((const Dali::Actor &)result);
49792   return jresult;
49793 }
49794
49795
49796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
49797   void * jresult ;
49798   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49799   Dali::Vector2 result;
49800
49801   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49802   {
49803     try {
49804       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
49805     } CALL_CATCH_EXCEPTION(0);
49806   }
49807
49808   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
49809   return jresult;
49810 }
49811
49812
49813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
49814   void * jresult ;
49815   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49816   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
49817
49818   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49819   {
49820     try {
49821       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
49822     } CALL_CATCH_EXCEPTION(0);
49823   }
49824
49825   jresult = (void *)result;
49826   return jresult;
49827 }
49828
49829
49830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
49831   void * jresult ;
49832   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49833   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
49834
49835   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49836   {
49837     try {
49838       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
49839     } CALL_CATCH_EXCEPTION(0);
49840   }
49841
49842   jresult = (void *)result;
49843   return jresult;
49844 }
49845
49846
49847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
49848   void * jresult ;
49849   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49850   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
49851
49852   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49853   {
49854     try {
49855       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
49856     } CALL_CATCH_EXCEPTION(0);
49857   }
49858
49859   jresult = (void *)result;
49860   return jresult;
49861 }
49862
49863
49864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
49865   void * jresult ;
49866   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49867   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49868
49869   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49870   {
49871     try {
49872       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
49873     } CALL_CATCH_EXCEPTION(0);
49874   }
49875
49876   jresult = (void *)result;
49877   return jresult;
49878 }
49879
49880
49881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
49882   void * jresult ;
49883   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49884   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49885
49886   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49887   {
49888     try {
49889       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
49890     } CALL_CATCH_EXCEPTION(0);
49891   }
49892
49893   jresult = (void *)result;
49894   return jresult;
49895 }
49896
49897
49898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
49899   void * jresult ;
49900   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49901   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49902
49903   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49904   {
49905     try {
49906       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
49907     } CALL_CATCH_EXCEPTION(0);
49908   }
49909
49910   jresult = (void *)result;
49911   return jresult;
49912 }
49913
49914
49915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
49916   void * jresult ;
49917   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49918   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49919
49920   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49921   {
49922     try {
49923       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
49924     } CALL_CATCH_EXCEPTION(0);
49925   }
49926
49927   jresult = (void *)result;
49928   return jresult;
49929 }
49930
49931
49932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
49933   void * jresult ;
49934   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49935   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49936
49937   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49938   {
49939     try {
49940       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
49941     } CALL_CATCH_EXCEPTION(0);
49942   }
49943
49944   jresult = (void *)result;
49945   return jresult;
49946 }
49947
49948
49949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
49950   void * jresult ;
49951   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49952   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49953
49954   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49955   {
49956     try {
49957       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
49958     } CALL_CATCH_EXCEPTION(0);
49959   }
49960
49961   jresult = (void *)result;
49962   return jresult;
49963 }
49964
49965
49966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
49967   void * jresult ;
49968   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49969   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49970
49971   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49972   {
49973     try {
49974       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
49975     } CALL_CATCH_EXCEPTION(0);
49976   }
49977
49978   jresult = (void *)result;
49979   return jresult;
49980 }
49981
49982
49983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
49984   void * jresult ;
49985   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49986   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49987
49988   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49989   {
49990     try {
49991       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
49992     } CALL_CATCH_EXCEPTION(0);
49993   }
49994
49995   jresult = (void *)result;
49996   return jresult;
49997 }
49998
49999
50000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
50001   void * jresult ;
50002   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50003   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50004
50005   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50006   {
50007     try {
50008       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
50009     } CALL_CATCH_EXCEPTION(0);
50010   }
50011
50012   jresult = (void *)result;
50013   return jresult;
50014 }
50015
50016
50017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
50018   void * jresult ;
50019   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50020   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50021
50022   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50023   {
50024     try {
50025       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
50026     } CALL_CATCH_EXCEPTION(0);
50027   }
50028
50029   jresult = (void *)result;
50030   return jresult;
50031 }
50032
50033
50034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
50035   void * jresult ;
50036   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50037   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50038
50039   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50040   {
50041     try {
50042       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
50043     } CALL_CATCH_EXCEPTION(0);
50044   }
50045
50046   jresult = (void *)result;
50047   return jresult;
50048 }
50049
50050
50051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
50052   void * jresult ;
50053   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50054   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50055
50056   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50057   {
50058     try {
50059       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
50060     } CALL_CATCH_EXCEPTION(0);
50061   }
50062
50063   jresult = (void *)result;
50064   return jresult;
50065 }
50066
50067
50068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
50069   void * jresult ;
50070   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50071   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50072
50073   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50074   {
50075     try {
50076       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
50077     } CALL_CATCH_EXCEPTION(0);
50078   }
50079
50080   jresult = (void *)result;
50081   return jresult;
50082 }
50083
50084
50085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
50086   void * jresult ;
50087   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50088   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50089
50090   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50091   {
50092     try {
50093       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
50094     } CALL_CATCH_EXCEPTION(0);
50095   }
50096
50097   jresult = (void *)result;
50098   return jresult;
50099 }
50100
50101
50102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
50103   void * jresult ;
50104   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50105   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50106
50107   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50108   {
50109     try {
50110       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
50111     } CALL_CATCH_EXCEPTION(0);
50112   }
50113
50114   jresult = (void *)result;
50115   return jresult;
50116 }
50117
50118
50119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
50120   void * jresult ;
50121   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50122   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50123
50124   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50125   {
50126     try {
50127       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
50128     } CALL_CATCH_EXCEPTION(0);
50129   }
50130
50131   jresult = (void *)result;
50132   return jresult;
50133 }
50134
50135
50136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
50137   void * jresult ;
50138   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50139   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50140
50141   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50142   {
50143     try {
50144       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
50145     } CALL_CATCH_EXCEPTION(0);
50146   }
50147
50148   jresult = (void *)result;
50149   return jresult;
50150 }
50151
50152
50153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
50154   void * jresult ;
50155   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50156   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50157
50158   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50159   {
50160     try {
50161       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
50162     } CALL_CATCH_EXCEPTION(0);
50163   }
50164
50165   jresult = (void *)result;
50166   return jresult;
50167 }
50168
50169
50170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
50171   void * jresult ;
50172   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50173   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50174
50175   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50176   {
50177     try {
50178       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
50179     } CALL_CATCH_EXCEPTION(0);
50180   }
50181
50182   jresult = (void *)result;
50183   return jresult;
50184 }
50185
50186
50187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
50188   void * jresult ;
50189   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50190   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50191
50192   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50193   {
50194     try {
50195       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
50196     } CALL_CATCH_EXCEPTION(0);
50197   }
50198
50199   jresult = (void *)result;
50200   return jresult;
50201 }
50202
50203
50204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
50205   void * jresult ;
50206   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50207   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50208
50209   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50210   {
50211     try {
50212       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
50213     } CALL_CATCH_EXCEPTION(0);
50214   }
50215
50216   jresult = (void *)result;
50217   return jresult;
50218 }
50219
50220
50221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
50222   void * jresult ;
50223   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50224   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50225
50226   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50227   {
50228     try {
50229       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
50230     } CALL_CATCH_EXCEPTION(0);
50231   }
50232
50233   jresult = (void *)result;
50234   return jresult;
50235 }
50236
50237
50238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
50239   void * jresult ;
50240   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50241   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50242
50243   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50244   {
50245     try {
50246       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
50247     } CALL_CATCH_EXCEPTION(0);
50248   }
50249
50250   jresult = (void *)result;
50251   return jresult;
50252 }
50253
50254
50255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
50256   void * jresult ;
50257   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50258   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50259
50260   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50261   {
50262     try {
50263       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
50264     } CALL_CATCH_EXCEPTION(0);
50265   }
50266
50267   jresult = (void *)result;
50268   return jresult;
50269 }
50270
50271
50272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
50273   void * jresult ;
50274   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50275   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50276
50277   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50278   {
50279     try {
50280       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
50281     } CALL_CATCH_EXCEPTION(0);
50282   }
50283
50284   jresult = (void *)result;
50285   return jresult;
50286 }
50287
50288
50289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
50290   void * jresult ;
50291   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50292   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
50293
50294   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50295   {
50296     try {
50297       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
50298     } CALL_CATCH_EXCEPTION(0);
50299   }
50300
50301   jresult = (void *)result;
50302   return jresult;
50303 }
50304
50305
50306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
50307   void * jresult ;
50308   Dali::Toolkit::StyleManager *result = 0 ;
50309
50310   {
50311     try {
50312       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
50313     } CALL_CATCH_EXCEPTION(0);
50314   }
50315
50316   jresult = (void *)result;
50317   return jresult;
50318 }
50319
50320
50321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
50322   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
50323
50324   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
50325   {
50326     try {
50327       delete arg1;
50328     } CALL_CATCH_EXCEPTION();
50329   }
50330
50331 }
50332
50333
50334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
50335   void * jresult ;
50336   Dali::Toolkit::StyleManager result;
50337
50338   {
50339     try {
50340       result = Dali::Toolkit::StyleManager::Get();
50341     } CALL_CATCH_EXCEPTION(0);
50342   }
50343
50344   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
50345   return jresult;
50346 }
50347
50348
50349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
50350   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
50351   std::string *arg2 = 0 ;
50352
50353   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
50354   if (!jarg2) {
50355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
50356     return ;
50357   }
50358   std::string arg2_str(jarg2);
50359   arg2 = &arg2_str;
50360   {
50361     try {
50362       (arg1)->ApplyTheme((std::string const &)*arg2);
50363     } CALL_CATCH_EXCEPTION();
50364   }
50365
50366
50367   //argout typemap for const std::string&
50368
50369 }
50370
50371
50372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
50373   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
50374
50375   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
50376   {
50377     try {
50378       (arg1)->ApplyDefaultTheme();
50379     } CALL_CATCH_EXCEPTION();
50380   }
50381
50382 }
50383
50384
50385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
50386   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
50387   std::string *arg2 = 0 ;
50388   Dali::Property::Value *arg3 = 0 ;
50389
50390   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
50391   if (!jarg2) {
50392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
50393     return ;
50394   }
50395   std::string arg2_str(jarg2);
50396   arg2 = &arg2_str;
50397   arg3 = (Dali::Property::Value *)jarg3;
50398   if (!arg3) {
50399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
50400     return ;
50401   }
50402   {
50403     try {
50404       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
50405     } CALL_CATCH_EXCEPTION();
50406   }
50407
50408
50409   //argout typemap for const std::string&
50410
50411 }
50412
50413
50414 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
50415   bool jresult ;
50416   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
50417   std::string *arg2 = 0 ;
50418   Dali::Property::Value *arg3 = 0 ;
50419   bool result;
50420
50421   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
50422   if (!jarg2) {
50423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
50424     return 0;
50425   }
50426   std::string arg2_str(jarg2);
50427   arg2 = &arg2_str;
50428   arg3 = (Dali::Property::Value *)jarg3;
50429   if (!arg3) {
50430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
50431     return 0;
50432   }
50433   {
50434     try {
50435       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
50436     } CALL_CATCH_EXCEPTION(0);
50437   }
50438
50439   jresult = result;
50440
50441   //argout typemap for const std::string&
50442
50443   return jresult;
50444 }
50445
50446
50447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
50448   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
50449   Dali::Toolkit::Control arg2 ;
50450   std::string *arg3 = 0 ;
50451   std::string *arg4 = 0 ;
50452   Dali::Toolkit::Control *argp2 ;
50453
50454   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
50455   argp2 = (Dali::Toolkit::Control *)jarg2;
50456   if (!argp2) {
50457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
50458     return ;
50459   }
50460   arg2 = *argp2;
50461   if (!jarg3) {
50462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
50463     return ;
50464   }
50465   std::string arg3_str(jarg3);
50466   arg3 = &arg3_str;
50467   if (!jarg4) {
50468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
50469     return ;
50470   }
50471   std::string arg4_str(jarg4);
50472   arg4 = &arg4_str;
50473   {
50474     try {
50475       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
50476     } CALL_CATCH_EXCEPTION();
50477   }
50478
50479
50480   //argout typemap for const std::string&
50481
50482
50483   //argout typemap for const std::string&
50484
50485 }
50486
50487
50488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
50489   void * jresult ;
50490   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
50491   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
50492
50493   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
50494   {
50495     try {
50496       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
50497     } CALL_CATCH_EXCEPTION(0);
50498   }
50499
50500   jresult = (void *)result;
50501   return jresult;
50502 }
50503
50504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
50505   int jresult ;
50506   int result;
50507
50508   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
50509   jresult = (int)result;
50510   return jresult;
50511 }
50512
50513
50514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
50515   int jresult ;
50516   int result;
50517
50518   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
50519   jresult = (int)result;
50520   return jresult;
50521 }
50522
50523
50524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
50525   int jresult ;
50526   int result;
50527
50528   result = (int)Dali::Toolkit::Slider::Property::VALUE;
50529   jresult = (int)result;
50530   return jresult;
50531 }
50532
50533
50534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
50535   int jresult ;
50536   int result;
50537
50538   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
50539   jresult = (int)result;
50540   return jresult;
50541 }
50542
50543
50544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
50545   int jresult ;
50546   int result;
50547
50548   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
50549   jresult = (int)result;
50550   return jresult;
50551 }
50552
50553
50554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
50555   int jresult ;
50556   int result;
50557
50558   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
50559   jresult = (int)result;
50560   return jresult;
50561 }
50562
50563
50564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
50565   int jresult ;
50566   int result;
50567
50568   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
50569   jresult = (int)result;
50570   return jresult;
50571 }
50572
50573
50574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
50575   int jresult ;
50576   int result;
50577
50578   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
50579   jresult = (int)result;
50580   return jresult;
50581 }
50582
50583
50584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
50585   int jresult ;
50586   int result;
50587
50588   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
50589   jresult = (int)result;
50590   return jresult;
50591 }
50592
50593
50594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
50595   int jresult ;
50596   int result;
50597
50598   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
50599   jresult = (int)result;
50600   return jresult;
50601 }
50602
50603
50604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
50605   int jresult ;
50606   int result;
50607
50608   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
50609   jresult = (int)result;
50610   return jresult;
50611 }
50612
50613
50614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
50615   int jresult ;
50616   int result;
50617
50618   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
50619   jresult = (int)result;
50620   return jresult;
50621 }
50622
50623
50624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
50625   int jresult ;
50626   int result;
50627
50628   result = (int)Dali::Toolkit::Slider::Property::MARKS;
50629   jresult = (int)result;
50630   return jresult;
50631 }
50632
50633
50634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
50635   int jresult ;
50636   int result;
50637
50638   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
50639   jresult = (int)result;
50640   return jresult;
50641 }
50642
50643
50644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
50645   int jresult ;
50646   int result;
50647
50648   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
50649   jresult = (int)result;
50650   return jresult;
50651 }
50652
50653
50654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
50655   void * jresult ;
50656   Dali::Toolkit::Slider::Property *result = 0 ;
50657
50658   {
50659     try {
50660       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
50661     } CALL_CATCH_EXCEPTION(0);
50662   }
50663
50664   jresult = (void *)result;
50665   return jresult;
50666 }
50667
50668
50669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
50670   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
50671
50672   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
50673   {
50674     try {
50675       delete arg1;
50676     } CALL_CATCH_EXCEPTION();
50677   }
50678
50679 }
50680
50681
50682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
50683   void * jresult ;
50684   Dali::Toolkit::Slider result;
50685
50686   {
50687     try {
50688       result = Dali::Toolkit::Slider::New();
50689     } CALL_CATCH_EXCEPTION(0);
50690   }
50691
50692   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
50693   return jresult;
50694 }
50695
50696
50697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
50698   void * jresult ;
50699   Dali::Toolkit::Slider *result = 0 ;
50700
50701   {
50702     try {
50703       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
50704     } CALL_CATCH_EXCEPTION(0);
50705   }
50706
50707   jresult = (void *)result;
50708   return jresult;
50709 }
50710
50711
50712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
50713   void * jresult ;
50714   Dali::Toolkit::Slider *arg1 = 0 ;
50715   Dali::Toolkit::Slider *result = 0 ;
50716
50717   arg1 = (Dali::Toolkit::Slider *)jarg1;
50718   if (!arg1) {
50719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
50720     return 0;
50721   }
50722   {
50723     try {
50724       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
50725     } CALL_CATCH_EXCEPTION(0);
50726   }
50727
50728   jresult = (void *)result;
50729   return jresult;
50730 }
50731
50732
50733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
50734   void * jresult ;
50735   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
50736   Dali::Toolkit::Slider *arg2 = 0 ;
50737   Dali::Toolkit::Slider *result = 0 ;
50738
50739   arg1 = (Dali::Toolkit::Slider *)jarg1;
50740   arg2 = (Dali::Toolkit::Slider *)jarg2;
50741   if (!arg2) {
50742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
50743     return 0;
50744   }
50745   {
50746     try {
50747       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
50748     } CALL_CATCH_EXCEPTION(0);
50749   }
50750
50751   jresult = (void *)result;
50752   return jresult;
50753 }
50754
50755
50756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
50757   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
50758
50759   arg1 = (Dali::Toolkit::Slider *)jarg1;
50760   {
50761     try {
50762       delete arg1;
50763     } CALL_CATCH_EXCEPTION();
50764   }
50765
50766 }
50767
50768
50769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
50770   void * jresult ;
50771   Dali::BaseHandle arg1 ;
50772   Dali::BaseHandle *argp1 ;
50773   Dali::Toolkit::Slider result;
50774
50775   argp1 = (Dali::BaseHandle *)jarg1;
50776   if (!argp1) {
50777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50778     return 0;
50779   }
50780   arg1 = *argp1;
50781   {
50782     try {
50783       result = Dali::Toolkit::Slider::DownCast(arg1);
50784     } CALL_CATCH_EXCEPTION(0);
50785   }
50786
50787   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
50788   return jresult;
50789 }
50790
50791
50792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
50793   void * jresult ;
50794   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
50795   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
50796
50797   arg1 = (Dali::Toolkit::Slider *)jarg1;
50798   {
50799     try {
50800       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
50801     } CALL_CATCH_EXCEPTION(0);
50802   }
50803
50804   jresult = (void *)result;
50805   return jresult;
50806 }
50807
50808
50809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
50810   void * jresult ;
50811   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
50812   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
50813
50814   arg1 = (Dali::Toolkit::Slider *)jarg1;
50815   {
50816     try {
50817       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
50818     } CALL_CATCH_EXCEPTION(0);
50819   }
50820
50821   jresult = (void *)result;
50822   return jresult;
50823 }
50824
50825
50826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
50827   void * jresult ;
50828   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
50829   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
50830
50831   arg1 = (Dali::Toolkit::Slider *)jarg1;
50832   {
50833     try {
50834       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
50835     } CALL_CATCH_EXCEPTION(0);
50836   }
50837
50838   jresult = (void *)result;
50839   return jresult;
50840 }
50841
50842
50843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
50844   int jresult ;
50845   int result;
50846
50847   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
50848   jresult = (int)result;
50849   return jresult;
50850 }
50851
50852
50853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
50854   int jresult ;
50855   int result;
50856
50857   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
50858   jresult = (int)result;
50859   return jresult;
50860 }
50861
50862
50863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
50864   int jresult ;
50865   int result;
50866
50867   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
50868   jresult = (int)result;
50869   return jresult;
50870 }
50871
50872
50873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
50874   int jresult ;
50875   int result;
50876
50877   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
50878   jresult = (int)result;
50879   return jresult;
50880 }
50881
50882
50883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
50884   int result;
50885
50886   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
50887
50888   return result;
50889 }
50890
50891
50892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
50893   void * jresult ;
50894   Dali::Toolkit::VideoView::Property *result = 0 ;
50895
50896   {
50897     try {
50898       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
50899     } CALL_CATCH_EXCEPTION(0);
50900   }
50901
50902   jresult = (void *)result;
50903   return jresult;
50904 }
50905
50906
50907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
50908   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
50909
50910   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
50911   {
50912     try {
50913       delete arg1;
50914     } CALL_CATCH_EXCEPTION();
50915   }
50916
50917 }
50918
50919
50920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
50921   void * jresult ;
50922   Dali::Toolkit::VideoView result;
50923
50924   {
50925     try {
50926       result = Dali::Toolkit::VideoView::New();
50927     } CALL_CATCH_EXCEPTION(0);
50928   }
50929
50930   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
50931   return jresult;
50932 }
50933
50934
50935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
50936   void * jresult ;
50937   std::string *arg1 = 0 ;
50938   Dali::Toolkit::VideoView result;
50939
50940   if (!jarg1) {
50941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
50942     return 0;
50943   }
50944   std::string arg1_str(jarg1);
50945   arg1 = &arg1_str;
50946   {
50947     try {
50948       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
50949     } CALL_CATCH_EXCEPTION(0);
50950   }
50951
50952   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
50953
50954   //argout typemap for const std::string&
50955
50956   return jresult;
50957 }
50958
50959
50960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
50961   void * jresult ;
50962   Dali::Toolkit::VideoView result;
50963   {
50964     try {
50965       result = Dali::Toolkit::VideoView::New(swCodec);
50966     } CALL_CATCH_EXCEPTION(0);
50967   }
50968
50969   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
50970
50971   //argout typemap for const std::string&
50972
50973   return jresult;
50974 }
50975
50976
50977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
50978   void * jresult ;
50979   std::string *arg1 = 0 ;
50980   Dali::Toolkit::VideoView result;
50981
50982   if (!jarg1) {
50983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
50984     return 0;
50985   }
50986   std::string arg1_str(jarg1);
50987   arg1 = &arg1_str;
50988   {
50989     try {
50990       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
50991     } CALL_CATCH_EXCEPTION(0);
50992   }
50993
50994   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
50995
50996   //argout typemap for const std::string&
50997
50998   return jresult;
50999 }
51000
51001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_4(unsigned int jarg1) {
51002   void * jresult ;
51003   Dali::VideoSyncMode syncMode;
51004   Dali::Toolkit::VideoView result;
51005
51006   syncMode = static_cast<Dali::VideoSyncMode>(jarg1);
51007
51008   {
51009     try {
51010       result = Dali::Toolkit::DevelVideoView::New(syncMode);
51011     } CALL_CATCH_EXCEPTION(0);
51012   }
51013
51014   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
51015
51016   return jresult;
51017 }
51018
51019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
51020   void * jresult ;
51021   Dali::Toolkit::VideoView *result = 0 ;
51022
51023   {
51024     try {
51025       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
51026     } CALL_CATCH_EXCEPTION(0);
51027   }
51028
51029   jresult = (void *)result;
51030   return jresult;
51031 }
51032
51033
51034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
51035   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
51036
51037   arg1 = (Dali::Toolkit::VideoView *)jarg1;
51038   {
51039     try {
51040       delete arg1;
51041     } CALL_CATCH_EXCEPTION();
51042   }
51043
51044 }
51045
51046
51047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
51048   void * jresult ;
51049   Dali::Toolkit::VideoView *arg1 = 0 ;
51050   Dali::Toolkit::VideoView *result = 0 ;
51051
51052   arg1 = (Dali::Toolkit::VideoView *)jarg1;
51053   if (!arg1) {
51054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
51055     return 0;
51056   }
51057   {
51058     try {
51059       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
51060     } CALL_CATCH_EXCEPTION(0);
51061   }
51062
51063   jresult = (void *)result;
51064   return jresult;
51065 }
51066
51067
51068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
51069   void * jresult ;
51070   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
51071   Dali::Toolkit::VideoView *arg2 = 0 ;
51072   Dali::Toolkit::VideoView *result = 0 ;
51073
51074   arg1 = (Dali::Toolkit::VideoView *)jarg1;
51075   arg2 = (Dali::Toolkit::VideoView *)jarg2;
51076   if (!arg2) {
51077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
51078     return 0;
51079   }
51080   {
51081     try {
51082       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
51083     } CALL_CATCH_EXCEPTION(0);
51084   }
51085
51086   jresult = (void *)result;
51087   return jresult;
51088 }
51089
51090
51091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
51092   void * jresult ;
51093   Dali::BaseHandle arg1 ;
51094   Dali::BaseHandle *argp1 ;
51095   Dali::Toolkit::VideoView result;
51096
51097   argp1 = (Dali::BaseHandle *)jarg1;
51098   if (!argp1) {
51099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51100     return 0;
51101   }
51102   arg1 = *argp1;
51103   {
51104     try {
51105       result = Dali::Toolkit::VideoView::DownCast(arg1);
51106     } CALL_CATCH_EXCEPTION(0);
51107   }
51108
51109   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
51110   return jresult;
51111 }
51112
51113
51114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
51115   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
51116
51117   arg1 = (Dali::Toolkit::VideoView *)jarg1;
51118   {
51119     try {
51120       (arg1)->Play();
51121     } CALL_CATCH_EXCEPTION();
51122   }
51123
51124 }
51125
51126
51127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
51128   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
51129
51130   arg1 = (Dali::Toolkit::VideoView *)jarg1;
51131   {
51132     try {
51133       (arg1)->Pause();
51134     } CALL_CATCH_EXCEPTION();
51135   }
51136
51137 }
51138
51139
51140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
51141   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
51142
51143   arg1 = (Dali::Toolkit::VideoView *)jarg1;
51144   {
51145     try {
51146       (arg1)->Stop();
51147     } CALL_CATCH_EXCEPTION();
51148   }
51149
51150 }
51151
51152
51153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
51154   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
51155   int arg2 ;
51156
51157   arg1 = (Dali::Toolkit::VideoView *)jarg1;
51158   arg2 = (int)jarg2;
51159   {
51160     try {
51161       (arg1)->Forward(arg2);
51162     } CALL_CATCH_EXCEPTION();
51163   }
51164
51165 }
51166
51167
51168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
51169   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
51170   int arg2 ;
51171
51172   arg1 = (Dali::Toolkit::VideoView *)jarg1;
51173   arg2 = (int)jarg2;
51174   {
51175     try {
51176       (arg1)->Backward(arg2);
51177     } CALL_CATCH_EXCEPTION();
51178   }
51179
51180 }
51181
51182
51183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
51184   void * jresult ;
51185   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
51186   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
51187
51188   arg1 = (Dali::Toolkit::VideoView *)jarg1;
51189   {
51190     try {
51191       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
51192     } CALL_CATCH_EXCEPTION(0);
51193   }
51194
51195   jresult = (void *)result;
51196   return jresult;
51197 }
51198
51199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle(void * jarg1)
51200 {
51201   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
51202   if( arg1 == nullptr )
51203   {
51204     DALI_LOG_ERROR("VideoView is nullptr!");
51205     return nullptr;
51206   }
51207   void * ret = nullptr;
51208   {
51209     try{
51210
51211       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
51212       ret = Dali::AnyCast< void * >( result );
51213
51214     } CALL_CATCH_EXCEPTION(0);
51215   }
51216   return ret;
51217 }
51218
51219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraView_New__SWIG_0(void * jarg1, int jarg2) {
51220   void * jresult ;
51221   Dali::Toolkit::CameraView result;
51222
51223   Dali::Any arg1(jarg1);
51224   Dali::Toolkit::CameraView::DisplayType arg2 = static_cast<Dali::Toolkit::CameraView::DisplayType>(jarg2);
51225   {
51226     try {
51227       result = Dali::Toolkit::CameraView::New(arg1, arg2);
51228     } CALL_CATCH_EXCEPTION(0);
51229   }
51230
51231   jresult = new Dali::Toolkit::CameraView((const Dali::Toolkit::CameraView &)result);
51232   return jresult;
51233 }
51234
51235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraView__SWIG_0() {
51236   void * jresult ;
51237   Dali::Toolkit::CameraView *result = 0 ;
51238
51239   {
51240     try {
51241       result = (Dali::Toolkit::CameraView *)new Dali::Toolkit::CameraView();
51242     } CALL_CATCH_EXCEPTION(0);
51243   }
51244
51245   jresult = (void *)result;
51246   return jresult;
51247 }
51248
51249
51250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraView(void * jarg1) {
51251   Dali::Toolkit::CameraView *arg1 = (Dali::Toolkit::CameraView *) 0 ;
51252
51253   arg1 = (Dali::Toolkit::CameraView *)jarg1;
51254   {
51255     try {
51256       delete arg1;
51257     } CALL_CATCH_EXCEPTION();
51258   }
51259
51260 }
51261
51262
51263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraView__SWIG_1(void * jarg1) {
51264   void * jresult ;
51265   Dali::Toolkit::CameraView *arg1 = 0 ;
51266   Dali::Toolkit::CameraView *result = 0 ;
51267
51268   arg1 = (Dali::Toolkit::CameraView *)jarg1;
51269   if (!arg1) {
51270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CameraView const & type is null", 0);
51271     return 0;
51272   }
51273   {
51274     try {
51275       result = (Dali::Toolkit::CameraView *)new Dali::Toolkit::CameraView((Dali::Toolkit::CameraView const &)*arg1);
51276     } CALL_CATCH_EXCEPTION(0);
51277   }
51278
51279   jresult = (void *)result;
51280   return jresult;
51281 }
51282
51283
51284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraView_Assign(void * jarg1, void * jarg2) {
51285   void * jresult ;
51286   Dali::Toolkit::CameraView *arg1 = (Dali::Toolkit::CameraView *) 0 ;
51287   Dali::Toolkit::CameraView *arg2 = 0 ;
51288   Dali::Toolkit::CameraView *result = 0 ;
51289
51290   arg1 = (Dali::Toolkit::CameraView *)jarg1;
51291   arg2 = (Dali::Toolkit::CameraView *)jarg2;
51292   if (!arg2) {
51293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CameraView const & type is null", 0);
51294     return 0;
51295   }
51296   {
51297     try {
51298       result = (Dali::Toolkit::CameraView *) &(arg1)->operator =((Dali::Toolkit::CameraView const &)*arg2);
51299     } CALL_CATCH_EXCEPTION(0);
51300   }
51301
51302   jresult = (void *)result;
51303   return jresult;
51304 }
51305
51306
51307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraView_DownCast(void * jarg1) {
51308   void * jresult ;
51309   Dali::BaseHandle arg1 ;
51310   Dali::BaseHandle *argp1 ;
51311   Dali::Toolkit::CameraView result;
51312
51313   argp1 = (Dali::BaseHandle *)jarg1;
51314   if (!argp1) {
51315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51316     return 0;
51317   }
51318   arg1 = *argp1;
51319   {
51320     try {
51321       result = Dali::Toolkit::CameraView::DownCast(arg1);
51322     } CALL_CATCH_EXCEPTION(0);
51323   }
51324
51325   jresult = new Dali::Toolkit::CameraView((const Dali::Toolkit::CameraView &)result);
51326   return jresult;
51327 }
51328
51329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraView_Update(void * jarg1) {
51330   Dali::Toolkit::CameraView *arg1 = (Dali::Toolkit::CameraView *) 0 ;
51331
51332   arg1 = (Dali::Toolkit::CameraView *)jarg1;
51333   {
51334     try {
51335       (arg1)->Update();
51336     } CALL_CATCH_EXCEPTION();
51337   }
51338 }
51339
51340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_PlayAnimation(void * jarg1, void * jarg2)
51341 {
51342   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView*)jarg1;
51343   if(arg1 == nullptr)
51344   {
51345     DALI_LOG_ERROR("VideoView is nullptr!");
51346     return;
51347   }
51348   Dali::Animation *arg2 = (Dali::Animation*)jarg2;
51349   if(arg2 == nullptr)
51350   {
51351     DALI_LOG_ERROR("Animation is nullptr!");
51352     return;
51353   }
51354
51355   {
51356     try{
51357
51358       Toolkit::DevelVideoView::PlayAnimation(*arg1, *arg2);
51359     } CALL_CATCH_EXCEPTION();
51360   }
51361
51362 }
51363
51364
51365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
51366   int jresult ;
51367   int result;
51368
51369   result = (int)Dali::Toolkit::Popup::Property::TITLE;
51370   jresult = (int)result;
51371   return jresult;
51372 }
51373
51374
51375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
51376   int jresult ;
51377   int result;
51378
51379   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
51380   jresult = (int)result;
51381   return jresult;
51382 }
51383
51384
51385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
51386   int jresult ;
51387   int result;
51388
51389   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
51390   jresult = (int)result;
51391   return jresult;
51392 }
51393
51394
51395 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
51396   int jresult ;
51397   int result;
51398
51399   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
51400   jresult = (int)result;
51401   return jresult;
51402 }
51403
51404
51405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
51406   int jresult ;
51407   int result;
51408
51409   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
51410   jresult = (int)result;
51411   return jresult;
51412 }
51413
51414
51415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
51416   int jresult ;
51417   int result;
51418
51419   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
51420   jresult = (int)result;
51421   return jresult;
51422 }
51423
51424
51425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
51426   int jresult ;
51427   int result;
51428
51429   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
51430   jresult = (int)result;
51431   return jresult;
51432 }
51433
51434
51435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
51436   int jresult ;
51437   int result;
51438
51439   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
51440   jresult = (int)result;
51441   return jresult;
51442 }
51443
51444
51445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
51446   int jresult ;
51447   int result;
51448
51449   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
51450   jresult = (int)result;
51451   return jresult;
51452 }
51453
51454
51455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
51456   int jresult ;
51457   int result;
51458
51459   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
51460   jresult = (int)result;
51461   return jresult;
51462 }
51463
51464
51465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
51466   int jresult ;
51467   int result;
51468
51469   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
51470   jresult = (int)result;
51471   return jresult;
51472 }
51473
51474
51475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
51476   int jresult ;
51477   int result;
51478
51479   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
51480   jresult = (int)result;
51481   return jresult;
51482 }
51483
51484
51485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
51486   int jresult ;
51487   int result;
51488
51489   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
51490   jresult = (int)result;
51491   return jresult;
51492 }
51493
51494
51495 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
51496   int jresult ;
51497   int result;
51498
51499   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
51500   jresult = (int)result;
51501   return jresult;
51502 }
51503
51504
51505 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
51506   int jresult ;
51507   int result;
51508
51509   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
51510   jresult = (int)result;
51511   return jresult;
51512 }
51513
51514
51515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
51516   int jresult ;
51517   int result;
51518
51519   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
51520   jresult = (int)result;
51521   return jresult;
51522 }
51523
51524
51525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
51526   int jresult ;
51527   int result;
51528
51529   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
51530   jresult = (int)result;
51531   return jresult;
51532 }
51533
51534
51535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
51536   int jresult ;
51537   int result;
51538
51539   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
51540   jresult = (int)result;
51541   return jresult;
51542 }
51543
51544
51545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
51546   int jresult ;
51547   int result;
51548
51549   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
51550   jresult = (int)result;
51551   return jresult;
51552 }
51553
51554
51555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
51556   int jresult ;
51557   int result;
51558
51559   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
51560   jresult = (int)result;
51561   return jresult;
51562 }
51563
51564
51565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
51566   int jresult ;
51567   int result;
51568
51569   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
51570   jresult = (int)result;
51571   return jresult;
51572 }
51573
51574
51575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
51576   void * jresult ;
51577   Dali::Toolkit::Popup::Property *result = 0 ;
51578
51579   {
51580     try {
51581       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
51582     } CALL_CATCH_EXCEPTION(0);
51583   }
51584
51585   jresult = (void *)result;
51586   return jresult;
51587 }
51588
51589
51590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
51591   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
51592
51593   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
51594   {
51595     try {
51596       delete arg1;
51597     } CALL_CATCH_EXCEPTION();
51598   }
51599
51600 }
51601
51602
51603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
51604   void * jresult ;
51605   Dali::Toolkit::Popup *result = 0 ;
51606
51607   {
51608     try {
51609       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
51610     } CALL_CATCH_EXCEPTION(0);
51611   }
51612
51613   jresult = (void *)result;
51614   return jresult;
51615 }
51616
51617
51618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
51619   void * jresult ;
51620   Dali::Toolkit::Popup result;
51621
51622   {
51623     try {
51624       result = Dali::Toolkit::Popup::New();
51625     } CALL_CATCH_EXCEPTION(0);
51626   }
51627
51628   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
51629   return jresult;
51630 }
51631
51632
51633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
51634   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51635
51636   arg1 = (Dali::Toolkit::Popup *)jarg1;
51637   {
51638     try {
51639       delete arg1;
51640     } CALL_CATCH_EXCEPTION();
51641   }
51642
51643 }
51644
51645
51646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
51647   void * jresult ;
51648   Dali::Toolkit::Popup *arg1 = 0 ;
51649   Dali::Toolkit::Popup *result = 0 ;
51650
51651   arg1 = (Dali::Toolkit::Popup *)jarg1;
51652   if (!arg1) {
51653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
51654     return 0;
51655   }
51656   {
51657     try {
51658       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
51659     } CALL_CATCH_EXCEPTION(0);
51660   }
51661
51662   jresult = (void *)result;
51663   return jresult;
51664 }
51665
51666
51667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
51668   void * jresult ;
51669   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51670   Dali::Toolkit::Popup *arg2 = 0 ;
51671   Dali::Toolkit::Popup *result = 0 ;
51672
51673   arg1 = (Dali::Toolkit::Popup *)jarg1;
51674   arg2 = (Dali::Toolkit::Popup *)jarg2;
51675   if (!arg2) {
51676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
51677     return 0;
51678   }
51679   {
51680     try {
51681       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
51682     } CALL_CATCH_EXCEPTION(0);
51683   }
51684
51685   jresult = (void *)result;
51686   return jresult;
51687 }
51688
51689
51690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
51691   void * jresult ;
51692   Dali::BaseHandle arg1 ;
51693   Dali::BaseHandle *argp1 ;
51694   Dali::Toolkit::Popup result;
51695
51696   argp1 = (Dali::BaseHandle *)jarg1;
51697   if (!argp1) {
51698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51699     return 0;
51700   }
51701   arg1 = *argp1;
51702   {
51703     try {
51704       result = Dali::Toolkit::Popup::DownCast(arg1);
51705     } CALL_CATCH_EXCEPTION(0);
51706   }
51707
51708   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
51709   return jresult;
51710 }
51711
51712
51713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
51714   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51715   Dali::Actor arg2 ;
51716   Dali::Actor *argp2 ;
51717
51718   arg1 = (Dali::Toolkit::Popup *)jarg1;
51719   argp2 = (Dali::Actor *)jarg2;
51720   if (!argp2) {
51721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51722     return ;
51723   }
51724   arg2 = *argp2;
51725   {
51726     try {
51727       (arg1)->SetTitle(arg2);
51728     } CALL_CATCH_EXCEPTION();
51729   }
51730
51731 }
51732
51733
51734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
51735   void * jresult ;
51736   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51737   Dali::Actor result;
51738
51739   arg1 = (Dali::Toolkit::Popup *)jarg1;
51740   {
51741     try {
51742       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
51743     } CALL_CATCH_EXCEPTION(0);
51744   }
51745
51746   jresult = new Dali::Actor((const Dali::Actor &)result);
51747   return jresult;
51748 }
51749
51750
51751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
51752   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51753   Dali::Actor arg2 ;
51754   Dali::Actor *argp2 ;
51755
51756   arg1 = (Dali::Toolkit::Popup *)jarg1;
51757   argp2 = (Dali::Actor *)jarg2;
51758   if (!argp2) {
51759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51760     return ;
51761   }
51762   arg2 = *argp2;
51763   {
51764     try {
51765       (arg1)->SetContent(arg2);
51766     } CALL_CATCH_EXCEPTION();
51767   }
51768
51769 }
51770
51771
51772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
51773   void * jresult ;
51774   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51775   Dali::Actor result;
51776
51777   arg1 = (Dali::Toolkit::Popup *)jarg1;
51778   {
51779     try {
51780       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
51781     } CALL_CATCH_EXCEPTION(0);
51782   }
51783
51784   jresult = new Dali::Actor((const Dali::Actor &)result);
51785   return jresult;
51786 }
51787
51788
51789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
51790   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51791   Dali::Actor arg2 ;
51792   Dali::Actor *argp2 ;
51793
51794   arg1 = (Dali::Toolkit::Popup *)jarg1;
51795   argp2 = (Dali::Actor *)jarg2;
51796   if (!argp2) {
51797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51798     return ;
51799   }
51800   arg2 = *argp2;
51801   {
51802     try {
51803       (arg1)->SetFooter(arg2);
51804     } CALL_CATCH_EXCEPTION();
51805   }
51806
51807 }
51808
51809
51810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
51811   void * jresult ;
51812   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51813   Dali::Actor result;
51814
51815   arg1 = (Dali::Toolkit::Popup *)jarg1;
51816   {
51817     try {
51818       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
51819     } CALL_CATCH_EXCEPTION(0);
51820   }
51821
51822   jresult = new Dali::Actor((const Dali::Actor &)result);
51823   return jresult;
51824 }
51825
51826
51827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
51828   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51829   Dali::Toolkit::Popup::DisplayState arg2 ;
51830
51831   arg1 = (Dali::Toolkit::Popup *)jarg1;
51832   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
51833   {
51834     try {
51835       (arg1)->SetDisplayState(arg2);
51836     } CALL_CATCH_EXCEPTION();
51837   }
51838
51839 }
51840
51841
51842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
51843   int jresult ;
51844   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51845   Dali::Toolkit::Popup::DisplayState result;
51846
51847   arg1 = (Dali::Toolkit::Popup *)jarg1;
51848   {
51849     try {
51850       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
51851     } CALL_CATCH_EXCEPTION(0);
51852   }
51853
51854   jresult = (int)result;
51855   return jresult;
51856 }
51857
51858
51859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
51860   void * jresult ;
51861   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51862   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
51863
51864   arg1 = (Dali::Toolkit::Popup *)jarg1;
51865   {
51866     try {
51867       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
51868     } CALL_CATCH_EXCEPTION(0);
51869   }
51870
51871   jresult = (void *)result;
51872   return jresult;
51873 }
51874
51875
51876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
51877   void * jresult ;
51878   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51879   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
51880
51881   arg1 = (Dali::Toolkit::Popup *)jarg1;
51882   {
51883     try {
51884       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
51885     } CALL_CATCH_EXCEPTION(0);
51886   }
51887
51888   jresult = (void *)result;
51889   return jresult;
51890 }
51891
51892
51893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
51894   void * jresult ;
51895   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51896   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
51897
51898   arg1 = (Dali::Toolkit::Popup *)jarg1;
51899   {
51900     try {
51901       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
51902     } CALL_CATCH_EXCEPTION(0);
51903   }
51904
51905   jresult = (void *)result;
51906   return jresult;
51907 }
51908
51909
51910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
51911   void * jresult ;
51912   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51913   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
51914
51915   arg1 = (Dali::Toolkit::Popup *)jarg1;
51916   {
51917     try {
51918       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
51919     } CALL_CATCH_EXCEPTION(0);
51920   }
51921
51922   jresult = (void *)result;
51923   return jresult;
51924 }
51925
51926
51927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
51928   void * jresult ;
51929   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51930   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
51931
51932   arg1 = (Dali::Toolkit::Popup *)jarg1;
51933   {
51934     try {
51935       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
51936     } CALL_CATCH_EXCEPTION(0);
51937   }
51938
51939   jresult = (void *)result;
51940   return jresult;
51941 }
51942
51943
51944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
51945   int jresult ;
51946   int result;
51947
51948   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
51949   jresult = (int)result;
51950   return jresult;
51951 }
51952
51953
51954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
51955   int jresult ;
51956   int result;
51957
51958   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
51959   jresult = (int)result;
51960   return jresult;
51961 }
51962
51963
51964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
51965   int jresult ;
51966   int result;
51967
51968   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
51969   jresult = (int)result;
51970   return jresult;
51971 }
51972
51973
51974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
51975   int jresult ;
51976   int result;
51977
51978   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
51979   jresult = (int)result;
51980   return jresult;
51981 }
51982
51983
51984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
51985   int jresult ;
51986   int result;
51987
51988   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
51989   jresult = (int)result;
51990   return jresult;
51991 }
51992
51993
51994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
51995   int jresult ;
51996   int result;
51997
51998   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
51999   jresult = (int)result;
52000   return jresult;
52001 }
52002
52003
52004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
52005   int jresult ;
52006   int result;
52007
52008   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
52009   jresult = (int)result;
52010   return jresult;
52011 }
52012
52013
52014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
52015   int jresult ;
52016   int result;
52017
52018   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
52019   jresult = (int)result;
52020   return jresult;
52021 }
52022
52023
52024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
52025   int jresult ;
52026   int result;
52027
52028   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
52029   jresult = (int)result;
52030   return jresult;
52031 }
52032
52033
52034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
52035   void * jresult ;
52036   Dali::Toolkit::ProgressBar::Property *result = 0 ;
52037
52038   {
52039     try {
52040       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
52041     } CALL_CATCH_EXCEPTION(0);
52042   }
52043
52044   jresult = (void *)result;
52045   return jresult;
52046 }
52047
52048
52049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
52050   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
52051
52052   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
52053   {
52054     try {
52055       delete arg1;
52056     } CALL_CATCH_EXCEPTION();
52057   }
52058
52059 }
52060
52061
52062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
52063   void * jresult ;
52064   Dali::Toolkit::ProgressBar result;
52065
52066   {
52067     try {
52068       result = Dali::Toolkit::ProgressBar::New();
52069     } CALL_CATCH_EXCEPTION(0);
52070   }
52071
52072   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
52073   return jresult;
52074 }
52075
52076
52077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
52078   void * jresult ;
52079   Dali::Toolkit::ProgressBar *result = 0 ;
52080
52081   {
52082     try {
52083       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
52084     } CALL_CATCH_EXCEPTION(0);
52085   }
52086
52087   jresult = (void *)result;
52088   return jresult;
52089 }
52090
52091
52092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
52093   void * jresult ;
52094   Dali::Toolkit::ProgressBar *arg1 = 0 ;
52095   Dali::Toolkit::ProgressBar *result = 0 ;
52096
52097   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
52098   if (!arg1) {
52099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
52100     return 0;
52101   }
52102   {
52103     try {
52104       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
52105     } CALL_CATCH_EXCEPTION(0);
52106   }
52107
52108   jresult = (void *)result;
52109   return jresult;
52110 }
52111
52112
52113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
52114   void * jresult ;
52115   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
52116   Dali::Toolkit::ProgressBar *arg2 = 0 ;
52117   Dali::Toolkit::ProgressBar *result = 0 ;
52118
52119   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
52120   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
52121   if (!arg2) {
52122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
52123     return 0;
52124   }
52125   {
52126     try {
52127       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
52128     } CALL_CATCH_EXCEPTION(0);
52129   }
52130
52131   jresult = (void *)result;
52132   return jresult;
52133 }
52134
52135
52136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
52137   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
52138
52139   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
52140   {
52141     try {
52142       delete arg1;
52143     } CALL_CATCH_EXCEPTION();
52144   }
52145
52146 }
52147
52148
52149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
52150   void * jresult ;
52151   Dali::BaseHandle arg1 ;
52152   Dali::BaseHandle *argp1 ;
52153   Dali::Toolkit::ProgressBar result;
52154
52155   argp1 = (Dali::BaseHandle *)jarg1;
52156   if (!argp1) {
52157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52158     return 0;
52159   }
52160   arg1 = *argp1;
52161   {
52162     try {
52163       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
52164     } CALL_CATCH_EXCEPTION(0);
52165   }
52166
52167   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
52168   return jresult;
52169 }
52170
52171
52172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
52173   void * jresult ;
52174   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
52175   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
52176
52177   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
52178   {
52179     try {
52180       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
52181     } CALL_CATCH_EXCEPTION(0);
52182   }
52183
52184   jresult = (void *)result;
52185   return jresult;
52186 }
52187
52188
52189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
52190   void * jresult ;
52191   Dali::Toolkit::GaussianBlurView *result = 0 ;
52192
52193   {
52194     try {
52195       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
52196     } CALL_CATCH_EXCEPTION(0);
52197   }
52198
52199   jresult = (void *)result;
52200   return jresult;
52201 }
52202
52203
52204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
52205   void * jresult ;
52206   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
52207   Dali::Toolkit::GaussianBlurView *result = 0 ;
52208
52209   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
52210   if (!arg1) {
52211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
52212     return 0;
52213   }
52214   {
52215     try {
52216       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
52217     } CALL_CATCH_EXCEPTION(0);
52218   }
52219
52220   jresult = (void *)result;
52221   return jresult;
52222 }
52223
52224
52225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
52226   void * jresult ;
52227   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
52228   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
52229   Dali::Toolkit::GaussianBlurView *result = 0 ;
52230
52231   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
52232   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
52233   if (!arg2) {
52234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
52235     return 0;
52236   }
52237   {
52238     try {
52239       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
52240     } CALL_CATCH_EXCEPTION(0);
52241   }
52242
52243   jresult = (void *)result;
52244   return jresult;
52245 }
52246
52247
52248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
52249   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
52250
52251   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
52252   {
52253     try {
52254       delete arg1;
52255     } CALL_CATCH_EXCEPTION();
52256   }
52257
52258 }
52259
52260
52261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
52262   void * jresult ;
52263   Dali::BaseHandle arg1 ;
52264   Dali::BaseHandle *argp1 ;
52265   Dali::Toolkit::GaussianBlurView result;
52266
52267   argp1 = (Dali::BaseHandle *)jarg1;
52268   if (!argp1) {
52269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52270     return 0;
52271   }
52272   arg1 = *argp1;
52273   {
52274     try {
52275       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
52276     } CALL_CATCH_EXCEPTION(0);
52277   }
52278
52279   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
52280   return jresult;
52281 }
52282
52283
52284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
52285   void * jresult ;
52286   Dali::Toolkit::GaussianBlurView result;
52287
52288   {
52289     try {
52290       result = Dali::Toolkit::GaussianBlurView::New();
52291     } CALL_CATCH_EXCEPTION(0);
52292   }
52293
52294   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
52295   return jresult;
52296 }
52297
52298
52299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, bool jarg6) {
52300   void * jresult ;
52301   unsigned int arg1 ;
52302   float arg2 ;
52303   Dali::Pixel::Format arg3 ;
52304   float arg4 ;
52305   float arg5 ;
52306   bool arg6 ;
52307   Dali::Toolkit::GaussianBlurView result;
52308
52309   arg1 = (unsigned int)jarg1;
52310   arg2 = (float)jarg2;
52311   arg3 = (Dali::Pixel::Format)jarg3;
52312   arg4 = (float)jarg4;
52313   arg5 = (float)jarg5;
52314   arg6 = jarg6 ? true : false;
52315   {
52316     try {
52317       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
52318     } CALL_CATCH_EXCEPTION(0);
52319   }
52320
52321   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
52322   return jresult;
52323 }
52324
52325
52326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
52327   void * jresult ;
52328   unsigned int arg1 ;
52329   float arg2 ;
52330   Dali::Pixel::Format arg3 ;
52331   float arg4 ;
52332   float arg5 ;
52333   Dali::Toolkit::GaussianBlurView result;
52334
52335   arg1 = (unsigned int)jarg1;
52336   arg2 = (float)jarg2;
52337   arg3 = (Dali::Pixel::Format)jarg3;
52338   arg4 = (float)jarg4;
52339   arg5 = (float)jarg5;
52340   {
52341     try {
52342       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
52343     } CALL_CATCH_EXCEPTION(0);
52344   }
52345
52346   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
52347   return jresult;
52348 }
52349
52350
52351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
52352   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
52353   Dali::Actor arg2 ;
52354   Dali::Actor *argp2 ;
52355
52356   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
52357   argp2 = (Dali::Actor *)jarg2;
52358   if (!argp2) {
52359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52360     return ;
52361   }
52362   arg2 = *argp2;
52363   {
52364     try {
52365       (arg1)->Add(arg2);
52366     } CALL_CATCH_EXCEPTION();
52367   }
52368
52369 }
52370
52371
52372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
52373   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
52374   Dali::Actor arg2 ;
52375   Dali::Actor *argp2 ;
52376
52377   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
52378   argp2 = (Dali::Actor *)jarg2;
52379   if (!argp2) {
52380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52381     return ;
52382   }
52383   arg2 = *argp2;
52384   {
52385     try {
52386       (arg1)->Remove(arg2);
52387     } CALL_CATCH_EXCEPTION();
52388   }
52389
52390 }
52391
52392
52393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
52394   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
52395
52396   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
52397   {
52398     try {
52399       (arg1)->Activate();
52400     } CALL_CATCH_EXCEPTION();
52401   }
52402
52403 }
52404
52405
52406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
52407   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
52408
52409   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
52410   {
52411     try {
52412       (arg1)->ActivateOnce();
52413     } CALL_CATCH_EXCEPTION();
52414   }
52415
52416 }
52417
52418
52419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
52420   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
52421
52422   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
52423   {
52424     try {
52425       (arg1)->Deactivate();
52426     } CALL_CATCH_EXCEPTION();
52427   }
52428
52429 }
52430
52431
52432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
52433   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
52434   Dali::Texture arg2 ;
52435   Dali::FrameBuffer arg3 ;
52436   Dali::Texture *argp2 ;
52437   Dali::FrameBuffer *argp3 ;
52438
52439   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
52440   argp2 = (Dali::Texture *)jarg2;
52441   if (!argp2) {
52442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
52443     return ;
52444   }
52445   arg2 = *argp2;
52446   argp3 = (Dali::FrameBuffer *)jarg3;
52447   if (!argp3) {
52448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
52449     return ;
52450   }
52451   arg3 = *argp3;
52452   {
52453     try {
52454       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
52455     } CALL_CATCH_EXCEPTION();
52456   }
52457
52458 }
52459
52460
52461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
52462   int jresult ;
52463   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
52464   Dali::Property::Index result;
52465
52466   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
52467   {
52468     try {
52469       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
52470     } CALL_CATCH_EXCEPTION(0);
52471   }
52472
52473   jresult = result;
52474   return jresult;
52475 }
52476
52477
52478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
52479   void * jresult ;
52480   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
52481   Dali::FrameBuffer result;
52482
52483   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
52484   {
52485     try {
52486       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
52487     } CALL_CATCH_EXCEPTION(0);
52488   }
52489
52490   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
52491   return jresult;
52492 }
52493
52494
52495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
52496   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
52497   Dali::Vector4 *arg2 = 0 ;
52498
52499   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
52500   arg2 = (Dali::Vector4 *)jarg2;
52501   if (!arg2) {
52502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
52503     return ;
52504   }
52505   {
52506     try {
52507       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
52508     } CALL_CATCH_EXCEPTION();
52509   }
52510
52511 }
52512
52513
52514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
52515   void * jresult ;
52516   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
52517   Dali::Vector4 result;
52518
52519   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
52520   {
52521     try {
52522       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
52523     } CALL_CATCH_EXCEPTION(0);
52524   }
52525
52526   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
52527   return jresult;
52528 }
52529
52530
52531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
52532   void * jresult ;
52533   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
52534   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
52535
52536   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
52537   {
52538     try {
52539       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
52540     } CALL_CATCH_EXCEPTION(0);
52541   }
52542
52543   jresult = (void *)result;
52544   return jresult;
52545 }
52546
52547
52548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
52549   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
52550
52551   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
52552   {
52553     try {
52554       delete arg1;
52555     } CALL_CATCH_EXCEPTION();
52556   }
52557
52558 }
52559
52560
52561 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
52562   unsigned int jresult ;
52563   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
52564   unsigned int result;
52565
52566   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
52567   {
52568     try {
52569       result = (unsigned int)(arg1)->GetNumberOfPages();
52570     } CALL_CATCH_EXCEPTION(0);
52571   }
52572
52573   jresult = result;
52574   return jresult;
52575 }
52576
52577
52578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
52579   void * jresult ;
52580   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
52581   unsigned int arg2 ;
52582   Dali::Texture result;
52583
52584   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
52585   arg2 = (unsigned int)jarg2;
52586   {
52587     try {
52588       result = (arg1)->NewPage(arg2);
52589     } CALL_CATCH_EXCEPTION(0);
52590   }
52591
52592   jresult = new Dali::Texture((const Dali::Texture &)result);
52593   return jresult;
52594 }
52595
52596
52597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
52598   int jresult ;
52599   int result;
52600
52601   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
52602   jresult = (int)result;
52603   return jresult;
52604 }
52605
52606
52607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
52608   int jresult ;
52609   int result;
52610
52611   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
52612   jresult = (int)result;
52613   return jresult;
52614 }
52615
52616
52617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
52618   int jresult ;
52619   int result;
52620
52621   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
52622   jresult = (int)result;
52623   return jresult;
52624 }
52625
52626
52627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
52628   void * jresult ;
52629   Dali::Toolkit::PageTurnView::Property *result = 0 ;
52630
52631   {
52632     try {
52633       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
52634     } CALL_CATCH_EXCEPTION(0);
52635   }
52636
52637   jresult = (void *)result;
52638   return jresult;
52639 }
52640
52641
52642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
52643   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
52644
52645   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
52646   {
52647     try {
52648       delete arg1;
52649     } CALL_CATCH_EXCEPTION();
52650   }
52651
52652 }
52653
52654
52655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
52656   void * jresult ;
52657   Dali::Toolkit::PageTurnView *result = 0 ;
52658
52659   {
52660     try {
52661       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
52662     } CALL_CATCH_EXCEPTION(0);
52663   }
52664
52665   jresult = (void *)result;
52666   return jresult;
52667 }
52668
52669
52670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
52671   void * jresult ;
52672   Dali::Toolkit::PageTurnView *arg1 = 0 ;
52673   Dali::Toolkit::PageTurnView *result = 0 ;
52674
52675   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
52676   if (!arg1) {
52677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
52678     return 0;
52679   }
52680   {
52681     try {
52682       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
52683     } CALL_CATCH_EXCEPTION(0);
52684   }
52685
52686   jresult = (void *)result;
52687   return jresult;
52688 }
52689
52690
52691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
52692   void * jresult ;
52693   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
52694   Dali::Toolkit::PageTurnView *arg2 = 0 ;
52695   Dali::Toolkit::PageTurnView *result = 0 ;
52696
52697   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
52698   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
52699   if (!arg2) {
52700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
52701     return 0;
52702   }
52703   {
52704     try {
52705       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
52706     } CALL_CATCH_EXCEPTION(0);
52707   }
52708
52709   jresult = (void *)result;
52710   return jresult;
52711 }
52712
52713
52714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
52715   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
52716
52717   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
52718   {
52719     try {
52720       delete arg1;
52721     } CALL_CATCH_EXCEPTION();
52722   }
52723
52724 }
52725
52726
52727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
52728   void * jresult ;
52729   Dali::BaseHandle arg1 ;
52730   Dali::BaseHandle *argp1 ;
52731   Dali::Toolkit::PageTurnView result;
52732
52733   argp1 = (Dali::BaseHandle *)jarg1;
52734   if (!argp1) {
52735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52736     return 0;
52737   }
52738   arg1 = *argp1;
52739   {
52740     try {
52741       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
52742     } CALL_CATCH_EXCEPTION(0);
52743   }
52744
52745   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
52746   return jresult;
52747 }
52748
52749
52750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
52751   void * jresult ;
52752   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
52753   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
52754
52755   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
52756   {
52757     try {
52758       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
52759     } CALL_CATCH_EXCEPTION(0);
52760   }
52761
52762   jresult = (void *)result;
52763   return jresult;
52764 }
52765
52766
52767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
52768   void * jresult ;
52769   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
52770   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
52771
52772   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
52773   {
52774     try {
52775       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
52776     } CALL_CATCH_EXCEPTION(0);
52777   }
52778
52779   jresult = (void *)result;
52780   return jresult;
52781 }
52782
52783
52784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
52785   void * jresult ;
52786   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
52787   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
52788
52789   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
52790   {
52791     try {
52792       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
52793     } CALL_CATCH_EXCEPTION(0);
52794   }
52795
52796   jresult = (void *)result;
52797   return jresult;
52798 }
52799
52800
52801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
52802   void * jresult ;
52803   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
52804   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
52805
52806   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
52807   {
52808     try {
52809       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
52810     } CALL_CATCH_EXCEPTION(0);
52811   }
52812
52813   jresult = (void *)result;
52814   return jresult;
52815 }
52816
52817
52818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
52819   void * jresult ;
52820   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
52821
52822   {
52823     try {
52824       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
52825     } CALL_CATCH_EXCEPTION(0);
52826   }
52827
52828   jresult = (void *)result;
52829   return jresult;
52830 }
52831
52832
52833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
52834   void * jresult ;
52835   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
52836   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
52837
52838   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
52839   if (!arg1) {
52840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
52841     return 0;
52842   }
52843   {
52844     try {
52845       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
52846     } CALL_CATCH_EXCEPTION(0);
52847   }
52848
52849   jresult = (void *)result;
52850   return jresult;
52851 }
52852
52853
52854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
52855   void * jresult ;
52856   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
52857   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
52858   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
52859
52860   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
52861   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
52862   if (!arg2) {
52863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
52864     return 0;
52865   }
52866   {
52867     try {
52868       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
52869     } CALL_CATCH_EXCEPTION(0);
52870   }
52871
52872   jresult = (void *)result;
52873   return jresult;
52874 }
52875
52876
52877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
52878   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
52879
52880   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
52881   {
52882     try {
52883       delete arg1;
52884     } CALL_CATCH_EXCEPTION();
52885   }
52886
52887 }
52888
52889
52890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
52891   void * jresult ;
52892   Dali::Toolkit::PageFactory *arg1 = 0 ;
52893   Dali::Vector2 *arg2 = 0 ;
52894   Dali::Toolkit::PageTurnLandscapeView result;
52895
52896   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
52897   if (!arg1) {
52898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
52899     return 0;
52900   }
52901   arg2 = (Dali::Vector2 *)jarg2;
52902   if (!arg2) {
52903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
52904     return 0;
52905   }
52906   {
52907     try {
52908       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
52909     } CALL_CATCH_EXCEPTION(0);
52910   }
52911
52912   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
52913   return jresult;
52914 }
52915
52916
52917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
52918   void * jresult ;
52919   Dali::BaseHandle arg1 ;
52920   Dali::BaseHandle *argp1 ;
52921   Dali::Toolkit::PageTurnLandscapeView result;
52922
52923   argp1 = (Dali::BaseHandle *)jarg1;
52924   if (!argp1) {
52925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52926     return 0;
52927   }
52928   arg1 = *argp1;
52929   {
52930     try {
52931       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
52932     } CALL_CATCH_EXCEPTION(0);
52933   }
52934
52935   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
52936   return jresult;
52937 }
52938
52939
52940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
52941   void * jresult ;
52942   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
52943
52944   {
52945     try {
52946       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
52947     } CALL_CATCH_EXCEPTION(0);
52948   }
52949
52950   jresult = (void *)result;
52951   return jresult;
52952 }
52953
52954
52955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
52956   void * jresult ;
52957   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
52958   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
52959
52960   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
52961   if (!arg1) {
52962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
52963     return 0;
52964   }
52965   {
52966     try {
52967       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
52968     } CALL_CATCH_EXCEPTION(0);
52969   }
52970
52971   jresult = (void *)result;
52972   return jresult;
52973 }
52974
52975
52976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
52977   void * jresult ;
52978   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
52979   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
52980   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
52981
52982   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
52983   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
52984   if (!arg2) {
52985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
52986     return 0;
52987   }
52988   {
52989     try {
52990       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
52991     } CALL_CATCH_EXCEPTION(0);
52992   }
52993
52994   jresult = (void *)result;
52995   return jresult;
52996 }
52997
52998
52999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
53000   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
53001
53002   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
53003   {
53004     try {
53005       delete arg1;
53006     } CALL_CATCH_EXCEPTION();
53007   }
53008
53009 }
53010
53011
53012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
53013   void * jresult ;
53014   Dali::Toolkit::PageFactory *arg1 = 0 ;
53015   Dali::Vector2 *arg2 = 0 ;
53016   Dali::Toolkit::PageTurnPortraitView result;
53017
53018   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
53019   if (!arg1) {
53020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
53021     return 0;
53022   }
53023   arg2 = (Dali::Vector2 *)jarg2;
53024   if (!arg2) {
53025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
53026     return 0;
53027   }
53028   {
53029     try {
53030       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
53031     } CALL_CATCH_EXCEPTION(0);
53032   }
53033
53034   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
53035   return jresult;
53036 }
53037
53038
53039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
53040   void * jresult ;
53041   Dali::BaseHandle arg1 ;
53042   Dali::BaseHandle *argp1 ;
53043   Dali::Toolkit::PageTurnPortraitView result;
53044
53045   argp1 = (Dali::BaseHandle *)jarg1;
53046   if (!argp1) {
53047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
53048     return 0;
53049   }
53050   arg1 = *argp1;
53051   {
53052     try {
53053       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
53054     } CALL_CATCH_EXCEPTION(0);
53055   }
53056
53057   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
53058   return jresult;
53059 }
53060
53061
53062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
53063   int jresult ;
53064   int result;
53065
53066   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
53067   jresult = (int)result;
53068   return jresult;
53069 }
53070
53071
53072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
53073   int jresult ;
53074   int result;
53075
53076   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
53077   jresult = (int)result;
53078   return jresult;
53079 }
53080
53081
53082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
53083   int jresult ;
53084   int result;
53085
53086   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
53087   jresult = (int)result;
53088   return jresult;
53089 }
53090
53091
53092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
53093   void * jresult ;
53094   Dali::Toolkit::ToggleButton::Property *result = 0 ;
53095
53096   {
53097     try {
53098       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
53099     } CALL_CATCH_EXCEPTION(0);
53100   }
53101
53102   jresult = (void *)result;
53103   return jresult;
53104 }
53105
53106
53107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
53108   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
53109
53110   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
53111   {
53112     try {
53113       delete arg1;
53114     } CALL_CATCH_EXCEPTION();
53115   }
53116
53117 }
53118
53119
53120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
53121   void * jresult ;
53122   Dali::Toolkit::ToggleButton *result = 0 ;
53123
53124   {
53125     try {
53126       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
53127     } CALL_CATCH_EXCEPTION(0);
53128   }
53129
53130   jresult = (void *)result;
53131   return jresult;
53132 }
53133
53134
53135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
53136   void * jresult ;
53137   Dali::Toolkit::ToggleButton *arg1 = 0 ;
53138   Dali::Toolkit::ToggleButton *result = 0 ;
53139
53140   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
53141   if (!arg1) {
53142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
53143     return 0;
53144   }
53145   {
53146     try {
53147       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
53148     } CALL_CATCH_EXCEPTION(0);
53149   }
53150
53151   jresult = (void *)result;
53152   return jresult;
53153 }
53154
53155
53156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
53157   void * jresult ;
53158   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
53159   Dali::Toolkit::ToggleButton *arg2 = 0 ;
53160   Dali::Toolkit::ToggleButton *result = 0 ;
53161
53162   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
53163   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
53164   if (!arg2) {
53165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
53166     return 0;
53167   }
53168   {
53169     try {
53170       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
53171     } CALL_CATCH_EXCEPTION(0);
53172   }
53173
53174   jresult = (void *)result;
53175   return jresult;
53176 }
53177
53178
53179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
53180   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
53181
53182   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
53183   {
53184     try {
53185       delete arg1;
53186     } CALL_CATCH_EXCEPTION();
53187   }
53188
53189 }
53190
53191
53192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
53193   void * jresult ;
53194   Dali::Toolkit::ToggleButton result;
53195
53196   {
53197     try {
53198       result = Dali::Toolkit::ToggleButton::New();
53199     } CALL_CATCH_EXCEPTION(0);
53200   }
53201
53202   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
53203   return jresult;
53204 }
53205
53206
53207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
53208   void * jresult ;
53209   Dali::BaseHandle arg1 ;
53210   Dali::BaseHandle *argp1 ;
53211   Dali::Toolkit::ToggleButton result;
53212
53213   argp1 = (Dali::BaseHandle *)jarg1;
53214   if (!argp1) {
53215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
53216     return 0;
53217   }
53218   arg1 = *argp1;
53219   {
53220     try {
53221       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
53222     } CALL_CATCH_EXCEPTION(0);
53223   }
53224
53225   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
53226   return jresult;
53227 }
53228
53229
53230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
53231   void * jresult ;
53232   Dali::Toolkit::Visual::Base *result = 0 ;
53233
53234   {
53235     try {
53236       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
53237     } CALL_CATCH_EXCEPTION(0);
53238   }
53239
53240   jresult = (void *)result;
53241   return jresult;
53242 }
53243
53244
53245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
53246   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
53247
53248   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
53249   {
53250     try {
53251       delete arg1;
53252     } CALL_CATCH_EXCEPTION();
53253   }
53254
53255 }
53256
53257
53258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
53259   void * jresult ;
53260   Dali::Toolkit::Visual::Base *arg1 = 0 ;
53261   Dali::Toolkit::Visual::Base *result = 0 ;
53262
53263   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
53264   if (!arg1) {
53265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
53266     return 0;
53267   }
53268   {
53269     try {
53270       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
53271     } CALL_CATCH_EXCEPTION(0);
53272   }
53273
53274   jresult = (void *)result;
53275   return jresult;
53276 }
53277
53278
53279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
53280   void * jresult ;
53281   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
53282   Dali::Toolkit::Visual::Base *arg2 = 0 ;
53283   Dali::Toolkit::Visual::Base *result = 0 ;
53284
53285   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
53286   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
53287   if (!arg2) {
53288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
53289     return 0;
53290   }
53291   {
53292     try {
53293       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
53294     } CALL_CATCH_EXCEPTION(0);
53295   }
53296
53297   jresult = (void *)result;
53298   return jresult;
53299 }
53300
53301
53302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
53303   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
53304   std::string *arg2 = 0 ;
53305
53306   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
53307   if (!jarg2) {
53308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53309     return ;
53310   }
53311   std::string arg2_str(jarg2);
53312   arg2 = &arg2_str;
53313   {
53314     try {
53315       (arg1)->SetName((std::string const &)*arg2);
53316     } CALL_CATCH_EXCEPTION();
53317   }
53318
53319
53320   //argout typemap for const std::string&
53321
53322 }
53323
53324
53325 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
53326   char * jresult ;
53327   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
53328   std::string *result = 0 ;
53329
53330   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
53331   {
53332     try {
53333       result = (std::string *) &(arg1)->GetName();
53334     } CALL_CATCH_EXCEPTION(0);
53335   }
53336
53337   jresult = SWIG_csharp_string_callback(result->c_str());
53338   return jresult;
53339 }
53340
53341
53342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
53343   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
53344   Dali::Property::Map *arg2 = 0 ;
53345   Dali::Size arg3 ;
53346   Dali::Size *argp3 ;
53347
53348   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
53349   arg2 = (Dali::Property::Map *)jarg2;
53350   if (!arg2) {
53351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53352     return ;
53353   }
53354   argp3 = (Dali::Size *)jarg3;
53355   if (!argp3) {
53356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
53357     return ;
53358   }
53359   arg3 = *argp3;
53360   {
53361     try {
53362       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
53363     } CALL_CATCH_EXCEPTION();
53364   }
53365
53366 }
53367
53368
53369 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
53370   float jresult ;
53371   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
53372   float arg2 ;
53373   float result;
53374
53375   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
53376   arg2 = (float)jarg2;
53377   {
53378     try {
53379       result = (float)(arg1)->GetHeightForWidth(arg2);
53380     } CALL_CATCH_EXCEPTION(0);
53381   }
53382
53383   jresult = result;
53384   return jresult;
53385 }
53386
53387
53388 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
53389   float jresult ;
53390   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
53391   float arg2 ;
53392   float result;
53393
53394   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
53395   arg2 = (float)jarg2;
53396   {
53397     try {
53398       result = (float)(arg1)->GetWidthForHeight(arg2);
53399     } CALL_CATCH_EXCEPTION(0);
53400   }
53401
53402   jresult = result;
53403   return jresult;
53404 }
53405
53406
53407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
53408   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
53409   Dali::Vector2 *arg2 = 0 ;
53410
53411   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
53412   arg2 = (Dali::Vector2 *)jarg2;
53413   if (!arg2) {
53414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
53415     return ;
53416   }
53417   {
53418     try {
53419       (arg1)->GetNaturalSize(*arg2);
53420     } CALL_CATCH_EXCEPTION();
53421   }
53422
53423 }
53424
53425
53426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
53427   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
53428   float arg2 ;
53429
53430   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
53431   arg2 = (int)jarg2;
53432   {
53433     try {
53434       (arg1)->SetDepthIndex(arg2);
53435     } CALL_CATCH_EXCEPTION();
53436   }
53437
53438 }
53439
53440
53441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
53442   int jresult ;
53443   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
53444   int result;
53445
53446   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
53447   {
53448     try {
53449       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
53450     } CALL_CATCH_EXCEPTION(0);
53451   }
53452
53453   jresult = result;
53454   return jresult;
53455 }
53456
53457
53458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
53459   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
53460   Dali::Property::Map *arg2 = 0 ;
53461
53462   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
53463   arg2 = (Dali::Property::Map *)jarg2;
53464   if (!arg2) {
53465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
53466     return ;
53467   }
53468   {
53469     try {
53470       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
53471     } CALL_CATCH_EXCEPTION();
53472   }
53473
53474 }
53475
53476
53477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
53478   void * jresult ;
53479   Dali::Toolkit::VisualFactory result;
53480
53481   {
53482     try {
53483       result = Dali::Toolkit::VisualFactory::Get();
53484     } CALL_CATCH_EXCEPTION(0);
53485   }
53486
53487   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
53488   return jresult;
53489 }
53490
53491
53492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
53493   void * jresult ;
53494   Dali::Toolkit::VisualFactory *result = 0 ;
53495
53496   {
53497     try {
53498       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
53499     } CALL_CATCH_EXCEPTION(0);
53500   }
53501
53502   jresult = (void *)result;
53503   return jresult;
53504 }
53505
53506
53507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
53508   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
53509
53510   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
53511   {
53512     try {
53513       delete arg1;
53514     } CALL_CATCH_EXCEPTION();
53515   }
53516
53517 }
53518
53519
53520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
53521   void * jresult ;
53522   Dali::Toolkit::VisualFactory *arg1 = 0 ;
53523   Dali::Toolkit::VisualFactory *result = 0 ;
53524
53525   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
53526   if (!arg1) {
53527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
53528     return 0;
53529   }
53530   {
53531     try {
53532       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
53533     } CALL_CATCH_EXCEPTION(0);
53534   }
53535
53536   jresult = (void *)result;
53537   return jresult;
53538 }
53539
53540
53541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
53542   void * jresult ;
53543   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
53544   Dali::Toolkit::VisualFactory *arg2 = 0 ;
53545   Dali::Toolkit::VisualFactory *result = 0 ;
53546
53547   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
53548   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
53549   if (!arg2) {
53550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
53551     return 0;
53552   }
53553   {
53554     try {
53555       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
53556     } CALL_CATCH_EXCEPTION(0);
53557   }
53558
53559   jresult = (void *)result;
53560   return jresult;
53561 }
53562
53563
53564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
53565   void * jresult ;
53566   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
53567   Dali::Property::Map *arg2 = 0 ;
53568   Dali::Toolkit::Visual::Base result;
53569
53570   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
53571   arg2 = (Dali::Property::Map *)jarg2;
53572   if (!arg2) {
53573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53574     return 0;
53575   }
53576   {
53577     try {
53578       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
53579     } CALL_CATCH_EXCEPTION(0);
53580   }
53581
53582   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
53583   return jresult;
53584 }
53585
53586
53587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
53588   void * jresult ;
53589   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
53590   std::string *arg2 = 0 ;
53591   Dali::ImageDimensions arg3 ;
53592   Dali::ImageDimensions *argp3 ;
53593   Dali::Toolkit::Visual::Base result;
53594
53595   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
53596   if (!jarg2) {
53597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53598     return 0;
53599   }
53600   std::string arg2_str(jarg2);
53601   arg2 = &arg2_str;
53602   argp3 = (Dali::ImageDimensions *)jarg3;
53603   if (!argp3) {
53604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
53605     return 0;
53606   }
53607   arg3 = *argp3;
53608   {
53609     try {
53610       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
53611     } CALL_CATCH_EXCEPTION(0);
53612   }
53613
53614   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
53615
53616   //argout typemap for const std::string&
53617
53618   return jresult;
53619 }
53620
53621
53622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
53623   void * jresult ;
53624   Dali::Toolkit::AsyncImageLoader *result = 0 ;
53625
53626   {
53627     try {
53628       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
53629     } CALL_CATCH_EXCEPTION(0);
53630   }
53631
53632   jresult = (void *)result;
53633   return jresult;
53634 }
53635
53636
53637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
53638   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
53639
53640   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
53641   {
53642     try {
53643       delete arg1;
53644     } CALL_CATCH_EXCEPTION();
53645   }
53646
53647 }
53648
53649
53650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
53651   void * jresult ;
53652   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
53653   Dali::Toolkit::AsyncImageLoader *result = 0 ;
53654
53655   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
53656   if (!arg1) {
53657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
53658     return 0;
53659   }
53660   {
53661     try {
53662       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
53663     } CALL_CATCH_EXCEPTION(0);
53664   }
53665
53666   jresult = (void *)result;
53667   return jresult;
53668 }
53669
53670
53671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
53672   void * jresult ;
53673   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
53674   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
53675   Dali::Toolkit::AsyncImageLoader *result = 0 ;
53676
53677   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
53678   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
53679   if (!arg2) {
53680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
53681     return 0;
53682   }
53683   {
53684     try {
53685       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
53686     } CALL_CATCH_EXCEPTION(0);
53687   }
53688
53689   jresult = (void *)result;
53690   return jresult;
53691 }
53692
53693
53694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
53695   void * jresult ;
53696   Dali::Toolkit::AsyncImageLoader result;
53697
53698   {
53699     try {
53700       result = Dali::Toolkit::AsyncImageLoader::New();
53701     } CALL_CATCH_EXCEPTION(0);
53702   }
53703
53704   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
53705   return jresult;
53706 }
53707
53708
53709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
53710   void * jresult ;
53711   Dali::BaseHandle arg1 ;
53712   Dali::BaseHandle *argp1 ;
53713   Dali::Toolkit::AsyncImageLoader result;
53714
53715   argp1 = (Dali::BaseHandle *)jarg1;
53716   if (!argp1) {
53717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
53718     return 0;
53719   }
53720   arg1 = *argp1;
53721   {
53722     try {
53723       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
53724     } CALL_CATCH_EXCEPTION(0);
53725   }
53726
53727   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
53728   return jresult;
53729 }
53730
53731
53732 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
53733   unsigned int jresult ;
53734   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
53735   std::string *arg2 = 0 ;
53736   uint32_t result;
53737
53738   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
53739   if (!jarg2) {
53740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53741     return 0;
53742   }
53743   std::string arg2_str(jarg2);
53744   arg2 = &arg2_str;
53745   {
53746     try {
53747       result = (arg1)->Load((std::string const &)*arg2);
53748     } CALL_CATCH_EXCEPTION(0);
53749   }
53750
53751   jresult = result;
53752
53753   //argout typemap for const std::string&
53754
53755   return jresult;
53756 }
53757
53758
53759 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
53760   unsigned int jresult ;
53761   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
53762   std::string *arg2 = 0 ;
53763   Dali::ImageDimensions arg3 ;
53764   Dali::ImageDimensions *argp3 ;
53765   uint32_t result;
53766
53767   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
53768   if (!jarg2) {
53769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53770     return 0;
53771   }
53772   std::string arg2_str(jarg2);
53773   arg2 = &arg2_str;
53774   argp3 = (Dali::ImageDimensions *)jarg3;
53775   if (!argp3) {
53776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
53777     return 0;
53778   }
53779   arg3 = *argp3;
53780   {
53781     try {
53782       result = (arg1)->Load((std::string const &)*arg2,arg3);
53783     } CALL_CATCH_EXCEPTION(0);
53784   }
53785
53786   jresult = result;
53787
53788   //argout typemap for const std::string&
53789
53790   return jresult;
53791 }
53792
53793
53794 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, bool jarg6) {
53795   unsigned int jresult ;
53796   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
53797   std::string *arg2 = 0 ;
53798   Dali::ImageDimensions arg3 ;
53799   Dali::FittingMode::Type arg4 ;
53800   Dali::SamplingMode::Type arg5 ;
53801   bool arg6 ;
53802   Dali::ImageDimensions *argp3 ;
53803   uint32_t result;
53804
53805   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
53806   if (!jarg2) {
53807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53808     return 0;
53809   }
53810   std::string arg2_str(jarg2);
53811   arg2 = &arg2_str;
53812   argp3 = (Dali::ImageDimensions *)jarg3;
53813   if (!argp3) {
53814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
53815     return 0;
53816   }
53817   arg3 = *argp3;
53818   arg4 = (Dali::FittingMode::Type)jarg4;
53819   arg5 = (Dali::SamplingMode::Type)jarg5;
53820   arg6 = jarg6 ? true : false;
53821   {
53822     try {
53823       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
53824     } CALL_CATCH_EXCEPTION(0);
53825   }
53826
53827   jresult = result;
53828
53829   //argout typemap for const std::string&
53830
53831   return jresult;
53832 }
53833
53834
53835 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
53836   bool jresult ;
53837   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
53838   uint32_t arg2 ;
53839   bool result;
53840
53841   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
53842   arg2 = (uint32_t)jarg2;
53843   {
53844     try {
53845       result = (bool)(arg1)->Cancel(arg2);
53846     } CALL_CATCH_EXCEPTION(0);
53847   }
53848
53849   jresult = result;
53850   return jresult;
53851 }
53852
53853
53854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
53855   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
53856
53857   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
53858   {
53859     try {
53860       (arg1)->CancelAll();
53861     } CALL_CATCH_EXCEPTION();
53862   }
53863
53864 }
53865
53866
53867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
53868   void * jresult ;
53869   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
53870   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
53871
53872   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
53873   {
53874     try {
53875       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
53876     } CALL_CATCH_EXCEPTION(0);
53877   }
53878
53879   jresult = (void *)result;
53880   return jresult;
53881 }
53882
53883
53884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
53885   void * jresult ;
53886   std::string *arg1 = 0 ;
53887   Dali::PixelData result;
53888
53889   if (!jarg1) {
53890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53891     return 0;
53892   }
53893   std::string arg1_str(jarg1);
53894   arg1 = &arg1_str;
53895   {
53896     try {
53897       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
53898     } CALL_CATCH_EXCEPTION(0);
53899   }
53900
53901   jresult = new Dali::PixelData((const Dali::PixelData &)result);
53902
53903   //argout typemap for const std::string&
53904
53905   return jresult;
53906 }
53907
53908
53909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
53910   void * jresult ;
53911   std::string *arg1 = 0 ;
53912   Dali::ImageDimensions arg2 ;
53913   Dali::ImageDimensions *argp2 ;
53914   Dali::PixelData result;
53915
53916   if (!jarg1) {
53917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53918     return 0;
53919   }
53920   std::string arg1_str(jarg1);
53921   arg1 = &arg1_str;
53922   argp2 = (Dali::ImageDimensions *)jarg2;
53923   if (!argp2) {
53924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
53925     return 0;
53926   }
53927   arg2 = *argp2;
53928   {
53929     try {
53930       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
53931     } CALL_CATCH_EXCEPTION(0);
53932   }
53933
53934   jresult = new Dali::PixelData((const Dali::PixelData &)result);
53935
53936   //argout typemap for const std::string&
53937
53938   return jresult;
53939 }
53940
53941
53942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
53943   void * jresult ;
53944   std::string *arg1 = 0 ;
53945   Dali::ImageDimensions arg2 ;
53946   Dali::FittingMode::Type arg3 ;
53947   Dali::SamplingMode::Type arg4 ;
53948   bool arg5 ;
53949   Dali::ImageDimensions *argp2 ;
53950   Dali::PixelData result;
53951
53952   if (!jarg1) {
53953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53954     return 0;
53955   }
53956   std::string arg1_str(jarg1);
53957   arg1 = &arg1_str;
53958   argp2 = (Dali::ImageDimensions *)jarg2;
53959   if (!argp2) {
53960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
53961     return 0;
53962   }
53963   arg2 = *argp2;
53964   arg3 = (Dali::FittingMode::Type)jarg3;
53965   arg4 = (Dali::SamplingMode::Type)jarg4;
53966   arg5 = jarg5 ? true : false;
53967   {
53968     try {
53969       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
53970     } CALL_CATCH_EXCEPTION(0);
53971   }
53972
53973   jresult = new Dali::PixelData((const Dali::PixelData &)result);
53974
53975   //argout typemap for const std::string&
53976
53977   return jresult;
53978 }
53979
53980
53981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
53982   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
53983
53984   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
53985   {
53986     try {
53987       delete arg1;
53988     } CALL_CATCH_EXCEPTION();
53989   }
53990
53991 }
53992
53993
53994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * customAlgorithmInterface, void * currentFocusedActor, void * proposedActorToFocus, int direction, char * deviceName) {
53995   void * jresult ;
53996   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
53997   Dali::Actor arg2 ;
53998   Dali::Actor arg3 ;
53999   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
54000   std::string *arg5 = 0 ;
54001   Dali::Actor *argp2 ;
54002   Dali::Actor *argp3 ;
54003   Dali::Actor result;
54004
54005   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)customAlgorithmInterface;
54006   argp2 = (Dali::Actor *)currentFocusedActor;
54007   if (!argp2) {
54008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54009     return 0;
54010   }
54011   arg2 = *argp2;
54012   argp3 = (Dali::Actor *)proposedActorToFocus;
54013   if (!argp3) {
54014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54015     return 0;
54016   }
54017   arg3 = *argp3;
54018   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)direction;
54019
54020   std::string arg5_str(deviceName);
54021   arg5 = &arg5_str;
54022
54023   {
54024     try {
54025       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4,(std::string const &)*arg5);
54026     } CALL_CATCH_EXCEPTION(0);
54027   }
54028
54029   jresult = new Dali::Actor((const Dali::Actor &)result);
54030   return jresult;
54031 }
54032
54033
54034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
54035   void * jresult ;
54036   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
54037
54038   {
54039     try {
54040       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
54041     } CALL_CATCH_EXCEPTION(0);
54042   }
54043
54044   jresult = (void *)result;
54045   return jresult;
54046 }
54047
54048
54049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback0_t callback0) {
54050   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg;
54051   SwigDirector_FrameCallbackInterface *director = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
54052   if (director) {
54053     director->swig_connect_director(callback0);
54054   }
54055 }
54056
54057
54058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameCallbackInterface() {
54059   void * jresult ;
54060   Dali::FrameCallbackInterface *result = 0 ;
54061
54062   {
54063     try {
54064       result =(Dali::FrameCallbackInterface *) new SwigDirector_FrameCallbackInterface();
54065     } CALL_CATCH_EXCEPTION(0);
54066   }
54067
54068   jresult = (void *)result;
54069   return jresult;
54070 }
54071
54072 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPosition(void * updateProxy, unsigned int id,  void* position) {
54073   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
54074   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
54075   return proxy->GetPosition(id, *vector3);
54076 }
54077
54078 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetPosition(void * updateProxy, unsigned int id, void* position) {
54079   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
54080   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
54081   return proxy->SetPosition(id, *vector3);
54082 }
54083
54084 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakePosition(void * updateProxy, unsigned int id, void* position) {
54085   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
54086   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
54087   return proxy->BakePosition(id, *vector3);
54088 }
54089
54090 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetSize(void * updateProxy, unsigned int id, void* size) {
54091   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
54092   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
54093   return proxy->GetSize(id, *vector3);
54094 }
54095
54096 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetSize(void * updateProxy, unsigned int id, void* size) {
54097   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
54098   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
54099   return proxy->SetSize(id, *vector3);
54100 }
54101 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeSize(void * updateProxy, unsigned int id, void* size) {
54102   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
54103   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
54104   return proxy->BakeSize(id, *vector3);
54105 }
54106
54107 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPositionAndSize(void * updateProxy, unsigned int id, void* position, void* size) {
54108   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
54109   Dali::Vector3* vector3_pos = (Dali::Vector3 *)position;
54110   Dali::Vector3* vector3_size = (Dali::Vector3 *)size;
54111   return proxy->GetPositionAndSize(id, *vector3_pos, *vector3_size);
54112 }
54113
54114 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetScale(void * updateProxy, unsigned int id, void* scale) {
54115   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
54116   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
54117   return proxy->GetScale(id,* vector3);
54118 }
54119
54120 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetScale(void * updateProxy, unsigned int id, void* scale) {
54121   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
54122   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
54123   return proxy->SetScale(id, *vector3);
54124 }
54125
54126 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeScale(void * updateProxy, unsigned int id, void* scale) {
54127   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
54128   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
54129   return proxy->BakeScale(id, *vector3);
54130 }
54131
54132 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetColor(void * updateProxy, unsigned int id, void* color) {
54133   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
54134   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
54135   return proxy->GetColor(id, *vector4);
54136 }
54137
54138 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetColor(void * updateProxy, unsigned int id, void* color) {
54139   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
54140   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
54141   return proxy->SetColor(id, *vector4);
54142 }
54143
54144 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeColor(void * updateProxy, unsigned int id, void* color) {
54145   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
54146   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
54147   return proxy->BakeColor(id, *vector4);
54148 }
54149
54150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_AddFrameCallback(void * jarg1, void* jarg2, void* jarg3) {
54151   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
54152   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
54153
54154   Dali::Stage *arg1 = (Dali::Stage *) 0;
54155   Dali::Actor *arg3 = 0;
54156
54157   arg1 = (Dali::Stage *)jarg1;
54158   arg3 = (Dali::Actor *)jarg3;
54159
54160   DevelStage::AddFrameCallback( *arg1, *arg2, *arg3 );
54161   return;
54162 }
54163
54164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_RemoveFrameCallback(void * jarg1, void* jarg2) {
54165
54166   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
54167   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
54168
54169   Dali::Stage *arg1 = (Dali::Stage *) 0;
54170
54171   arg1 = (Dali::Stage *)jarg1;
54172
54173   DevelStage::RemoveFrameCallback( *arg1, *arg2 );
54174   return;
54175 }
54176
54177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
54178   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
54179   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
54180   if (director) {
54181     director->swig_connect_director(callback0);
54182   }
54183 }
54184
54185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
54186   KeyboardFocusManager arg1 ;
54187   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
54188   KeyboardFocusManager *argp1 ;
54189
54190   argp1 = (KeyboardFocusManager *)jarg1;
54191   if (!argp1) {
54192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
54193     return ;
54194   }
54195   arg1 = *argp1;
54196   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
54197   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
54198   {
54199     try {
54200       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
54201     } CALL_CATCH_EXCEPTION();
54202   }
54203
54204 }
54205
54206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_EnableDefaultAlgorithm(void * jarg1, bool jarg2) {
54207   KeyboardFocusManager arg1 ;
54208   bool arg2 ;
54209   KeyboardFocusManager *argp1 ;
54210
54211   argp1 = (KeyboardFocusManager *)jarg1;
54212   if (!argp1) {
54213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
54214     return ;
54215   }
54216   arg1 = *argp1;
54217   arg2 = jarg2;
54218   {
54219     try {
54220       Dali::Toolkit::DevelKeyboardFocusManager::EnableDefaultAlgorithm(arg1, arg2);
54221     } CALL_CATCH_EXCEPTION();
54222   }
54223 }
54224
54225 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_IsDefaultAlgorithmEnabled(void * jarg1) {
54226   bool jresult ;
54227   KeyboardFocusManager arg1 ;
54228   KeyboardFocusManager *argp1 ;
54229   bool result;
54230
54231   argp1 = (KeyboardFocusManager *)jarg1;
54232   if (!argp1) {
54233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
54234     return false;
54235   }
54236   arg1 = *argp1;
54237   {
54238     try {
54239       result = Dali::Toolkit::DevelKeyboardFocusManager::IsDefaultAlgorithmEnabled(arg1);
54240     } CALL_CATCH_EXCEPTION(0);
54241   }
54242   jresult = result;
54243   return jresult;
54244 }
54245
54246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_SetFocusFinderRootActor(void * manager, void * actor) {
54247   if (!manager) {
54248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
54249     return ;
54250   }
54251   if (!actor) {
54252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
54253     return ;
54254   }
54255   {
54256     try {
54257       Dali::Toolkit::DevelKeyboardFocusManager::SetFocusFinderRootActor(*(KeyboardFocusManager *)manager, *(Dali::Actor *)actor);
54258     } CALL_CATCH_EXCEPTION();
54259   }
54260 }
54261
54262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_ResetFocusFinderRootActor(void * manager) {
54263   if (!manager) {
54264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
54265     return ;
54266   }
54267   {
54268     try {
54269       Dali::Toolkit::DevelKeyboardFocusManager::ResetFocusFinderRootActor(*(KeyboardFocusManager *)manager);
54270     } CALL_CATCH_EXCEPTION();
54271   }
54272 }
54273
54274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
54275   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54276
54277   arg1 = (std::vector< unsigned int > *)jarg1;
54278   {
54279     try {
54280       (arg1)->clear();
54281     } CALL_CATCH_EXCEPTION();
54282   }
54283
54284 }
54285
54286
54287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
54288   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54289   unsigned int *arg2 = 0 ;
54290   unsigned int temp2 ;
54291
54292   arg1 = (std::vector< unsigned int > *)jarg1;
54293   temp2 = (unsigned int)jarg2;
54294   arg2 = &temp2;
54295   {
54296     try {
54297       (arg1)->push_back((unsigned int const &)*arg2);
54298     } CALL_CATCH_EXCEPTION();
54299   }
54300
54301 }
54302
54303
54304 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
54305   unsigned long jresult ;
54306   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54307   std::vector< unsigned int >::size_type result;
54308
54309   arg1 = (std::vector< unsigned int > *)jarg1;
54310   {
54311     try {
54312       result = ((std::vector< unsigned int > const *)arg1)->size();
54313     } CALL_CATCH_EXCEPTION(0);
54314   }
54315
54316   jresult = (unsigned long)result;
54317   return jresult;
54318 }
54319
54320
54321 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
54322   unsigned long jresult ;
54323   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54324   std::vector< unsigned int >::size_type result;
54325
54326   arg1 = (std::vector< unsigned int > *)jarg1;
54327   {
54328     try {
54329       result = ((std::vector< unsigned int > const *)arg1)->capacity();
54330     } CALL_CATCH_EXCEPTION(0);
54331   }
54332
54333   jresult = (unsigned long)result;
54334   return jresult;
54335 }
54336
54337
54338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
54339   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54340   std::vector< unsigned int >::size_type arg2 ;
54341
54342   arg1 = (std::vector< unsigned int > *)jarg1;
54343   arg2 = (std::vector< unsigned int >::size_type)jarg2;
54344   {
54345     try {
54346       (arg1)->reserve(arg2);
54347     } CALL_CATCH_EXCEPTION();
54348   }
54349
54350 }
54351
54352
54353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
54354   void * jresult ;
54355   std::vector< unsigned int > *result = 0 ;
54356
54357   {
54358     try {
54359       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
54360     } CALL_CATCH_EXCEPTION(0);
54361   }
54362
54363   jresult = (void *)result;
54364   return jresult;
54365 }
54366
54367
54368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
54369   void * jresult ;
54370   std::vector< unsigned int > *arg1 = 0 ;
54371   std::vector< unsigned int > *result = 0 ;
54372
54373   arg1 = (std::vector< unsigned int > *)jarg1;
54374   if (!arg1) {
54375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
54376     return 0;
54377   }
54378   {
54379     try {
54380       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
54381     } CALL_CATCH_EXCEPTION(0);
54382   }
54383
54384   jresult = (void *)result;
54385   return jresult;
54386 }
54387
54388
54389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
54390   void * jresult ;
54391   int arg1 ;
54392   std::vector< unsigned int > *result = 0 ;
54393
54394   arg1 = (int)jarg1;
54395   {
54396     try {
54397       try {
54398         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
54399       }
54400       catch(std::out_of_range &_e) {
54401         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54402         return 0;
54403       }
54404
54405     } CALL_CATCH_EXCEPTION(0);
54406   }
54407
54408   jresult = (void *)result;
54409   return jresult;
54410 }
54411
54412
54413 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
54414   unsigned int jresult ;
54415   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54416   int arg2 ;
54417   unsigned int result;
54418
54419   arg1 = (std::vector< unsigned int > *)jarg1;
54420   arg2 = (int)jarg2;
54421   {
54422     try {
54423       try {
54424         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
54425       }
54426       catch(std::out_of_range &_e) {
54427         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54428         return 0;
54429       }
54430
54431     } CALL_CATCH_EXCEPTION(0);
54432   }
54433
54434   jresult = result;
54435   return jresult;
54436 }
54437
54438
54439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
54440   unsigned int jresult ;
54441   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54442   int arg2 ;
54443   unsigned int *result = 0 ;
54444
54445   arg1 = (std::vector< unsigned int > *)jarg1;
54446   arg2 = (int)jarg2;
54447   {
54448     try {
54449       try {
54450         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
54451       }
54452       catch(std::out_of_range &_e) {
54453         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54454         return 0;
54455       }
54456
54457     } CALL_CATCH_EXCEPTION(0);
54458   }
54459
54460   jresult = *result;
54461   return jresult;
54462 }
54463
54464
54465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
54466   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54467   int arg2 ;
54468   unsigned int *arg3 = 0 ;
54469   unsigned int temp3 ;
54470
54471   arg1 = (std::vector< unsigned int > *)jarg1;
54472   arg2 = (int)jarg2;
54473   temp3 = (unsigned int)jarg3;
54474   arg3 = &temp3;
54475   {
54476     try {
54477       try {
54478         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
54479       }
54480       catch(std::out_of_range &_e) {
54481         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54482         return ;
54483       }
54484
54485     } CALL_CATCH_EXCEPTION();
54486   }
54487
54488 }
54489
54490
54491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
54492   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54493   std::vector< unsigned int > *arg2 = 0 ;
54494
54495   arg1 = (std::vector< unsigned int > *)jarg1;
54496   arg2 = (std::vector< unsigned int > *)jarg2;
54497   if (!arg2) {
54498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
54499     return ;
54500   }
54501   {
54502     try {
54503       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
54504     } CALL_CATCH_EXCEPTION();
54505   }
54506
54507 }
54508
54509
54510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
54511   void * jresult ;
54512   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54513   int arg2 ;
54514   int arg3 ;
54515   std::vector< unsigned int > *result = 0 ;
54516
54517   arg1 = (std::vector< unsigned int > *)jarg1;
54518   arg2 = (int)jarg2;
54519   arg3 = (int)jarg3;
54520   {
54521     try {
54522       try {
54523         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
54524       }
54525       catch(std::out_of_range &_e) {
54526         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54527         return 0;
54528       }
54529       catch(std::invalid_argument &_e) {
54530         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
54531         return 0;
54532       }
54533
54534     } CALL_CATCH_EXCEPTION(0);
54535   }
54536
54537   jresult = (void *)result;
54538   return jresult;
54539 }
54540
54541
54542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
54543   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54544   int arg2 ;
54545   unsigned int *arg3 = 0 ;
54546   unsigned int temp3 ;
54547
54548   arg1 = (std::vector< unsigned int > *)jarg1;
54549   arg2 = (int)jarg2;
54550   temp3 = (unsigned int)jarg3;
54551   arg3 = &temp3;
54552   {
54553     try {
54554       try {
54555         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
54556       }
54557       catch(std::out_of_range &_e) {
54558         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54559         return ;
54560       }
54561
54562     } CALL_CATCH_EXCEPTION();
54563   }
54564
54565 }
54566
54567
54568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
54569   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54570   int arg2 ;
54571   std::vector< unsigned int > *arg3 = 0 ;
54572
54573   arg1 = (std::vector< unsigned int > *)jarg1;
54574   arg2 = (int)jarg2;
54575   arg3 = (std::vector< unsigned int > *)jarg3;
54576   if (!arg3) {
54577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
54578     return ;
54579   }
54580   {
54581     try {
54582       try {
54583         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
54584       }
54585       catch(std::out_of_range &_e) {
54586         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54587         return ;
54588       }
54589
54590     } CALL_CATCH_EXCEPTION();
54591   }
54592
54593 }
54594
54595
54596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
54597   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54598   int arg2 ;
54599
54600   arg1 = (std::vector< unsigned int > *)jarg1;
54601   arg2 = (int)jarg2;
54602   {
54603     try {
54604       try {
54605         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
54606       }
54607       catch(std::out_of_range &_e) {
54608         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54609         return ;
54610       }
54611
54612     } CALL_CATCH_EXCEPTION();
54613   }
54614
54615 }
54616
54617
54618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
54619   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54620   int arg2 ;
54621   int arg3 ;
54622
54623   arg1 = (std::vector< unsigned int > *)jarg1;
54624   arg2 = (int)jarg2;
54625   arg3 = (int)jarg3;
54626   {
54627     try {
54628       try {
54629         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
54630       }
54631       catch(std::out_of_range &_e) {
54632         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54633         return ;
54634       }
54635       catch(std::invalid_argument &_e) {
54636         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
54637         return ;
54638       }
54639
54640     } CALL_CATCH_EXCEPTION();
54641   }
54642
54643 }
54644
54645
54646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
54647   void * jresult ;
54648   unsigned int *arg1 = 0 ;
54649   int arg2 ;
54650   unsigned int temp1 ;
54651   std::vector< unsigned int > *result = 0 ;
54652
54653   temp1 = (unsigned int)jarg1;
54654   arg1 = &temp1;
54655   arg2 = (int)jarg2;
54656   {
54657     try {
54658       try {
54659         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
54660       }
54661       catch(std::out_of_range &_e) {
54662         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54663         return 0;
54664       }
54665
54666     } CALL_CATCH_EXCEPTION(0);
54667   }
54668
54669   jresult = (void *)result;
54670   return jresult;
54671 }
54672
54673
54674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
54675   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54676
54677   arg1 = (std::vector< unsigned int > *)jarg1;
54678   {
54679     try {
54680       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
54681     } CALL_CATCH_EXCEPTION();
54682   }
54683
54684 }
54685
54686
54687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
54688   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54689   int arg2 ;
54690   int arg3 ;
54691
54692   arg1 = (std::vector< unsigned int > *)jarg1;
54693   arg2 = (int)jarg2;
54694   arg3 = (int)jarg3;
54695   {
54696     try {
54697       try {
54698         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
54699       }
54700       catch(std::out_of_range &_e) {
54701         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54702         return ;
54703       }
54704       catch(std::invalid_argument &_e) {
54705         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
54706         return ;
54707       }
54708
54709     } CALL_CATCH_EXCEPTION();
54710   }
54711
54712 }
54713
54714
54715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
54716   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54717   int arg2 ;
54718   std::vector< unsigned int > *arg3 = 0 ;
54719
54720   arg1 = (std::vector< unsigned int > *)jarg1;
54721   arg2 = (int)jarg2;
54722   arg3 = (std::vector< unsigned int > *)jarg3;
54723   if (!arg3) {
54724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
54725     return ;
54726   }
54727   {
54728     try {
54729       try {
54730         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
54731       }
54732       catch(std::out_of_range &_e) {
54733         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54734         return ;
54735       }
54736
54737     } CALL_CATCH_EXCEPTION();
54738   }
54739
54740 }
54741
54742
54743 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
54744   bool jresult ;
54745   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54746   unsigned int *arg2 = 0 ;
54747   unsigned int temp2 ;
54748   bool result;
54749
54750   arg1 = (std::vector< unsigned int > *)jarg1;
54751   temp2 = (unsigned int)jarg2;
54752   arg2 = &temp2;
54753   {
54754     try {
54755       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
54756     } CALL_CATCH_EXCEPTION(0);
54757   }
54758
54759   jresult = result;
54760   return jresult;
54761 }
54762
54763
54764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
54765   int jresult ;
54766   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54767   unsigned int *arg2 = 0 ;
54768   unsigned int temp2 ;
54769   int result;
54770
54771   arg1 = (std::vector< unsigned int > *)jarg1;
54772   temp2 = (unsigned int)jarg2;
54773   arg2 = &temp2;
54774   {
54775     try {
54776       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
54777     } CALL_CATCH_EXCEPTION(0);
54778   }
54779
54780   jresult = result;
54781   return jresult;
54782 }
54783
54784
54785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
54786   int jresult ;
54787   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54788   unsigned int *arg2 = 0 ;
54789   unsigned int temp2 ;
54790   int result;
54791
54792   arg1 = (std::vector< unsigned int > *)jarg1;
54793   temp2 = (unsigned int)jarg2;
54794   arg2 = &temp2;
54795   {
54796     try {
54797       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
54798     } CALL_CATCH_EXCEPTION(0);
54799   }
54800
54801   jresult = result;
54802   return jresult;
54803 }
54804
54805
54806 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
54807   bool jresult ;
54808   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54809   unsigned int *arg2 = 0 ;
54810   unsigned int temp2 ;
54811   bool result;
54812
54813   arg1 = (std::vector< unsigned int > *)jarg1;
54814   temp2 = (unsigned int)jarg2;
54815   arg2 = &temp2;
54816   {
54817     try {
54818       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
54819     } CALL_CATCH_EXCEPTION(0);
54820   }
54821
54822   jresult = result;
54823   return jresult;
54824 }
54825
54826
54827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
54828   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54829
54830   arg1 = (std::vector< unsigned int > *)jarg1;
54831   {
54832     try {
54833       delete arg1;
54834     } CALL_CATCH_EXCEPTION();
54835   }
54836
54837 }
54838
54839
54840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
54841   void * jresult ;
54842   std::pair< unsigned int,Dali::Actor > *result = 0 ;
54843
54844   {
54845     try {
54846       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
54847     } CALL_CATCH_EXCEPTION(0);
54848   }
54849
54850   jresult = (void *)result;
54851   return jresult;
54852 }
54853
54854
54855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
54856   void * jresult ;
54857   unsigned int arg1 ;
54858   Dali::Actor arg2 ;
54859   Dali::Actor *argp2 ;
54860   std::pair< unsigned int,Dali::Actor > *result = 0 ;
54861
54862   arg1 = (unsigned int)jarg1;
54863   argp2 = (Dali::Actor *)jarg2;
54864   if (!argp2) {
54865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54866     return 0;
54867   }
54868   arg2 = *argp2;
54869   {
54870     try {
54871       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
54872     } CALL_CATCH_EXCEPTION(0);
54873   }
54874
54875   jresult = (void *)result;
54876   return jresult;
54877 }
54878
54879
54880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
54881   void * jresult ;
54882   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
54883   std::pair< unsigned int,Dali::Actor > *result = 0 ;
54884
54885   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
54886   if (!arg1) {
54887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
54888     return 0;
54889   }
54890   {
54891     try {
54892       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
54893     } CALL_CATCH_EXCEPTION(0);
54894   }
54895
54896   jresult = (void *)result;
54897   return jresult;
54898 }
54899
54900
54901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
54902   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
54903   unsigned int arg2 ;
54904
54905   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
54906   arg2 = (unsigned int)jarg2;
54907   if (arg1) (arg1)->first = arg2;
54908 }
54909
54910
54911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
54912   unsigned int jresult ;
54913   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
54914   unsigned int result;
54915
54916   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
54917   result = (unsigned int) ((arg1)->first);
54918   jresult = result;
54919   return jresult;
54920 }
54921
54922
54923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
54924   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
54925   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
54926
54927   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
54928   arg2 = (Dali::Actor *)jarg2;
54929   if (arg1) (arg1)->second = *arg2;
54930 }
54931
54932
54933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
54934   void * jresult ;
54935   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
54936   Dali::Actor *result = 0 ;
54937
54938   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
54939   result = (Dali::Actor *)& ((arg1)->second);
54940   jresult = (void *)result;
54941   return jresult;
54942 }
54943
54944
54945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
54946   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
54947
54948   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
54949   {
54950     try {
54951       delete arg1;
54952     } CALL_CATCH_EXCEPTION();
54953   }
54954
54955 }
54956
54957
54958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
54959   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54960
54961   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54962   {
54963     try {
54964       (arg1)->clear();
54965     } CALL_CATCH_EXCEPTION();
54966   }
54967
54968 }
54969
54970
54971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
54972   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54973   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
54974
54975   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54976   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
54977   if (!arg2) {
54978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
54979     return ;
54980   }
54981   {
54982     try {
54983       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
54984     } CALL_CATCH_EXCEPTION();
54985   }
54986
54987 }
54988
54989
54990 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
54991   unsigned long jresult ;
54992   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54993   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
54994
54995   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54996   {
54997     try {
54998       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
54999     } CALL_CATCH_EXCEPTION(0);
55000   }
55001
55002   jresult = (unsigned long)result;
55003   return jresult;
55004 }
55005
55006
55007 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
55008   unsigned long jresult ;
55009   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
55010   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
55011
55012   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55013   {
55014     try {
55015       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
55016     } CALL_CATCH_EXCEPTION(0);
55017   }
55018
55019   jresult = (unsigned long)result;
55020   return jresult;
55021 }
55022
55023
55024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
55025   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
55026   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
55027
55028   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55029   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
55030   {
55031     try {
55032       (arg1)->reserve(arg2);
55033     } CALL_CATCH_EXCEPTION();
55034   }
55035
55036 }
55037
55038
55039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
55040   void * jresult ;
55041   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
55042
55043   {
55044     try {
55045       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
55046     } CALL_CATCH_EXCEPTION(0);
55047   }
55048
55049   jresult = (void *)result;
55050   return jresult;
55051 }
55052
55053
55054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
55055   void * jresult ;
55056   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
55057   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
55058
55059   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55060   if (!arg1) {
55061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
55062     return 0;
55063   }
55064   {
55065     try {
55066       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);
55067     } CALL_CATCH_EXCEPTION(0);
55068   }
55069
55070   jresult = (void *)result;
55071   return jresult;
55072 }
55073
55074
55075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
55076   void * jresult ;
55077   int arg1 ;
55078   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
55079
55080   arg1 = (int)jarg1;
55081   {
55082     try {
55083       try {
55084         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);
55085       }
55086       catch(std::out_of_range &_e) {
55087         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55088         return 0;
55089       }
55090
55091     } CALL_CATCH_EXCEPTION(0);
55092   }
55093
55094   jresult = (void *)result;
55095   return jresult;
55096 }
55097
55098
55099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
55100   void * jresult ;
55101   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
55102   int arg2 ;
55103   std::pair< unsigned int,Dali::Actor > result;
55104
55105   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55106   arg2 = (int)jarg2;
55107   {
55108     try {
55109       try {
55110         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
55111       }
55112       catch(std::out_of_range &_e) {
55113         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55114         return 0;
55115       }
55116
55117     } CALL_CATCH_EXCEPTION(0);
55118   }
55119
55120   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
55121   return jresult;
55122 }
55123
55124
55125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
55126   void * jresult ;
55127   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
55128   int arg2 ;
55129   std::pair< unsigned int,Dali::Actor > *result = 0 ;
55130
55131   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55132   arg2 = (int)jarg2;
55133   {
55134     try {
55135       try {
55136         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
55137       }
55138       catch(std::out_of_range &_e) {
55139         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55140         return 0;
55141       }
55142
55143     } CALL_CATCH_EXCEPTION(0);
55144   }
55145
55146   jresult = (void *)result;
55147   return jresult;
55148 }
55149
55150
55151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
55152   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
55153   int arg2 ;
55154   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
55155
55156   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55157   arg2 = (int)jarg2;
55158   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
55159   if (!arg3) {
55160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
55161     return ;
55162   }
55163   {
55164     try {
55165       try {
55166         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);
55167       }
55168       catch(std::out_of_range &_e) {
55169         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55170         return ;
55171       }
55172
55173     } CALL_CATCH_EXCEPTION();
55174   }
55175
55176 }
55177
55178
55179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
55180   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
55181   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
55182
55183   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55184   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
55185   if (!arg2) {
55186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
55187     return ;
55188   }
55189   {
55190     try {
55191       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);
55192     } CALL_CATCH_EXCEPTION();
55193   }
55194
55195 }
55196
55197
55198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
55199   void * jresult ;
55200   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
55201   int arg2 ;
55202   int arg3 ;
55203   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
55204
55205   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55206   arg2 = (int)jarg2;
55207   arg3 = (int)jarg3;
55208   {
55209     try {
55210       try {
55211         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);
55212       }
55213       catch(std::out_of_range &_e) {
55214         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55215         return 0;
55216       }
55217       catch(std::invalid_argument &_e) {
55218         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
55219         return 0;
55220       }
55221
55222     } CALL_CATCH_EXCEPTION(0);
55223   }
55224
55225   jresult = (void *)result;
55226   return jresult;
55227 }
55228
55229
55230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
55231   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
55232   int arg2 ;
55233   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
55234
55235   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55236   arg2 = (int)jarg2;
55237   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
55238   if (!arg3) {
55239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
55240     return ;
55241   }
55242   {
55243     try {
55244       try {
55245         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);
55246       }
55247       catch(std::out_of_range &_e) {
55248         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55249         return ;
55250       }
55251
55252     } CALL_CATCH_EXCEPTION();
55253   }
55254
55255 }
55256
55257
55258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
55259   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
55260   int arg2 ;
55261   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
55262
55263   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55264   arg2 = (int)jarg2;
55265   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
55266   if (!arg3) {
55267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
55268     return ;
55269   }
55270   {
55271     try {
55272       try {
55273         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);
55274       }
55275       catch(std::out_of_range &_e) {
55276         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55277         return ;
55278       }
55279
55280     } CALL_CATCH_EXCEPTION();
55281   }
55282
55283 }
55284
55285
55286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
55287   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
55288   int arg2 ;
55289
55290   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55291   arg2 = (int)jarg2;
55292   {
55293     try {
55294       try {
55295         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
55296       }
55297       catch(std::out_of_range &_e) {
55298         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55299         return ;
55300       }
55301
55302     } CALL_CATCH_EXCEPTION();
55303   }
55304
55305 }
55306
55307
55308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
55309   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
55310   int arg2 ;
55311   int arg3 ;
55312
55313   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55314   arg2 = (int)jarg2;
55315   arg3 = (int)jarg3;
55316   {
55317     try {
55318       try {
55319         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
55320       }
55321       catch(std::out_of_range &_e) {
55322         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55323         return ;
55324       }
55325       catch(std::invalid_argument &_e) {
55326         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
55327         return ;
55328       }
55329
55330     } CALL_CATCH_EXCEPTION();
55331   }
55332
55333 }
55334
55335
55336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
55337   void * jresult ;
55338   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
55339   int arg2 ;
55340   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
55341
55342   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
55343   if (!arg1) {
55344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
55345     return 0;
55346   }
55347   arg2 = (int)jarg2;
55348   {
55349     try {
55350       try {
55351         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);
55352       }
55353       catch(std::out_of_range &_e) {
55354         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55355         return 0;
55356       }
55357
55358     } CALL_CATCH_EXCEPTION(0);
55359   }
55360
55361   jresult = (void *)result;
55362   return jresult;
55363 }
55364
55365
55366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
55367   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
55368
55369   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55370   {
55371     try {
55372       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
55373     } CALL_CATCH_EXCEPTION();
55374   }
55375
55376 }
55377
55378
55379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
55380   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
55381   int arg2 ;
55382   int arg3 ;
55383
55384   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55385   arg2 = (int)jarg2;
55386   arg3 = (int)jarg3;
55387   {
55388     try {
55389       try {
55390         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
55391       }
55392       catch(std::out_of_range &_e) {
55393         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55394         return ;
55395       }
55396       catch(std::invalid_argument &_e) {
55397         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
55398         return ;
55399       }
55400
55401     } CALL_CATCH_EXCEPTION();
55402   }
55403
55404 }
55405
55406
55407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
55408   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
55409   int arg2 ;
55410   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
55411
55412   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55413   arg2 = (int)jarg2;
55414   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
55415   if (!arg3) {
55416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
55417     return ;
55418   }
55419   {
55420     try {
55421       try {
55422         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);
55423       }
55424       catch(std::out_of_range &_e) {
55425         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55426         return ;
55427       }
55428
55429     } CALL_CATCH_EXCEPTION();
55430   }
55431
55432 }
55433
55434
55435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
55436   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
55437
55438   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55439   {
55440     try {
55441       delete arg1;
55442     } CALL_CATCH_EXCEPTION();
55443   }
55444
55445 }
55446
55447
55448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
55449   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55450
55451   arg1 = (std::vector< Dali::Actor > *)jarg1;
55452   {
55453     try {
55454       (arg1)->clear();
55455     } CALL_CATCH_EXCEPTION();
55456   }
55457
55458 }
55459
55460
55461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
55462   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55463   Dali::Actor *arg2 = 0 ;
55464
55465   arg1 = (std::vector< Dali::Actor > *)jarg1;
55466   arg2 = (Dali::Actor *)jarg2;
55467   if (!arg2) {
55468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
55469     return ;
55470   }
55471   {
55472     try {
55473       (arg1)->push_back((Dali::Actor const &)*arg2);
55474     } CALL_CATCH_EXCEPTION();
55475   }
55476
55477 }
55478
55479
55480 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
55481   unsigned long jresult ;
55482   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55483   std::vector< Dali::Actor >::size_type result;
55484
55485   arg1 = (std::vector< Dali::Actor > *)jarg1;
55486   {
55487     try {
55488       result = ((std::vector< Dali::Actor > const *)arg1)->size();
55489     } CALL_CATCH_EXCEPTION(0);
55490   }
55491
55492   jresult = (unsigned long)result;
55493   return jresult;
55494 }
55495
55496
55497 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
55498   unsigned long jresult ;
55499   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55500   std::vector< Dali::Actor >::size_type result;
55501
55502   arg1 = (std::vector< Dali::Actor > *)jarg1;
55503   {
55504     try {
55505       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
55506     } CALL_CATCH_EXCEPTION(0);
55507   }
55508
55509   jresult = (unsigned long)result;
55510   return jresult;
55511 }
55512
55513
55514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
55515   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55516   std::vector< Dali::Actor >::size_type arg2 ;
55517
55518   arg1 = (std::vector< Dali::Actor > *)jarg1;
55519   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
55520   {
55521     try {
55522       (arg1)->reserve(arg2);
55523     } CALL_CATCH_EXCEPTION();
55524   }
55525
55526 }
55527
55528
55529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
55530   void * jresult ;
55531   std::vector< Dali::Actor > *result = 0 ;
55532
55533   {
55534     try {
55535       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
55536     } CALL_CATCH_EXCEPTION(0);
55537   }
55538
55539   jresult = (void *)result;
55540   return jresult;
55541 }
55542
55543
55544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
55545   void * jresult ;
55546   std::vector< Dali::Actor > *arg1 = 0 ;
55547   std::vector< Dali::Actor > *result = 0 ;
55548
55549   arg1 = (std::vector< Dali::Actor > *)jarg1;
55550   if (!arg1) {
55551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
55552     return 0;
55553   }
55554   {
55555     try {
55556       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
55557     } CALL_CATCH_EXCEPTION(0);
55558   }
55559
55560   jresult = (void *)result;
55561   return jresult;
55562 }
55563
55564
55565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
55566   void * jresult ;
55567   int arg1 ;
55568   std::vector< Dali::Actor > *result = 0 ;
55569
55570   arg1 = (int)jarg1;
55571   {
55572     try {
55573       try {
55574         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
55575       }
55576       catch(std::out_of_range &_e) {
55577         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55578         return 0;
55579       }
55580
55581     } CALL_CATCH_EXCEPTION(0);
55582   }
55583
55584   jresult = (void *)result;
55585   return jresult;
55586 }
55587
55588
55589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
55590   void * jresult ;
55591   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55592   int arg2 ;
55593   Dali::Actor result;
55594
55595   arg1 = (std::vector< Dali::Actor > *)jarg1;
55596   arg2 = (int)jarg2;
55597   {
55598     try {
55599       try {
55600         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
55601       }
55602       catch(std::out_of_range &_e) {
55603         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55604         return 0;
55605       }
55606
55607     } CALL_CATCH_EXCEPTION(0);
55608   }
55609
55610   jresult = new Dali::Actor((const Dali::Actor &)result);
55611   return jresult;
55612 }
55613
55614
55615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
55616   void * jresult ;
55617   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55618   int arg2 ;
55619   Dali::Actor *result = 0 ;
55620
55621   arg1 = (std::vector< Dali::Actor > *)jarg1;
55622   arg2 = (int)jarg2;
55623   {
55624     try {
55625       try {
55626         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
55627       }
55628       catch(std::out_of_range &_e) {
55629         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55630         return 0;
55631       }
55632
55633     } CALL_CATCH_EXCEPTION(0);
55634   }
55635
55636   jresult = (void *)result;
55637   return jresult;
55638 }
55639
55640
55641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
55642   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55643   int arg2 ;
55644   Dali::Actor *arg3 = 0 ;
55645
55646   arg1 = (std::vector< Dali::Actor > *)jarg1;
55647   arg2 = (int)jarg2;
55648   arg3 = (Dali::Actor *)jarg3;
55649   if (!arg3) {
55650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
55651     return ;
55652   }
55653   {
55654     try {
55655       try {
55656         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
55657       }
55658       catch(std::out_of_range &_e) {
55659         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55660         return ;
55661       }
55662
55663     } CALL_CATCH_EXCEPTION();
55664   }
55665
55666 }
55667
55668
55669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
55670   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55671   std::vector< Dali::Actor > *arg2 = 0 ;
55672
55673   arg1 = (std::vector< Dali::Actor > *)jarg1;
55674   arg2 = (std::vector< Dali::Actor > *)jarg2;
55675   if (!arg2) {
55676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
55677     return ;
55678   }
55679   {
55680     try {
55681       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
55682     } CALL_CATCH_EXCEPTION();
55683   }
55684
55685 }
55686
55687
55688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
55689   void * jresult ;
55690   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55691   int arg2 ;
55692   int arg3 ;
55693   std::vector< Dali::Actor > *result = 0 ;
55694
55695   arg1 = (std::vector< Dali::Actor > *)jarg1;
55696   arg2 = (int)jarg2;
55697   arg3 = (int)jarg3;
55698   {
55699     try {
55700       try {
55701         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
55702       }
55703       catch(std::out_of_range &_e) {
55704         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55705         return 0;
55706       }
55707       catch(std::invalid_argument &_e) {
55708         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
55709         return 0;
55710       }
55711
55712     } CALL_CATCH_EXCEPTION(0);
55713   }
55714
55715   jresult = (void *)result;
55716   return jresult;
55717 }
55718
55719
55720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
55721   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55722   int arg2 ;
55723   Dali::Actor *arg3 = 0 ;
55724
55725   arg1 = (std::vector< Dali::Actor > *)jarg1;
55726   arg2 = (int)jarg2;
55727   arg3 = (Dali::Actor *)jarg3;
55728   if (!arg3) {
55729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
55730     return ;
55731   }
55732   {
55733     try {
55734       try {
55735         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
55736       }
55737       catch(std::out_of_range &_e) {
55738         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55739         return ;
55740       }
55741
55742     } CALL_CATCH_EXCEPTION();
55743   }
55744
55745 }
55746
55747
55748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
55749   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55750   int arg2 ;
55751   std::vector< Dali::Actor > *arg3 = 0 ;
55752
55753   arg1 = (std::vector< Dali::Actor > *)jarg1;
55754   arg2 = (int)jarg2;
55755   arg3 = (std::vector< Dali::Actor > *)jarg3;
55756   if (!arg3) {
55757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
55758     return ;
55759   }
55760   {
55761     try {
55762       try {
55763         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
55764       }
55765       catch(std::out_of_range &_e) {
55766         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55767         return ;
55768       }
55769
55770     } CALL_CATCH_EXCEPTION();
55771   }
55772
55773 }
55774
55775
55776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
55777   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55778   int arg2 ;
55779
55780   arg1 = (std::vector< Dali::Actor > *)jarg1;
55781   arg2 = (int)jarg2;
55782   {
55783     try {
55784       try {
55785         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
55786       }
55787       catch(std::out_of_range &_e) {
55788         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55789         return ;
55790       }
55791
55792     } CALL_CATCH_EXCEPTION();
55793   }
55794
55795 }
55796
55797
55798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
55799   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55800   int arg2 ;
55801   int arg3 ;
55802
55803   arg1 = (std::vector< Dali::Actor > *)jarg1;
55804   arg2 = (int)jarg2;
55805   arg3 = (int)jarg3;
55806   {
55807     try {
55808       try {
55809         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
55810       }
55811       catch(std::out_of_range &_e) {
55812         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55813         return ;
55814       }
55815       catch(std::invalid_argument &_e) {
55816         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
55817         return ;
55818       }
55819
55820     } CALL_CATCH_EXCEPTION();
55821   }
55822
55823 }
55824
55825
55826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
55827   void * jresult ;
55828   Dali::Actor *arg1 = 0 ;
55829   int arg2 ;
55830   std::vector< Dali::Actor > *result = 0 ;
55831
55832   arg1 = (Dali::Actor *)jarg1;
55833   if (!arg1) {
55834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
55835     return 0;
55836   }
55837   arg2 = (int)jarg2;
55838   {
55839     try {
55840       try {
55841         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
55842       }
55843       catch(std::out_of_range &_e) {
55844         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55845         return 0;
55846       }
55847
55848     } CALL_CATCH_EXCEPTION(0);
55849   }
55850
55851   jresult = (void *)result;
55852   return jresult;
55853 }
55854
55855
55856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
55857   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55858
55859   arg1 = (std::vector< Dali::Actor > *)jarg1;
55860   {
55861     try {
55862       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
55863     } CALL_CATCH_EXCEPTION();
55864   }
55865
55866 }
55867
55868
55869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
55870   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55871   int arg2 ;
55872   int arg3 ;
55873
55874   arg1 = (std::vector< Dali::Actor > *)jarg1;
55875   arg2 = (int)jarg2;
55876   arg3 = (int)jarg3;
55877   {
55878     try {
55879       try {
55880         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
55881       }
55882       catch(std::out_of_range &_e) {
55883         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55884         return ;
55885       }
55886       catch(std::invalid_argument &_e) {
55887         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
55888         return ;
55889       }
55890
55891     } CALL_CATCH_EXCEPTION();
55892   }
55893
55894 }
55895
55896
55897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
55898   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55899   int arg2 ;
55900   std::vector< Dali::Actor > *arg3 = 0 ;
55901
55902   arg1 = (std::vector< Dali::Actor > *)jarg1;
55903   arg2 = (int)jarg2;
55904   arg3 = (std::vector< Dali::Actor > *)jarg3;
55905   if (!arg3) {
55906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
55907     return ;
55908   }
55909   {
55910     try {
55911       try {
55912         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
55913       }
55914       catch(std::out_of_range &_e) {
55915         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55916         return ;
55917       }
55918
55919     } CALL_CATCH_EXCEPTION();
55920   }
55921
55922 }
55923
55924
55925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
55926   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55927
55928   arg1 = (std::vector< Dali::Actor > *)jarg1;
55929   {
55930     try {
55931       delete arg1;
55932     } CALL_CATCH_EXCEPTION();
55933   }
55934
55935 }
55936
55937
55938 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
55939   bool jresult ;
55940   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
55941   bool result;
55942
55943   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
55944   {
55945     try {
55946       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
55947     } CALL_CATCH_EXCEPTION(0);
55948   }
55949
55950   jresult = result;
55951   return jresult;
55952 }
55953
55954
55955 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
55956   unsigned long jresult ;
55957   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
55958   std::size_t result;
55959
55960   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
55961   {
55962     try {
55963       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
55964     } CALL_CATCH_EXCEPTION(0);
55965   }
55966
55967   jresult = (unsigned long)result;
55968   return jresult;
55969 }
55970
55971
55972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
55973   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
55974   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
55975
55976   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
55977   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
55978   {
55979     try {
55980       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
55981     } CALL_CATCH_EXCEPTION();
55982   }
55983
55984 }
55985
55986
55987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
55988   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
55989   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
55990
55991   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
55992   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
55993   {
55994     try {
55995       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
55996     } CALL_CATCH_EXCEPTION();
55997   }
55998
55999 }
56000
56001
56002 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
56003   bool jresult ;
56004   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
56005   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
56006   bool result;
56007
56008   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
56009   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
56010   if (!arg2) {
56011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
56012     return 0;
56013   }
56014   {
56015     try {
56016       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
56017     } CALL_CATCH_EXCEPTION(0);
56018   }
56019
56020   jresult = result;
56021   return jresult;
56022 }
56023
56024
56025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
56026   void * jresult ;
56027   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
56028
56029   {
56030     try {
56031       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
56032     } CALL_CATCH_EXCEPTION(0);
56033   }
56034
56035   jresult = (void *)result;
56036   return jresult;
56037 }
56038
56039
56040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
56041   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
56042
56043   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
56044   {
56045     try {
56046       delete arg1;
56047     } CALL_CATCH_EXCEPTION();
56048   }
56049
56050 }
56051
56052
56053 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
56054   bool jresult ;
56055   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
56056   bool result;
56057
56058   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
56059   {
56060     try {
56061       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);
56062     } CALL_CATCH_EXCEPTION(0);
56063   }
56064
56065   jresult = result;
56066   return jresult;
56067 }
56068
56069
56070 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
56071   unsigned long jresult ;
56072   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
56073   std::size_t result;
56074
56075   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
56076   {
56077     try {
56078       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);
56079     } CALL_CATCH_EXCEPTION(0);
56080   }
56081
56082   jresult = (unsigned long)result;
56083   return jresult;
56084 }
56085
56086
56087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
56088   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
56089   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
56090
56091   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
56092   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
56093   {
56094     try {
56095       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
56096     } CALL_CATCH_EXCEPTION();
56097   }
56098
56099 }
56100
56101
56102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
56103   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
56104   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
56105
56106   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
56107   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
56108   {
56109     try {
56110       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
56111     } CALL_CATCH_EXCEPTION();
56112   }
56113
56114 }
56115
56116
56117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
56118   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
56119   Dali::Actor arg2 ;
56120   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
56121   Dali::Actor *argp2 ;
56122
56123   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
56124   argp2 = (Dali::Actor *)jarg2;
56125   if (!argp2) {
56126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56127     return ;
56128   }
56129   arg2 = *argp2;
56130   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
56131   {
56132     try {
56133       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
56134     } CALL_CATCH_EXCEPTION();
56135   }
56136
56137 }
56138
56139
56140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
56141   void * jresult ;
56142   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
56143
56144   {
56145     try {
56146       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
56147     } CALL_CATCH_EXCEPTION(0);
56148   }
56149
56150   jresult = (void *)result;
56151   return jresult;
56152 }
56153
56154
56155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
56156   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
56157
56158   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
56159   {
56160     try {
56161       delete arg1;
56162     } CALL_CATCH_EXCEPTION();
56163   }
56164
56165 }
56166
56167
56168 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
56169   bool jresult ;
56170   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
56171   bool result;
56172
56173   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
56174   {
56175     try {
56176       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
56177     } CALL_CATCH_EXCEPTION(0);
56178   }
56179
56180   jresult = result;
56181   return jresult;
56182 }
56183
56184
56185 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
56186   unsigned long jresult ;
56187   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
56188   std::size_t result;
56189
56190   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
56191   {
56192     try {
56193       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
56194     } CALL_CATCH_EXCEPTION(0);
56195   }
56196
56197   jresult = (unsigned long)result;
56198   return jresult;
56199 }
56200
56201
56202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
56203   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
56204   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
56205
56206   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
56207   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
56208   {
56209     try {
56210       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
56211     } CALL_CATCH_EXCEPTION();
56212   }
56213
56214 }
56215
56216
56217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
56218   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
56219   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
56220
56221   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
56222   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
56223   {
56224     try {
56225       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
56226     } CALL_CATCH_EXCEPTION();
56227   }
56228
56229 }
56230
56231
56232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
56233   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
56234   Dali::Actor arg2 ;
56235   Dali::Actor arg3 ;
56236   Dali::Actor *argp2 ;
56237   Dali::Actor *argp3 ;
56238
56239   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
56240   argp2 = (Dali::Actor *)jarg2;
56241   if (!argp2) {
56242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56243     return ;
56244   }
56245   arg2 = *argp2;
56246   argp3 = (Dali::Actor *)jarg3;
56247   if (!argp3) {
56248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56249     return ;
56250   }
56251   arg3 = *argp3;
56252   {
56253     try {
56254       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
56255     } CALL_CATCH_EXCEPTION();
56256   }
56257
56258 }
56259
56260
56261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
56262   void * jresult ;
56263   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
56264
56265   {
56266     try {
56267       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
56268     } CALL_CATCH_EXCEPTION(0);
56269   }
56270
56271   jresult = (void *)result;
56272   return jresult;
56273 }
56274
56275
56276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
56277   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
56278
56279   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
56280   {
56281     try {
56282       delete arg1;
56283     } CALL_CATCH_EXCEPTION();
56284   }
56285
56286 }
56287
56288
56289 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
56290   bool jresult ;
56291   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
56292   bool result;
56293
56294   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
56295   {
56296     try {
56297       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
56298     } CALL_CATCH_EXCEPTION(0);
56299   }
56300
56301   jresult = result;
56302   return jresult;
56303 }
56304
56305
56306 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
56307   unsigned long jresult ;
56308   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
56309   std::size_t result;
56310
56311   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
56312   {
56313     try {
56314       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
56315     } CALL_CATCH_EXCEPTION(0);
56316   }
56317
56318   jresult = (unsigned long)result;
56319   return jresult;
56320 }
56321
56322
56323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
56324   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
56325   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
56326
56327   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
56328   arg2 = (void (*)(Dali::Actor,bool))jarg2;
56329   {
56330     try {
56331       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
56332     } CALL_CATCH_EXCEPTION();
56333   }
56334
56335 }
56336
56337
56338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
56339   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
56340   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
56341
56342   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
56343   arg2 = (void (*)(Dali::Actor,bool))jarg2;
56344   {
56345     try {
56346       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
56347     } CALL_CATCH_EXCEPTION();
56348   }
56349
56350 }
56351
56352
56353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, bool jarg3) {
56354   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
56355   Dali::Actor arg2 ;
56356   bool arg3 ;
56357   Dali::Actor *argp2 ;
56358
56359   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
56360   argp2 = (Dali::Actor *)jarg2;
56361   if (!argp2) {
56362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56363     return ;
56364   }
56365   arg2 = *argp2;
56366   arg3 = jarg3 ? true : false;
56367   {
56368     try {
56369       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
56370     } CALL_CATCH_EXCEPTION();
56371   }
56372
56373 }
56374
56375
56376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
56377   void * jresult ;
56378   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
56379
56380   {
56381     try {
56382       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
56383     } CALL_CATCH_EXCEPTION(0);
56384   }
56385
56386   jresult = (void *)result;
56387   return jresult;
56388 }
56389
56390
56391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
56392   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
56393
56394   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
56395   {
56396     try {
56397       delete arg1;
56398     } CALL_CATCH_EXCEPTION();
56399   }
56400
56401 }
56402
56403
56404 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
56405   bool jresult ;
56406   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
56407   bool result;
56408
56409   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
56410   {
56411     try {
56412       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);
56413     } CALL_CATCH_EXCEPTION(0);
56414   }
56415
56416   jresult = result;
56417   return jresult;
56418 }
56419
56420
56421 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
56422   unsigned long jresult ;
56423   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
56424   std::size_t result;
56425
56426   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
56427   {
56428     try {
56429       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);
56430     } CALL_CATCH_EXCEPTION(0);
56431   }
56432
56433   jresult = (unsigned long)result;
56434   return jresult;
56435 }
56436
56437
56438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
56439   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
56440   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
56441
56442   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
56443   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
56444   {
56445     try {
56446       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
56447     } CALL_CATCH_EXCEPTION();
56448   }
56449
56450 }
56451
56452
56453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
56454   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
56455   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
56456
56457   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
56458   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
56459   {
56460     try {
56461       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
56462     } CALL_CATCH_EXCEPTION();
56463   }
56464
56465 }
56466
56467
56468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
56469   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
56470   Dali::Toolkit::StyleManager arg2 ;
56471   Dali::StyleChange::Type arg3 ;
56472   Dali::Toolkit::StyleManager *argp2 ;
56473
56474   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
56475   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
56476   if (!argp2) {
56477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
56478     return ;
56479   }
56480   arg2 = *argp2;
56481   arg3 = (Dali::StyleChange::Type)jarg3;
56482   {
56483     try {
56484       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
56485     } CALL_CATCH_EXCEPTION();
56486   }
56487
56488 }
56489
56490
56491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
56492   void * jresult ;
56493   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
56494
56495   {
56496     try {
56497       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
56498     } CALL_CATCH_EXCEPTION(0);
56499   }
56500
56501   jresult = (void *)result;
56502   return jresult;
56503 }
56504
56505
56506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
56507   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
56508
56509   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
56510   {
56511     try {
56512       delete arg1;
56513     } CALL_CATCH_EXCEPTION();
56514   }
56515
56516 }
56517
56518
56519 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
56520   bool jresult ;
56521   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
56522   bool result;
56523
56524   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
56525   {
56526     try {
56527       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
56528     } CALL_CATCH_EXCEPTION(0);
56529   }
56530
56531   jresult = result;
56532   return jresult;
56533 }
56534
56535
56536 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
56537   unsigned long jresult ;
56538   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
56539   std::size_t result;
56540
56541   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
56542   {
56543     try {
56544       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
56545     } CALL_CATCH_EXCEPTION(0);
56546   }
56547
56548   jresult = (unsigned long)result;
56549   return jresult;
56550 }
56551
56552
56553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
56554   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
56555   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
56556
56557   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
56558   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
56559   {
56560     try {
56561       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
56562     } CALL_CATCH_EXCEPTION();
56563   }
56564
56565 }
56566
56567
56568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
56569   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
56570   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
56571
56572   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
56573   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
56574   {
56575     try {
56576       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
56577     } CALL_CATCH_EXCEPTION();
56578   }
56579
56580 }
56581
56582
56583 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
56584   bool jresult ;
56585   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
56586   Dali::Toolkit::Button arg2 ;
56587   Dali::Toolkit::Button *argp2 ;
56588   bool result;
56589
56590   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
56591   argp2 = (Dali::Toolkit::Button *)jarg2;
56592   if (!argp2) {
56593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
56594     return 0;
56595   }
56596   arg2 = *argp2;
56597   {
56598     try {
56599       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
56600     } CALL_CATCH_EXCEPTION(0);
56601   }
56602
56603   jresult = result;
56604   return jresult;
56605 }
56606
56607
56608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
56609   void * jresult ;
56610   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
56611
56612   {
56613     try {
56614       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
56615     } CALL_CATCH_EXCEPTION(0);
56616   }
56617
56618   jresult = (void *)result;
56619   return jresult;
56620 }
56621
56622
56623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
56624   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
56625
56626   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
56627   {
56628     try {
56629       delete arg1;
56630     } CALL_CATCH_EXCEPTION();
56631   }
56632
56633 }
56634
56635
56636 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
56637   bool jresult ;
56638   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
56639   bool result;
56640
56641   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
56642   {
56643     try {
56644       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
56645     } CALL_CATCH_EXCEPTION(0);
56646   }
56647
56648   jresult = result;
56649   return jresult;
56650 }
56651
56652
56653 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
56654   unsigned long jresult ;
56655   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
56656   std::size_t result;
56657
56658   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
56659   {
56660     try {
56661       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
56662     } CALL_CATCH_EXCEPTION(0);
56663   }
56664
56665   jresult = (unsigned long)result;
56666   return jresult;
56667 }
56668
56669
56670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
56671   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
56672   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
56673
56674   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
56675   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
56676   {
56677     try {
56678       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
56679     } CALL_CATCH_EXCEPTION();
56680   }
56681
56682 }
56683
56684
56685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
56686   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
56687   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
56688
56689   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
56690   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
56691   {
56692     try {
56693       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
56694     } CALL_CATCH_EXCEPTION();
56695   }
56696
56697 }
56698
56699
56700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
56701   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
56702   Dali::Toolkit::GaussianBlurView arg2 ;
56703   Dali::Toolkit::GaussianBlurView *argp2 ;
56704
56705   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
56706   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
56707   if (!argp2) {
56708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
56709     return ;
56710   }
56711   arg2 = *argp2;
56712   {
56713     try {
56714       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
56715     } CALL_CATCH_EXCEPTION();
56716   }
56717
56718 }
56719
56720
56721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
56722   void * jresult ;
56723   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
56724
56725   {
56726     try {
56727       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
56728     } CALL_CATCH_EXCEPTION(0);
56729   }
56730
56731   jresult = (void *)result;
56732   return jresult;
56733 }
56734
56735
56736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
56737   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
56738
56739   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
56740   {
56741     try {
56742       delete arg1;
56743     } CALL_CATCH_EXCEPTION();
56744   }
56745
56746 }
56747
56748
56749 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
56750   bool jresult ;
56751   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
56752   bool result;
56753
56754   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
56755   {
56756     try {
56757       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);
56758     } CALL_CATCH_EXCEPTION(0);
56759   }
56760
56761   jresult = result;
56762   return jresult;
56763 }
56764
56765
56766 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
56767   unsigned long jresult ;
56768   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
56769   std::size_t result;
56770
56771   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
56772   {
56773     try {
56774       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);
56775     } CALL_CATCH_EXCEPTION(0);
56776   }
56777
56778   jresult = (unsigned long)result;
56779   return jresult;
56780 }
56781
56782
56783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
56784   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
56785   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
56786
56787   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
56788   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
56789   {
56790     try {
56791       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
56792     } CALL_CATCH_EXCEPTION();
56793   }
56794
56795 }
56796
56797
56798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
56799   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
56800   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
56801
56802   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
56803   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
56804   {
56805     try {
56806       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
56807     } CALL_CATCH_EXCEPTION();
56808   }
56809
56810 }
56811
56812
56813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, bool jarg4) {
56814   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
56815   Dali::Toolkit::PageTurnView arg2 ;
56816   unsigned int arg3 ;
56817   bool arg4 ;
56818   Dali::Toolkit::PageTurnView *argp2 ;
56819
56820   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
56821   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
56822   if (!argp2) {
56823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
56824     return ;
56825   }
56826   arg2 = *argp2;
56827   arg3 = (unsigned int)jarg3;
56828   arg4 = jarg4 ? true : false;
56829   {
56830     try {
56831       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
56832     } CALL_CATCH_EXCEPTION();
56833   }
56834
56835 }
56836
56837
56838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
56839   void * jresult ;
56840   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
56841
56842   {
56843     try {
56844       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
56845     } CALL_CATCH_EXCEPTION(0);
56846   }
56847
56848   jresult = (void *)result;
56849   return jresult;
56850 }
56851
56852
56853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
56854   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
56855
56856   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
56857   {
56858     try {
56859       delete arg1;
56860     } CALL_CATCH_EXCEPTION();
56861   }
56862
56863 }
56864
56865
56866 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
56867   bool jresult ;
56868   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
56869   bool result;
56870
56871   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
56872   {
56873     try {
56874       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
56875     } CALL_CATCH_EXCEPTION(0);
56876   }
56877
56878   jresult = result;
56879   return jresult;
56880 }
56881
56882
56883 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
56884   unsigned long jresult ;
56885   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
56886   std::size_t result;
56887
56888   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
56889   {
56890     try {
56891       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
56892     } CALL_CATCH_EXCEPTION(0);
56893   }
56894
56895   jresult = (unsigned long)result;
56896   return jresult;
56897 }
56898
56899
56900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
56901   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
56902   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
56903
56904   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
56905   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
56906   {
56907     try {
56908       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
56909     } CALL_CATCH_EXCEPTION();
56910   }
56911 }
56912
56913
56914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
56915   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
56916   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
56917
56918   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
56919   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
56920   {
56921     try {
56922       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
56923     } CALL_CATCH_EXCEPTION();
56924   }
56925 }
56926
56927
56928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
56929   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
56930   Dali::Toolkit::PageTurnView arg2 ;
56931   Dali::Toolkit::PageTurnView *argp2 ;
56932
56933   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
56934   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
56935   if (!argp2) {
56936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
56937     return ;
56938   }
56939   arg2 = *argp2;
56940   {
56941     try {
56942       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
56943     } CALL_CATCH_EXCEPTION();
56944   }
56945 }
56946
56947
56948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
56949   void * jresult ;
56950   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
56951
56952   {
56953     try {
56954       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
56955     } CALL_CATCH_EXCEPTION(0);
56956   }
56957
56958   jresult = (void *)result;
56959   return jresult;
56960 }
56961
56962
56963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
56964   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
56965
56966   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
56967   {
56968     try {
56969       delete arg1;
56970     } CALL_CATCH_EXCEPTION();
56971   }
56972
56973 }
56974
56975
56976 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
56977   bool jresult ;
56978   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
56979   bool result;
56980
56981   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
56982   {
56983     try {
56984       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);
56985     } CALL_CATCH_EXCEPTION(0);
56986   }
56987
56988   jresult = result;
56989   return jresult;
56990 }
56991
56992
56993 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
56994   unsigned long jresult ;
56995   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
56996   std::size_t result;
56997
56998   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
56999   {
57000     try {
57001       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);
57002     } CALL_CATCH_EXCEPTION(0);
57003   }
57004
57005   jresult = (unsigned long)result;
57006   return jresult;
57007 }
57008
57009
57010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
57011   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
57012   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
57013
57014   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
57015   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
57016   {
57017     try {
57018       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
57019     } CALL_CATCH_EXCEPTION();
57020   }
57021
57022 }
57023
57024
57025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
57026   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
57027   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
57028
57029   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
57030   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
57031   {
57032     try {
57033       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
57034     } CALL_CATCH_EXCEPTION();
57035   }
57036
57037 }
57038
57039
57040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
57041   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
57042   Dali::Toolkit::ProgressBar arg2 ;
57043   float arg3 ;
57044   float arg4 ;
57045   Dali::Toolkit::ProgressBar *argp2 ;
57046
57047   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
57048   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
57049   if (!argp2) {
57050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
57051     return ;
57052   }
57053   arg2 = *argp2;
57054   arg3 = (float)jarg3;
57055   arg4 = (float)jarg4;
57056   {
57057     try {
57058       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
57059     } CALL_CATCH_EXCEPTION();
57060   }
57061
57062 }
57063
57064
57065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
57066   void * jresult ;
57067   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
57068
57069   {
57070     try {
57071       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
57072     } CALL_CATCH_EXCEPTION(0);
57073   }
57074
57075   jresult = (void *)result;
57076   return jresult;
57077 }
57078
57079
57080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
57081   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
57082
57083   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
57084   {
57085     try {
57086       delete arg1;
57087     } CALL_CATCH_EXCEPTION();
57088   }
57089
57090 }
57091
57092
57093 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
57094   bool jresult ;
57095   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
57096   bool result;
57097
57098   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
57099   {
57100     try {
57101       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);
57102     } CALL_CATCH_EXCEPTION(0);
57103   }
57104
57105   jresult = result;
57106   return jresult;
57107 }
57108
57109
57110 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
57111   unsigned long jresult ;
57112   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
57113   std::size_t result;
57114
57115   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
57116   {
57117     try {
57118       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);
57119     } CALL_CATCH_EXCEPTION(0);
57120   }
57121
57122   jresult = (unsigned long)result;
57123   return jresult;
57124 }
57125
57126
57127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
57128   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
57129   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
57130
57131   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
57132   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
57133   {
57134     try {
57135       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57136     } CALL_CATCH_EXCEPTION();
57137   }
57138
57139 }
57140
57141
57142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
57143   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
57144   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
57145
57146   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
57147   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
57148   {
57149     try {
57150       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57151     } CALL_CATCH_EXCEPTION();
57152   }
57153
57154 }
57155
57156
57157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
57158   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
57159   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
57160
57161   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
57162   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
57163   if (!arg2) {
57164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
57165     return ;
57166   }
57167   {
57168     try {
57169       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
57170     } CALL_CATCH_EXCEPTION();
57171   }
57172
57173 }
57174
57175
57176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
57177   void * jresult ;
57178   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
57179
57180   {
57181     try {
57182       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
57183     } CALL_CATCH_EXCEPTION(0);
57184   }
57185
57186   jresult = (void *)result;
57187   return jresult;
57188 }
57189
57190
57191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
57192   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
57193
57194   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
57195   {
57196     try {
57197       delete arg1;
57198     } CALL_CATCH_EXCEPTION();
57199   }
57200
57201 }
57202
57203
57204 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
57205   bool jresult ;
57206   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
57207   bool result;
57208
57209   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
57210   {
57211     try {
57212       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
57213     } CALL_CATCH_EXCEPTION(0);
57214   }
57215
57216   jresult = result;
57217   return jresult;
57218 }
57219
57220
57221 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
57222   unsigned long jresult ;
57223   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
57224   std::size_t result;
57225
57226   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
57227   {
57228     try {
57229       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
57230     } CALL_CATCH_EXCEPTION(0);
57231   }
57232
57233   jresult = (unsigned long)result;
57234   return jresult;
57235 }
57236
57237
57238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
57239   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
57240   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
57241
57242   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
57243   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
57244   {
57245     try {
57246       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57247     } CALL_CATCH_EXCEPTION();
57248   }
57249
57250 }
57251
57252
57253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
57254   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
57255   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
57256
57257   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
57258   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
57259   {
57260     try {
57261       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57262     } CALL_CATCH_EXCEPTION();
57263   }
57264
57265 }
57266
57267
57268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
57269   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
57270   Dali::Vector2 *arg2 = 0 ;
57271
57272   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
57273   arg2 = (Dali::Vector2 *)jarg2;
57274   if (!arg2) {
57275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
57276     return ;
57277   }
57278   {
57279     try {
57280       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
57281     } CALL_CATCH_EXCEPTION();
57282   }
57283
57284 }
57285
57286
57287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
57288   void * jresult ;
57289   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
57290
57291   {
57292     try {
57293       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
57294     } CALL_CATCH_EXCEPTION(0);
57295   }
57296
57297   jresult = (void *)result;
57298   return jresult;
57299 }
57300
57301
57302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
57303   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
57304
57305   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
57306   {
57307     try {
57308       delete arg1;
57309     } CALL_CATCH_EXCEPTION();
57310   }
57311
57312 }
57313
57314
57315
57316 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
57317   bool jresult ;
57318   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
57319   bool result;
57320
57321   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
57322   {
57323     try {
57324       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);
57325     } CALL_CATCH_EXCEPTION(0);
57326   }
57327
57328   jresult = result;
57329   return jresult;
57330 }
57331
57332
57333 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
57334   unsigned long jresult ;
57335   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
57336   std::size_t result;
57337
57338   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
57339   {
57340     try {
57341       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);
57342     } CALL_CATCH_EXCEPTION(0);
57343   }
57344
57345   jresult = (unsigned long)result;
57346   return jresult;
57347 }
57348
57349
57350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
57351   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
57352   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
57353
57354   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
57355   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
57356   {
57357     try {
57358       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57359     } CALL_CATCH_EXCEPTION();
57360   }
57361
57362 }
57363
57364
57365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
57366   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
57367   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
57368
57369   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
57370   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
57371   {
57372     try {
57373       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57374     } CALL_CATCH_EXCEPTION();
57375   }
57376
57377 }
57378
57379
57380 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57381   bool jresult ;
57382   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
57383   Dali::Toolkit::Control arg2 ;
57384   Dali::KeyEvent *arg3 = 0 ;
57385   Dali::Toolkit::Control *argp2 ;
57386   bool result;
57387
57388   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
57389   argp2 = (Dali::Toolkit::Control *)jarg2;
57390   if (!argp2) {
57391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
57392     return 0;
57393   }
57394   arg2 = *argp2;
57395   arg3 = (Dali::KeyEvent *)jarg3;
57396   if (!arg3) {
57397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
57398     return 0;
57399   }
57400   {
57401     try {
57402       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);
57403     } CALL_CATCH_EXCEPTION(0);
57404   }
57405
57406   jresult = result;
57407   return jresult;
57408 }
57409
57410
57411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
57412   void * jresult ;
57413   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
57414
57415   {
57416     try {
57417       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
57418     } CALL_CATCH_EXCEPTION(0);
57419   }
57420
57421   jresult = (void *)result;
57422   return jresult;
57423 }
57424
57425
57426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
57427   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
57428
57429   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
57430   {
57431     try {
57432       delete arg1;
57433     } CALL_CATCH_EXCEPTION();
57434   }
57435
57436 }
57437
57438
57439 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
57440   bool jresult ;
57441   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
57442   bool result;
57443
57444   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
57445   {
57446     try {
57447       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
57448     } CALL_CATCH_EXCEPTION(0);
57449   }
57450
57451   jresult = result;
57452   return jresult;
57453 }
57454
57455
57456 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
57457   unsigned long jresult ;
57458   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
57459   std::size_t result;
57460
57461   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
57462   {
57463     try {
57464       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
57465     } CALL_CATCH_EXCEPTION(0);
57466   }
57467
57468   jresult = (unsigned long)result;
57469   return jresult;
57470 }
57471
57472
57473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
57474   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
57475   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
57476
57477   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
57478   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
57479   {
57480     try {
57481       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
57482     } CALL_CATCH_EXCEPTION();
57483   }
57484
57485 }
57486
57487
57488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
57489   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
57490   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
57491
57492   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
57493   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
57494   {
57495     try {
57496       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
57497     } CALL_CATCH_EXCEPTION();
57498   }
57499
57500 }
57501
57502
57503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
57504   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
57505   Dali::Toolkit::Control arg2 ;
57506   Dali::Toolkit::Control *argp2 ;
57507
57508   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
57509   argp2 = (Dali::Toolkit::Control *)jarg2;
57510   if (!argp2) {
57511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
57512     return ;
57513   }
57514   arg2 = *argp2;
57515   {
57516     try {
57517       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
57518     } CALL_CATCH_EXCEPTION();
57519   }
57520
57521 }
57522
57523
57524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
57525   void * jresult ;
57526   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
57527
57528   {
57529     try {
57530       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
57531     } CALL_CATCH_EXCEPTION(0);
57532   }
57533
57534   jresult = (void *)result;
57535   return jresult;
57536 }
57537
57538
57539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
57540   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
57541
57542   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
57543   {
57544     try {
57545       delete arg1;
57546     } CALL_CATCH_EXCEPTION();
57547   }
57548
57549 }
57550
57551
57552 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
57553   bool jresult ;
57554   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
57555   bool result;
57556
57557   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
57558   {
57559     try {
57560       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
57561     } CALL_CATCH_EXCEPTION(0);
57562   }
57563
57564   jresult = result;
57565   return jresult;
57566 }
57567
57568
57569 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
57570   unsigned long jresult ;
57571   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
57572   std::size_t result;
57573
57574   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
57575   {
57576     try {
57577       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
57578     } CALL_CATCH_EXCEPTION(0);
57579   }
57580
57581   jresult = (unsigned long)result;
57582   return jresult;
57583 }
57584
57585
57586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
57587   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
57588   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
57589
57590   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
57591   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
57592   {
57593     try {
57594       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
57595     } CALL_CATCH_EXCEPTION();
57596   }
57597
57598 }
57599
57600
57601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
57602   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
57603   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
57604
57605   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
57606   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
57607   {
57608     try {
57609       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
57610     } CALL_CATCH_EXCEPTION();
57611   }
57612
57613 }
57614
57615
57616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
57617   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
57618   Dali::Toolkit::VideoView *arg2 = 0 ;
57619
57620   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
57621   arg2 = (Dali::Toolkit::VideoView *)jarg2;
57622   if (!arg2) {
57623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
57624     return ;
57625   }
57626   {
57627     try {
57628       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
57629     } CALL_CATCH_EXCEPTION();
57630   }
57631
57632 }
57633
57634
57635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
57636   void * jresult ;
57637   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
57638
57639   {
57640     try {
57641       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
57642     } CALL_CATCH_EXCEPTION(0);
57643   }
57644
57645   jresult = (void *)result;
57646   return jresult;
57647 }
57648
57649
57650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
57651   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
57652
57653   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
57654   {
57655     try {
57656       delete arg1;
57657     } CALL_CATCH_EXCEPTION();
57658   }
57659
57660 }
57661
57662
57663 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
57664   bool jresult ;
57665   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
57666   bool result;
57667
57668   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
57669   {
57670     try {
57671       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
57672     } CALL_CATCH_EXCEPTION(0);
57673   }
57674
57675   jresult = result;
57676   return jresult;
57677 }
57678
57679
57680 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
57681   unsigned long jresult ;
57682   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
57683   std::size_t result;
57684
57685   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
57686   {
57687     try {
57688       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
57689     } CALL_CATCH_EXCEPTION(0);
57690   }
57691
57692   jresult = (unsigned long)result;
57693   return jresult;
57694 }
57695
57696
57697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
57698   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
57699   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
57700
57701   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
57702   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
57703   {
57704     try {
57705       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
57706     } CALL_CATCH_EXCEPTION();
57707   }
57708
57709 }
57710
57711
57712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
57713   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
57714   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
57715
57716   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
57717   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
57718   {
57719     try {
57720       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
57721     } CALL_CATCH_EXCEPTION();
57722   }
57723
57724 }
57725
57726
57727 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
57728   bool jresult ;
57729   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
57730   Dali::Toolkit::Slider arg2 ;
57731   float arg3 ;
57732   Dali::Toolkit::Slider *argp2 ;
57733   bool result;
57734
57735   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
57736   argp2 = (Dali::Toolkit::Slider *)jarg2;
57737   if (!argp2) {
57738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
57739     return 0;
57740   }
57741   arg2 = *argp2;
57742   arg3 = (float)jarg3;
57743   {
57744     try {
57745       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
57746     } CALL_CATCH_EXCEPTION(0);
57747   }
57748
57749   jresult = result;
57750   return jresult;
57751 }
57752
57753
57754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
57755   void * jresult ;
57756   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
57757
57758   {
57759     try {
57760       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
57761     } CALL_CATCH_EXCEPTION(0);
57762   }
57763
57764   jresult = (void *)result;
57765   return jresult;
57766 }
57767
57768
57769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
57770   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
57771
57772   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
57773   {
57774     try {
57775       delete arg1;
57776     } CALL_CATCH_EXCEPTION();
57777   }
57778
57779 }
57780
57781
57782 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
57783   bool jresult ;
57784   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
57785   bool result;
57786
57787   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
57788   {
57789     try {
57790       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
57791     } CALL_CATCH_EXCEPTION(0);
57792   }
57793
57794   jresult = result;
57795   return jresult;
57796 }
57797
57798
57799 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
57800   unsigned long jresult ;
57801   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
57802   std::size_t result;
57803
57804   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
57805   {
57806     try {
57807       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
57808     } CALL_CATCH_EXCEPTION(0);
57809   }
57810
57811   jresult = (unsigned long)result;
57812   return jresult;
57813 }
57814
57815
57816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
57817   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
57818   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
57819
57820   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
57821   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
57822   {
57823     try {
57824       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
57825     } CALL_CATCH_EXCEPTION();
57826   }
57827
57828 }
57829
57830
57831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
57832   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
57833   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
57834
57835   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
57836   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
57837   {
57838     try {
57839       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
57840     } CALL_CATCH_EXCEPTION();
57841   }
57842
57843 }
57844
57845
57846 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
57847   bool jresult ;
57848   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
57849   Dali::Toolkit::Slider arg2 ;
57850   int arg3 ;
57851   Dali::Toolkit::Slider *argp2 ;
57852   bool result;
57853
57854   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
57855   argp2 = (Dali::Toolkit::Slider *)jarg2;
57856   if (!argp2) {
57857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
57858     return 0;
57859   }
57860   arg2 = *argp2;
57861   arg3 = (int)jarg3;
57862   {
57863     try {
57864       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
57865     } CALL_CATCH_EXCEPTION(0);
57866   }
57867
57868   jresult = result;
57869   return jresult;
57870 }
57871
57872
57873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
57874   void * jresult ;
57875   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
57876
57877   {
57878     try {
57879       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
57880     } CALL_CATCH_EXCEPTION(0);
57881   }
57882
57883   jresult = (void *)result;
57884   return jresult;
57885 }
57886
57887
57888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
57889   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
57890
57891   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
57892   {
57893     try {
57894       delete arg1;
57895     } CALL_CATCH_EXCEPTION();
57896   }
57897
57898 }
57899
57900
57901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
57902   void * jresult ;
57903   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
57904
57905   {
57906     try {
57907       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
57908     } CALL_CATCH_EXCEPTION(0);
57909   }
57910
57911   jresult = (void *)result;
57912   return jresult;
57913 }
57914
57915
57916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
57917   void * jresult ;
57918   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
57919   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
57920
57921   arg1 = (Dali::Toolkit::Ruler *)jarg1;
57922   {
57923     try {
57924       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
57925     } CALL_CATCH_EXCEPTION(0);
57926   }
57927
57928   jresult = (void *)result;
57929   return jresult;
57930 }
57931
57932
57933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
57934   void * jresult ;
57935   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
57936   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
57937
57938   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57939   if (!arg1) {
57940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
57941     return 0;
57942   }
57943   {
57944     try {
57945       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
57946     } CALL_CATCH_EXCEPTION(0);
57947   }
57948
57949   jresult = (void *)result;
57950   return jresult;
57951 }
57952
57953
57954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
57955   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57956
57957   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57958   {
57959     try {
57960       delete arg1;
57961     } CALL_CATCH_EXCEPTION();
57962   }
57963
57964 }
57965
57966
57967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
57968   void * jresult ;
57969   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57970   Dali::Toolkit::Ruler *result = 0 ;
57971
57972   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57973   {
57974     try {
57975       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
57976     } CALL_CATCH_EXCEPTION(0);
57977   }
57978
57979   jresult = (void *)result;
57980   return jresult;
57981 }
57982
57983
57984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
57985   void * jresult ;
57986   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57987   Dali::Toolkit::Ruler *result = 0 ;
57988
57989   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57990   {
57991     try {
57992       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
57993     } CALL_CATCH_EXCEPTION(0);
57994   }
57995
57996   jresult = (void *)result;
57997   return jresult;
57998 }
57999
58000
58001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
58002   void * jresult ;
58003   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58004   Dali::Toolkit::Ruler *result = 0 ;
58005
58006   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58007   {
58008     try {
58009       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
58010     } CALL_CATCH_EXCEPTION(0);
58011   }
58012
58013   jresult = (void *)result;
58014   return jresult;
58015 }
58016
58017
58018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
58019   void * jresult ;
58020   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58021   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
58022   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
58023
58024   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58025   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
58026   if (!arg2) {
58027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
58028     return 0;
58029   }
58030   {
58031     try {
58032       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
58033     } CALL_CATCH_EXCEPTION(0);
58034   }
58035
58036   jresult = (void *)result;
58037   return jresult;
58038 }
58039
58040
58041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
58042   void * jresult ;
58043   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58044   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
58045   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
58046
58047   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58048   arg2 = (Dali::Toolkit::Ruler *)jarg2;
58049   {
58050     try {
58051       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
58052     } CALL_CATCH_EXCEPTION(0);
58053   }
58054
58055   jresult = (void *)result;
58056   return jresult;
58057 }
58058
58059
58060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
58061   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58062
58063   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58064   {
58065     try {
58066       (arg1)->Reset();
58067     } CALL_CATCH_EXCEPTION();
58068   }
58069
58070 }
58071
58072
58073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
58074   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58075   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
58076
58077   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58078   arg2 = (Dali::Toolkit::Ruler *)jarg2;
58079   {
58080     try {
58081       (arg1)->Reset(arg2);
58082     } CALL_CATCH_EXCEPTION();
58083   }
58084
58085 }
58086
58087
58088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
58089   void * jresult ;
58090   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58091   Dali::Toolkit::Ruler *result = 0 ;
58092
58093   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58094   {
58095     try {
58096       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
58097     } CALL_CATCH_EXCEPTION(0);
58098   }
58099
58100   jresult = (void *)result;
58101   return jresult;
58102 }
58103
58104
58105 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
58106   float jresult ;
58107   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58108   float arg2 ;
58109   float arg3 ;
58110   float result;
58111
58112   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58113   arg2 = (float)jarg2;
58114   arg3 = (float)jarg3;
58115   {
58116     try {
58117       result = (float)(*arg1)->Snap(arg2,arg3);
58118     } CALL_CATCH_EXCEPTION(0);
58119   }
58120
58121   jresult = result;
58122   return jresult;
58123 }
58124
58125
58126 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
58127   float jresult ;
58128   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58129   float arg2 ;
58130   float result;
58131
58132   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58133   arg2 = (float)jarg2;
58134   {
58135     try {
58136       result = (float)(*arg1)->Snap(arg2);
58137     } CALL_CATCH_EXCEPTION(0);
58138   }
58139
58140   jresult = result;
58141   return jresult;
58142 }
58143
58144
58145 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) {
58146   float jresult ;
58147   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58148   unsigned int arg2 ;
58149   unsigned int *arg3 = 0 ;
58150   bool arg4 ;
58151   float result;
58152
58153   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58154   arg2 = (unsigned int)jarg2;
58155   arg3 = (unsigned int *)jarg3;
58156   arg4 = jarg4 ? true : false;
58157   {
58158     try {
58159       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
58160     } CALL_CATCH_EXCEPTION(0);
58161   }
58162
58163   jresult = result;
58164   return jresult;
58165 }
58166
58167
58168 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) {
58169   unsigned int jresult ;
58170   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58171   float arg2 ;
58172   bool arg3 ;
58173   unsigned int result;
58174
58175   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58176   arg2 = (float)jarg2;
58177   arg3 = jarg3 ? true : false;
58178   {
58179     try {
58180       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
58181     } CALL_CATCH_EXCEPTION(0);
58182   }
58183
58184   jresult = result;
58185   return jresult;
58186 }
58187
58188
58189 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
58190   unsigned int jresult ;
58191   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58192   unsigned int result;
58193
58194   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58195   {
58196     try {
58197       result = (unsigned int)(*arg1)->GetTotalPages();
58198     } CALL_CATCH_EXCEPTION(0);
58199   }
58200
58201   jresult = result;
58202   return jresult;
58203 }
58204
58205
58206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
58207   int jresult ;
58208   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58209   Dali::Toolkit::Ruler::RulerType result;
58210
58211   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58212   {
58213     try {
58214       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
58215     } CALL_CATCH_EXCEPTION(0);
58216   }
58217
58218   jresult = (int)result;
58219   return jresult;
58220 }
58221
58222
58223 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
58224   bool jresult ;
58225   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58226   bool result;
58227
58228   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58229   {
58230     try {
58231       result = (bool)(*arg1)->IsEnabled();
58232     } CALL_CATCH_EXCEPTION(0);
58233   }
58234
58235   jresult = result;
58236   return jresult;
58237 }
58238
58239
58240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
58241   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58242
58243   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58244   {
58245     try {
58246       (*arg1)->Enable();
58247     } CALL_CATCH_EXCEPTION();
58248   }
58249
58250 }
58251
58252
58253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
58254   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58255
58256   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58257   {
58258     try {
58259       (*arg1)->Disable();
58260     } CALL_CATCH_EXCEPTION();
58261   }
58262
58263 }
58264
58265
58266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
58267   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58268   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
58269   Dali::Toolkit::RulerDomain *argp2 ;
58270
58271   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58272   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
58273   if (!argp2) {
58274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
58275     return ;
58276   }
58277   arg2 = *argp2;
58278   {
58279     try {
58280       (*arg1)->SetDomain(arg2);
58281     } CALL_CATCH_EXCEPTION();
58282   }
58283
58284 }
58285
58286
58287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
58288   void * jresult ;
58289   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58290   Dali::Toolkit::RulerDomain *result = 0 ;
58291
58292   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58293   {
58294     try {
58295       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
58296     } CALL_CATCH_EXCEPTION(0);
58297   }
58298
58299   jresult = (void *)result;
58300   return jresult;
58301 }
58302
58303
58304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
58305   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58306
58307   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58308   {
58309     try {
58310       (*arg1)->DisableDomain();
58311     } CALL_CATCH_EXCEPTION();
58312   }
58313
58314 }
58315
58316
58317 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
58318   float jresult ;
58319   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58320   float arg2 ;
58321   float arg3 ;
58322   float arg4 ;
58323   float result;
58324
58325   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58326   arg2 = (float)jarg2;
58327   arg3 = (float)jarg3;
58328   arg4 = (float)jarg4;
58329   {
58330     try {
58331       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
58332     } CALL_CATCH_EXCEPTION(0);
58333   }
58334
58335   jresult = result;
58336   return jresult;
58337 }
58338
58339
58340 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
58341   float jresult ;
58342   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58343   float arg2 ;
58344   float arg3 ;
58345   float result;
58346
58347   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58348   arg2 = (float)jarg2;
58349   arg3 = (float)jarg3;
58350   {
58351     try {
58352       result = (float)(*arg1)->Clamp(arg2,arg3);
58353     } CALL_CATCH_EXCEPTION(0);
58354   }
58355
58356   jresult = result;
58357   return jresult;
58358 }
58359
58360
58361 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
58362   float jresult ;
58363   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58364   float arg2 ;
58365   float result;
58366
58367   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58368   arg2 = (float)jarg2;
58369   {
58370     try {
58371       result = (float)(*arg1)->Clamp(arg2);
58372     } CALL_CATCH_EXCEPTION(0);
58373   }
58374
58375   jresult = result;
58376   return jresult;
58377 }
58378
58379
58380 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
58381   float jresult ;
58382   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58383   float arg2 ;
58384   float arg3 ;
58385   float arg4 ;
58386   Dali::Toolkit::ClampState *arg5 = 0 ;
58387   float result;
58388
58389   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58390   arg2 = (float)jarg2;
58391   arg3 = (float)jarg3;
58392   arg4 = (float)jarg4;
58393   arg5 = (Dali::Toolkit::ClampState *)jarg5;
58394   if (!arg5) {
58395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
58396     return 0;
58397   }
58398   {
58399     try {
58400       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
58401     } CALL_CATCH_EXCEPTION(0);
58402   }
58403
58404   jresult = result;
58405   return jresult;
58406 }
58407
58408
58409 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
58410   float jresult ;
58411   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58412   float arg2 ;
58413   float arg3 ;
58414   float arg4 ;
58415   float arg5 ;
58416   float result;
58417
58418   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58419   arg2 = (float)jarg2;
58420   arg3 = (float)jarg3;
58421   arg4 = (float)jarg4;
58422   arg5 = (float)jarg5;
58423   {
58424     try {
58425       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
58426     } CALL_CATCH_EXCEPTION(0);
58427   }
58428
58429   jresult = result;
58430   return jresult;
58431 }
58432
58433
58434 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
58435   float jresult ;
58436   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58437   float arg2 ;
58438   float arg3 ;
58439   float arg4 ;
58440   float result;
58441
58442   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58443   arg2 = (float)jarg2;
58444   arg3 = (float)jarg3;
58445   arg4 = (float)jarg4;
58446   {
58447     try {
58448       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
58449     } CALL_CATCH_EXCEPTION(0);
58450   }
58451
58452   jresult = result;
58453   return jresult;
58454 }
58455
58456
58457 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
58458   float jresult ;
58459   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58460   float arg2 ;
58461   float arg3 ;
58462   float result;
58463
58464   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58465   arg2 = (float)jarg2;
58466   arg3 = (float)jarg3;
58467   {
58468     try {
58469       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
58470     } CALL_CATCH_EXCEPTION(0);
58471   }
58472
58473   jresult = result;
58474   return jresult;
58475 }
58476
58477
58478 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
58479   float jresult ;
58480   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58481   float arg2 ;
58482   float result;
58483
58484   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58485   arg2 = (float)jarg2;
58486   {
58487     try {
58488       result = (float)(*arg1)->SnapAndClamp(arg2);
58489     } CALL_CATCH_EXCEPTION(0);
58490   }
58491
58492   jresult = result;
58493   return jresult;
58494 }
58495
58496
58497 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
58498   float jresult ;
58499   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58500   float arg2 ;
58501   float arg3 ;
58502   float arg4 ;
58503   float arg5 ;
58504   Dali::Toolkit::ClampState *arg6 = 0 ;
58505   float result;
58506
58507   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58508   arg2 = (float)jarg2;
58509   arg3 = (float)jarg3;
58510   arg4 = (float)jarg4;
58511   arg5 = (float)jarg5;
58512   arg6 = (Dali::Toolkit::ClampState *)jarg6;
58513   if (!arg6) {
58514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
58515     return 0;
58516   }
58517   {
58518     try {
58519       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
58520     } CALL_CATCH_EXCEPTION(0);
58521   }
58522
58523   jresult = result;
58524   return jresult;
58525 }
58526
58527
58528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
58529   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58530
58531   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58532   {
58533     try {
58534       (*arg1)->Reference();
58535     } CALL_CATCH_EXCEPTION();
58536   }
58537
58538 }
58539
58540
58541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
58542   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58543
58544   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58545   {
58546     try {
58547       (*arg1)->Unreference();
58548     } CALL_CATCH_EXCEPTION();
58549   }
58550
58551 }
58552
58553
58554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
58555   int jresult ;
58556   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58557   int result;
58558
58559   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58560   {
58561     try {
58562       result = (int)(*arg1)->ReferenceCount();
58563     } CALL_CATCH_EXCEPTION(0);
58564   }
58565
58566   jresult = result;
58567   return jresult;
58568 }
58569
58570
58571 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
58572   bool jresult ;
58573   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
58574   bool result;
58575
58576   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
58577   {
58578     try {
58579       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
58580     } CALL_CATCH_EXCEPTION(0);
58581   }
58582
58583   jresult = result;
58584   return jresult;
58585 }
58586
58587
58588 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
58589   unsigned long jresult ;
58590   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
58591   std::size_t result;
58592
58593   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
58594   {
58595     try {
58596       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
58597     } CALL_CATCH_EXCEPTION(0);
58598   }
58599
58600   jresult = (unsigned long)result;
58601   return jresult;
58602 }
58603
58604
58605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
58606   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
58607   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
58608
58609   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
58610   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
58611   {
58612     try {
58613       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
58614     } CALL_CATCH_EXCEPTION();
58615   }
58616
58617 }
58618
58619
58620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
58621   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
58622   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
58623
58624   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
58625   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
58626   {
58627     try {
58628       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
58629     } CALL_CATCH_EXCEPTION();
58630   }
58631
58632 }
58633
58634
58635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
58636   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
58637   Dali::Toolkit::Control arg2 ;
58638   Dali::Toolkit::Control *argp2 ;
58639
58640   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
58641   argp2 = (Dali::Toolkit::Control *)jarg2;
58642   if (!argp2) {
58643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
58644     return ;
58645   }
58646   arg2 = *argp2;
58647   {
58648     try {
58649       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
58650     } CALL_CATCH_EXCEPTION();
58651   }
58652
58653 }
58654
58655
58656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
58657   void * jresult ;
58658   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
58659
58660   {
58661     try {
58662       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
58663     } CALL_CATCH_EXCEPTION(0);
58664   }
58665
58666   jresult = (void *)result;
58667   return jresult;
58668 }
58669
58670
58671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
58672   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
58673
58674   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
58675   {
58676     try {
58677       delete arg1;
58678     } CALL_CATCH_EXCEPTION();
58679   }
58680
58681 }
58682
58683 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
58684   Dali::RefObject *result = NULL;
58685
58686   if (arg1)
58687   {
58688     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
58689   }
58690   return result;
58691 }
58692
58693 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
58694     return (Dali::RefObject *)jarg1;
58695 }
58696
58697 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
58698     return (Dali::SignalObserver *)jarg1;
58699 }
58700
58701 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
58702     return (Dali::ConnectionTrackerInterface *)jarg1;
58703 }
58704
58705 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
58706     return (Dali::BaseHandle *)jarg1;
58707 }
58708
58709 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
58710     return (Dali::BaseHandle *)jarg1;
58711 }
58712
58713 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
58714     return (Dali::BaseHandle *)jarg1;
58715 }
58716
58717 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
58718     return (Dali::BaseHandle *)jarg1;
58719 }
58720
58721 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
58722     return (Dali::BaseHandle *)jarg1;
58723 }
58724
58725 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
58726     return (Dali::BaseHandle *)jarg1;
58727 }
58728
58729 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
58730     return (Dali::BaseHandle *)jarg1;
58731 }
58732
58733 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
58734     return (Dali::BaseHandle *)jarg1;
58735 }
58736
58737 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
58738     return (Dali::BaseHandle *)jarg1;
58739 }
58740
58741 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
58742     return (Dali::BaseHandle *)jarg1;
58743 }
58744
58745 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VertexBuffer_SWIGUpcast(Dali::VertexBuffer *jarg1) {
58746     return (Dali::BaseHandle *)jarg1;
58747 }
58748
58749 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
58750     return (Dali::BaseHandle *)jarg1;
58751 }
58752
58753 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
58754     return (Dali::Handle *)jarg1;
58755 }
58756
58757 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
58758     return (Dali::Handle *)jarg1;
58759 }
58760
58761 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
58762     return (Dali::BaseHandle *)jarg1;
58763 }
58764
58765 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
58766     return (Dali::BaseHandle *)jarg1;
58767 }
58768
58769 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
58770     return (Dali::Handle *)jarg1;
58771 }
58772
58773 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchEvent *jarg1) {
58774     return (Dali::BaseHandle *)jarg1;
58775 }
58776
58777 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Hover_SWIGUpcast(Dali::HoverEvent *jarg1) {
58778     return (Dali::BaseHandle *)jarg1;
58779 }
58780
58781 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Wheel_SWIGUpcast(Dali::WheelEvent *jarg1) {
58782     return (Dali::BaseHandle *)jarg1;
58783 }
58784
58785 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Key_SWIGUpcast(Dali::KeyEvent *jarg1) {
58786     return (Dali::BaseHandle *)jarg1;
58787 }
58788
58789 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Gesture_SWIGUpcast(Dali::Gesture *jarg1) {
58790     return (Dali::BaseHandle *)jarg1;
58791 }
58792
58793 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
58794     return (Dali::Handle *)jarg1;
58795 }
58796
58797 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
58798     return (Dali::GestureDetector *)jarg1;
58799 }
58800
58801 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
58802     return (Dali::Gesture *)jarg1;
58803 }
58804
58805 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
58806     return (Dali::Handle *)jarg1;
58807 }
58808
58809 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
58810     return (Dali::Actor *)jarg1;
58811 }
58812
58813 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
58814     return (Dali::RefObject *)jarg1;
58815 }
58816
58817 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
58818     return (Dali::Actor *)jarg1;
58819 }
58820
58821 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
58822     return (Dali::GestureDetector *)jarg1;
58823 }
58824
58825 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
58826     return (Dali::Gesture *)jarg1;
58827 }
58828
58829 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
58830     return (Dali::GestureDetector *)jarg1;
58831 }
58832
58833 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
58834     return (Dali::Gesture *)jarg1;
58835 }
58836
58837 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
58838     return (Dali::GestureDetector *)jarg1;
58839 }
58840
58841 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
58842     return (Dali::Gesture *)jarg1;
58843 }
58844
58845 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
58846     return (Dali::BaseHandle *)jarg1;
58847 }
58848
58849 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
58850     return (Dali::Handle *)jarg1;
58851 }
58852
58853 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
58854     return (Dali::Handle *)jarg1;
58855 }
58856
58857 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
58858     return (Dali::Handle *)jarg1;
58859 }
58860
58861 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
58862     return (Dali::RefObject *)jarg1;
58863 }
58864
58865 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
58866     return (Dali::Actor *)jarg1;
58867 }
58868
58869 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
58870     return (Dali::BaseHandle *)jarg1;
58871 }
58872
58873 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
58874     return (Dali::BaseHandle *)jarg1;
58875 }
58876
58877 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
58878     return (Dali::BaseHandle *)jarg1;
58879 }
58880
58881 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
58882     return (Dali::CustomActorImpl *)jarg1;
58883 }
58884
58885 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
58886     return (Dali::CustomActor *)jarg1;
58887 }
58888
58889 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
58890     return (Dali::BaseHandle *)jarg1;
58891 }
58892
58893 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
58894     return (Dali::Toolkit::Control *)jarg1;
58895 }
58896
58897 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
58898     return (Dali::Toolkit::Control *)jarg1;
58899 }
58900
58901 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
58902     return (Dali::Toolkit::Button *)jarg1;
58903 }
58904
58905 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
58906     return (Dali::Toolkit::Button *)jarg1;
58907 }
58908
58909 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
58910     return (Dali::Toolkit::Button *)jarg1;
58911 }
58912
58913 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
58914     return (Dali::Toolkit::Control *)jarg1;
58915 }
58916
58917 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
58918     return (Dali::Toolkit::Control *)jarg1;
58919 }
58920
58921 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
58922     return (Dali::Toolkit::Control *)jarg1;
58923 }
58924
58925 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
58926     return (Dali::Toolkit::Control *)jarg1;
58927 }
58928
58929 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
58930     return (Dali::Toolkit::Control *)jarg1;
58931 }
58932
58933 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
58934     return (Dali::RefObject *)jarg1;
58935 }
58936
58937 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
58938     return (Dali::Toolkit::Scrollable *)jarg1;
58939 }
58940
58941 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
58942     return (Dali::BaseHandle *)jarg1;
58943 }
58944
58945 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
58946     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
58947 }
58948
58949 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
58950     return (Dali::RefObject *)jarg1;
58951 }
58952
58953 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
58954     return (Dali::Toolkit::Ruler *)jarg1;
58955 }
58956
58957 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
58958     return (Dali::Toolkit::Ruler *)jarg1;
58959 }
58960
58961 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
58962     return (Dali::Toolkit::Scrollable *)jarg1;
58963 }
58964
58965 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
58966     return (Dali::Toolkit::Control *)jarg1;
58967 }
58968
58969
58970 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
58971     return (Dali::Toolkit::Control *)jarg1;
58972 }
58973
58974 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
58975     return (Dali::BaseHandle *)jarg1;
58976 }
58977
58978 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
58979     return (Dali::BaseHandle *)jarg1;
58980 }
58981
58982 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
58983     return (Dali::Toolkit::Control *)jarg1;
58984 }
58985
58986 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
58987     return (Dali::Toolkit::Control *)jarg1;
58988 }
58989
58990 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_CameraView_SWIGUpcast(Dali::Toolkit::CameraView *jarg1) {
58991     return (Dali::Toolkit::Control *)jarg1;
58992 }
58993
58994 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
58995     return (Dali::Toolkit::Control *)jarg1;
58996 }
58997
58998 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
58999     return (Dali::Toolkit::Control *)jarg1;
59000 }
59001
59002 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
59003     return (Dali::Toolkit::Control *)jarg1;
59004 }
59005
59006 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
59007     return (Dali::Toolkit::Control *)jarg1;
59008 }
59009
59010 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
59011     return (Dali::Toolkit::PageTurnView *)jarg1;
59012 }
59013
59014 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
59015     return (Dali::Toolkit::PageTurnView *)jarg1;
59016 }
59017
59018 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
59019     return (Dali::Toolkit::Button *)jarg1;
59020 }
59021
59022 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
59023     return (Dali::BaseHandle *)jarg1;
59024 }
59025
59026 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
59027     return (Dali::BaseHandle *)jarg1;
59028 }
59029
59030 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
59031     return (Dali::BaseHandle *)jarg1;
59032 }
59033
59034 /*
59035  * Widget binding
59036  */
59037 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
59038     return (Dali::BaseHandle *)jarg1;
59039 }
59040
59041 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
59042     return (Dali::BaseObject *)jarg1;
59043 }
59044
59045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
59046   void * jresult ;
59047   Dali::Widget result;
59048
59049   {
59050     try {
59051       result = Dali::Widget::New();
59052     } CALL_CATCH_EXCEPTION(0);
59053   }
59054
59055   jresult = new Dali::Widget((const Dali::Widget &)result);
59056   return jresult;
59057 }
59058
59059
59060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
59061   void * jresult ;
59062   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
59063   Dali::Widget result;
59064
59065   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59066
59067   if (!arg1) {
59068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
59069     return 0;
59070   }
59071   {
59072     try {
59073       jresult = new Dali::Widget(arg1);
59074     } CALL_CATCH_EXCEPTION(0);
59075   }
59076   return jresult;
59077 }
59078
59079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
59080   void * jresult ;
59081   Dali::Widget *result = 0 ;
59082
59083   {
59084     try {
59085       result = (Dali::Widget *)new Dali::Widget();
59086     } CALL_CATCH_EXCEPTION(0);
59087   }
59088   jresult = (void *)result;
59089   return jresult;
59090 }
59091
59092
59093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
59094   void * jresult ;
59095   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
59096   Dali::Widget *arg2 = 0 ;
59097   Dali::Widget *result = 0 ;
59098
59099   arg1 = (Dali::Widget *)jarg1;
59100   arg2 = (Dali::Widget *)jarg2;
59101   if (!arg2) {
59102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
59103     return 0;
59104   }
59105   {
59106     try {
59107       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
59108     } CALL_CATCH_EXCEPTION(0);
59109   }
59110   jresult = (void *)result;
59111   return jresult;
59112 }
59113
59114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
59115   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
59116
59117   arg1 = (Dali::Widget *)jarg1;
59118   {
59119     try {
59120       delete arg1;
59121     } CALL_CATCH_EXCEPTION();
59122   }
59123 }
59124
59125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
59126   void * jresult ;
59127   SwigDirector_WidgetImpl* result;
59128   {
59129     try {
59130       result = new SwigDirector_WidgetImpl();
59131     } CALL_CATCH_EXCEPTION(0);
59132   }
59133   jresult = result;
59134   return jresult;
59135 }
59136
59137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
59138   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59139   std::string *arg2 = 0 ;
59140   Dali::Window arg3 ;
59141   Dali::Window *argp3 ;
59142
59143   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59144   if (!jarg2) {
59145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59146     return ;
59147   }
59148   std::string arg2_str(jarg2);
59149   arg2 = &arg2_str;
59150   argp3 = (Dali::Window *)jarg3;
59151   if (!argp3) {
59152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
59153     return ;
59154   }
59155   arg3 = *argp3;
59156   {
59157     try {
59158       (arg1)->OnCreate((std::string const &)*arg2,arg3);
59159     } CALL_CATCH_EXCEPTION();
59160   }
59161 }
59162
59163
59164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
59165   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59166   std::string *arg2 = 0 ;
59167   Dali::Window arg3 ;
59168   Dali::Window *argp3 ;
59169
59170   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59171   if (!jarg2) {
59172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59173     return ;
59174   }
59175   std::string arg2_str(jarg2);
59176   arg2 = &arg2_str;
59177   argp3 = (Dali::Window *)jarg3;
59178   if (!argp3) {
59179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
59180     return ;
59181   }
59182   arg3 = *argp3;
59183   {
59184     try {
59185       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
59186     } CALL_CATCH_EXCEPTION();
59187   }
59188 }
59189
59190
59191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
59192   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59193   std::string *arg2 = 0 ;
59194   Dali::Widget::Termination arg3 ;
59195
59196   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59197   if (!jarg2) {
59198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59199     return ;
59200   }
59201   std::string arg2_str(jarg2);
59202   arg2 = &arg2_str;
59203   arg3 = (Dali::Widget::Termination)jarg3;
59204   {
59205     try {
59206       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
59207     } CALL_CATCH_EXCEPTION();
59208   }
59209 }
59210
59211
59212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
59213   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59214   std::string *arg2 = 0 ;
59215   Dali::Widget::Termination arg3 ;
59216
59217   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59218   if (!jarg2) {
59219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59220     return ;
59221   }
59222   std::string arg2_str(jarg2);
59223   arg2 = &arg2_str;
59224   arg3 = (Dali::Widget::Termination)jarg3;
59225   {
59226     try {
59227       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
59228     } CALL_CATCH_EXCEPTION();
59229   }
59230 }
59231
59232
59233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
59234   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59235
59236   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59237   {
59238     try {
59239       (arg1)->OnPause();
59240     } CALL_CATCH_EXCEPTION();
59241   }
59242 }
59243
59244
59245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
59246   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59247
59248   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59249   {
59250     try {
59251       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
59252     } CALL_CATCH_EXCEPTION();
59253   }
59254 }
59255
59256
59257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
59258   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59259
59260   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59261   {
59262     try {
59263       (arg1)->OnResume();
59264     } CALL_CATCH_EXCEPTION();
59265   }
59266 }
59267
59268
59269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
59270   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59271
59272   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59273   {
59274     try {
59275       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
59276     } CALL_CATCH_EXCEPTION();
59277   }
59278 }
59279
59280
59281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
59282   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59283   Dali::Window arg2 ;
59284   Dali::Window *argp2 ;
59285
59286   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59287   argp2 = (Dali::Window *)jarg2;
59288   if (!argp2) {
59289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
59290     return ;
59291   }
59292   arg2 = *argp2;
59293   {
59294     try {
59295       (arg1)->OnResize(arg2);
59296     } CALL_CATCH_EXCEPTION();
59297   }
59298 }
59299
59300
59301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
59302   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59303   Dali::Window arg2 ;
59304   Dali::Window *argp2 ;
59305
59306   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59307   argp2 = (Dali::Window *)jarg2;
59308   if (!argp2) {
59309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
59310     return ;
59311   }
59312   arg2 = *argp2;
59313   {
59314     try {
59315       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
59316     } CALL_CATCH_EXCEPTION();
59317   }
59318 }
59319
59320
59321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
59322   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59323   std::string *arg2 = 0 ;
59324   int arg3 ;
59325
59326   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59327   if (!jarg2) {
59328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59329     return ;
59330   }
59331   std::string arg2_str(jarg2);
59332   arg2 = &arg2_str;
59333   arg3 = (int)jarg3;
59334   {
59335     try {
59336       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
59337     } CALL_CATCH_EXCEPTION();
59338   }
59339 }
59340
59341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
59342   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59343   std::string *arg2 = 0 ;
59344   int arg3 ;
59345
59346   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59347   if (!jarg2) {
59348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59349     return ;
59350   }
59351   std::string arg2_str(jarg2);
59352   arg2 = &arg2_str;
59353   arg3 = (int)jarg3;
59354   {
59355     try {
59356       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
59357     } CALL_CATCH_EXCEPTION();
59358   }
59359 }
59360
59361
59362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
59363   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59364   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
59365   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
59366
59367   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59368   arg2 = (Dali::SlotObserver *)jarg2;
59369   arg3 = (Dali::CallbackBase *)jarg3;
59370   {
59371     try {
59372       (arg1)->SignalConnected(arg2,arg3);
59373     } CALL_CATCH_EXCEPTION();
59374   }
59375 }
59376
59377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
59378   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59379   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
59380   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
59381
59382   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59383   arg2 = (Dali::SlotObserver *)jarg2;
59384   arg3 = (Dali::CallbackBase *)jarg3;
59385   {
59386     try {
59387       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
59388     } CALL_CATCH_EXCEPTION();
59389   }
59390 }
59391
59392
59393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
59394   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59395   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
59396   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
59397
59398   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59399   arg2 = (Dali::SlotObserver *)jarg2;
59400   arg3 = (Dali::CallbackBase *)jarg3;
59401   {
59402     try {
59403       (arg1)->SignalDisconnected(arg2,arg3);
59404     } CALL_CATCH_EXCEPTION();
59405   }
59406 }
59407
59408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
59409   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59410   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
59411   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
59412
59413   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59414   arg2 = (Dali::SlotObserver *)jarg2;
59415   arg3 = (Dali::CallbackBase *)jarg3;
59416   {
59417     try {
59418       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
59419     } CALL_CATCH_EXCEPTION();
59420   }
59421 }
59422
59423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
59424   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59425   std::string *arg2 = 0 ;
59426
59427   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59428   if (!jarg2) {
59429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59430     return ;
59431   }
59432   std::string arg2_str(jarg2);
59433   arg2 = &arg2_str;
59434   {
59435     try {
59436       (arg1)->SetContentInfo((std::string const &)*arg2);
59437     } CALL_CATCH_EXCEPTION();
59438   }
59439 }
59440
59441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetUsingKeyEvent(void * jwidget, bool jflag) {
59442   Dali::Internal::Adaptor::Widget *widget = (Dali::Internal::Adaptor::Widget *) 0 ;
59443   bool flag;
59444
59445   widget = (Dali::Internal::Adaptor::Widget *)jwidget;
59446   flag = jflag ? true : false;
59447   {
59448     try {
59449       (widget)->SetUsingKeyEvent(flag);
59450     } CALL_CATCH_EXCEPTION();
59451   }
59452 }
59453
59454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
59455   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59456   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
59457
59458   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59459   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
59460   {
59461     try {
59462       (arg1)->SetImpl(arg2);
59463     } CALL_CATCH_EXCEPTION();
59464   }
59465 }
59466
59467
59468 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) {
59469   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
59470   if (director) {
59471     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
59472   }
59473 }
59474
59475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
59476   void * jresult ;
59477   Dali::Widget *arg1 = 0 ;
59478   SwigDirector_WidgetImpl *result = 0 ;
59479
59480   arg1 = (Dali::Widget *)jarg1;
59481   if (!arg1) {
59482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
59483     return 0;
59484   }
59485   {
59486     try {
59487       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
59488     } CALL_CATCH_EXCEPTION(0);
59489   }
59490   jresult = (void*) result;
59491   return jresult;
59492 }
59493
59494
59495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
59496   void * jresult ;
59497   int *arg1 = (int *) 0 ;
59498   char ***arg2 ;
59499   std::string *arg3 = 0 ;
59500   Dali::WidgetApplication result;
59501   {
59502     int index = 0;
59503     int length = 0;
59504     char *retPtr;
59505     char *nextPtr;
59506     argWidgetC = jarg1;
59507     argWidgetV = new char*[jarg1 + 1];
59508
59509     retPtr = strtok_r( jarg2, " ", &nextPtr);
59510     if( retPtr )
59511     {
59512       length = strlen(retPtr);
59513     }
59514     argWidgetV[index] = new char[length + 1];
59515     if( retPtr )
59516     {
59517       strncpy(argWidgetV[index], retPtr, length);
59518     }
59519     argWidgetV[index][length] = '\0';
59520     index++;
59521
59522     while (index < jarg1)
59523     {
59524       length = 0;
59525       retPtr = strtok_r(NULL, " ", &nextPtr);
59526       if( retPtr )
59527       {
59528         length = strlen(retPtr);
59529       }
59530       argWidgetV[index] = new char[length + 1];
59531       if( retPtr )
59532       {
59533         strncpy(argWidgetV[index], retPtr, length);
59534       }
59535       argWidgetV[index][length] = '\0';
59536       index++;
59537     }
59538
59539     argWidgetV[jarg1] = NULL;
59540     argWidgetC = jarg1;
59541
59542     arg1 = &argWidgetC;
59543     arg2 = &argWidgetV;
59544   }
59545
59546   if (!jarg3) {
59547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59548     return 0;
59549   }
59550   std::string arg3_str(jarg3);
59551   arg3 = &arg3_str;
59552   {
59553     try {
59554       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
59555     } CALL_CATCH_EXCEPTION(0);
59556   }
59557   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
59558   return jresult;
59559 }
59560
59561
59562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
59563   void * jresult ;
59564   Dali::WidgetApplication *result = 0 ;
59565
59566   {
59567     try {
59568       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
59569     } CALL_CATCH_EXCEPTION(0);
59570   }
59571   jresult = (void *)result;
59572   return jresult;
59573 }
59574
59575
59576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
59577   void * jresult ;
59578   Dali::WidgetApplication *arg1 = 0 ;
59579   Dali::WidgetApplication *result = 0 ;
59580
59581   arg1 = (Dali::WidgetApplication *)jarg1;
59582   if (!arg1) {
59583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
59584     return 0;
59585   }
59586   {
59587     try {
59588       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
59589     } CALL_CATCH_EXCEPTION(0);
59590   }
59591   jresult = (void *)result;
59592   return jresult;
59593 }
59594
59595
59596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
59597   void * jresult ;
59598   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
59599   Dali::WidgetApplication *arg2 = 0 ;
59600   Dali::WidgetApplication *result = 0 ;
59601
59602   arg1 = (Dali::WidgetApplication *)jarg1;
59603   arg2 = (Dali::WidgetApplication *)jarg2;
59604   if (!arg2) {
59605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
59606     return 0;
59607   }
59608   {
59609     try {
59610       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
59611     } CALL_CATCH_EXCEPTION(0);
59612   }
59613   jresult = (void *)result;
59614   return jresult;
59615 }
59616
59617
59618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
59619   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
59620
59621   arg1 = (Dali::WidgetApplication *)jarg1;
59622   {
59623     try {
59624       delete arg1;
59625       if( argWidgetV )
59626       {
59627         // free string data
59628         for( int i=0; i < argWidgetC+1; i++)
59629         {
59630           delete [] argWidgetV[i];
59631         }
59632         delete [] argWidgetV;
59633       }
59634     } CALL_CATCH_EXCEPTION();
59635   }
59636 }
59637
59638
59639 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
59640 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
59641
59642 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
59643 {
59644   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
59645   return *widget;
59646 }
59647
59648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
59649   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
59650   std::string *arg2 = 0 ;
59651
59652   arg1 = (Dali::WidgetApplication *)jarg1;
59653   if (!jarg2) {
59654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59655     return ;
59656   }
59657   std::string arg2_str(*jarg2);
59658   arg2 = &arg2_str;
59659
59660   if(!_CSharpCreateWidgetFunction)
59661   {
59662     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
59663   }
59664
59665   {
59666     try {
59667       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
59668     } CALL_CATCH_EXCEPTION();
59669   }
59670   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
59671 }
59672
59673
59674 //for PixelBuffer and ImageLoading
59675
59676 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
59677     return (Dali::BaseHandle *)jarg1;
59678 }
59679
59680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
59681   void * jresult ;
59682   unsigned int arg1 ;
59683   unsigned int arg2 ;
59684   Dali::Pixel::Format arg3 ;
59685   Dali::Devel::PixelBuffer result;
59686
59687   arg1 = (unsigned int)jarg1;
59688   arg2 = (unsigned int)jarg2;
59689   arg3 = (Dali::Pixel::Format)jarg3;
59690   {
59691     try {
59692       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
59693     } CALL_CATCH_EXCEPTION(0);
59694   }
59695   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59696   return jresult;
59697 }
59698
59699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
59700   void * jresult ;
59701   Dali::Devel::PixelBuffer *result = 0 ;
59702
59703   {
59704     try {
59705       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
59706     } CALL_CATCH_EXCEPTION(0);
59707   }
59708   jresult = (void *)result;
59709   return jresult;
59710 }
59711
59712
59713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
59714   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59715
59716   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59717   {
59718     try {
59719       delete arg1;
59720     } CALL_CATCH_EXCEPTION();
59721   }
59722 }
59723
59724
59725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
59726   void * jresult ;
59727   Dali::Devel::PixelBuffer *arg1 = 0 ;
59728   Dali::Devel::PixelBuffer *result = 0 ;
59729
59730   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59731   if (!arg1) {
59732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
59733     return 0;
59734   }
59735   {
59736     try {
59737       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
59738     } CALL_CATCH_EXCEPTION(0);
59739   }
59740   jresult = (void *)result;
59741   return jresult;
59742 }
59743
59744
59745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
59746   void * jresult ;
59747   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59748   Dali::Devel::PixelBuffer *arg2 = 0 ;
59749   Dali::Devel::PixelBuffer *result = 0 ;
59750
59751   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59752   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
59753   if (!arg2) {
59754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
59755     return 0;
59756   }
59757   {
59758     try {
59759       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
59760     } CALL_CATCH_EXCEPTION(0);
59761   }
59762   jresult = (void *)result;
59763   return jresult;
59764 }
59765
59766
59767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
59768   void * jresult ;
59769   Dali::Devel::PixelBuffer *arg1 = 0 ;
59770   Dali::PixelData result;
59771
59772   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59773   if (!arg1) {
59774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
59775     return 0;
59776   }
59777   {
59778     try {
59779       result = Dali::Devel::PixelBuffer::Convert(*arg1);
59780     } CALL_CATCH_EXCEPTION(0);
59781   }
59782   jresult = new Dali::PixelData((const Dali::PixelData &)result);
59783   return jresult;
59784 }
59785
59786
59787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
59788   void * jresult ;
59789   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59790   Dali::PixelData result;
59791
59792   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59793   {
59794     try {
59795       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
59796     } CALL_CATCH_EXCEPTION(0);
59797   }
59798   jresult = new Dali::PixelData((const Dali::PixelData &)result);
59799   return jresult;
59800 }
59801
59802
59803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
59804   void * jresult ;
59805   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59806   unsigned char *result = 0 ;
59807
59808   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59809   {
59810     try {
59811       result = (unsigned char *)(arg1)->GetBuffer();
59812     } CALL_CATCH_EXCEPTION(0);
59813   }
59814    jresult = (void *)result;
59815    return jresult;
59816 }
59817
59818 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
59819   unsigned int jresult ;
59820   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59821   unsigned int result;
59822
59823   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59824   {
59825     try {
59826       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
59827     } CALL_CATCH_EXCEPTION(0);
59828   }
59829   jresult = result;
59830   return jresult;
59831 }
59832
59833
59834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
59835   unsigned int jresult ;
59836   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59837   unsigned int result;
59838
59839   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59840   {
59841     try {
59842       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
59843     } CALL_CATCH_EXCEPTION(0);
59844   }
59845   jresult = result;
59846   return jresult;
59847 }
59848
59849
59850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
59851   int jresult ;
59852   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59853   Dali::Pixel::Format result;
59854
59855   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59856   {
59857     try {
59858       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
59859     } CALL_CATCH_EXCEPTION(0);
59860   }
59861   jresult = (int)result;
59862   return jresult;
59863 }
59864
59865
59866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, bool jarg4) {
59867   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59868   Dali::Devel::PixelBuffer arg2 ;
59869   float arg3 ;
59870   bool arg4 ;
59871   Dali::Devel::PixelBuffer *argp2 ;
59872
59873   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59874   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
59875   if (!argp2) {
59876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
59877     return ;
59878   }
59879   arg2 = *argp2;
59880   arg3 = (float)jarg3;
59881   arg4 = jarg4 ? true : false;
59882   {
59883     try {
59884       (arg1)->ApplyMask(arg2,arg3,arg4);
59885     } CALL_CATCH_EXCEPTION();
59886   }
59887 }
59888
59889
59890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
59891   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59892   Dali::Devel::PixelBuffer arg2 ;
59893   float arg3 ;
59894   Dali::Devel::PixelBuffer *argp2 ;
59895
59896   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59897   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
59898   if (!argp2) {
59899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
59900     return ;
59901   }
59902   arg2 = *argp2;
59903   arg3 = (float)jarg3;
59904   {
59905     try {
59906       (arg1)->ApplyMask(arg2,arg3);
59907     } CALL_CATCH_EXCEPTION();
59908   }
59909 }
59910
59911
59912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
59913   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59914   Dali::Devel::PixelBuffer arg2 ;
59915   Dali::Devel::PixelBuffer *argp2 ;
59916
59917   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59918   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
59919   if (!argp2) {
59920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
59921     return ;
59922   }
59923   arg2 = *argp2;
59924   {
59925     try {
59926       (arg1)->ApplyMask(arg2);
59927     } CALL_CATCH_EXCEPTION();
59928   }
59929 }
59930
59931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
59932   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59933   float arg2 ;
59934
59935   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59936   arg2 = (float)jarg2;
59937   {
59938     try {
59939       (arg1)->ApplyGaussianBlur(arg2);
59940     } CALL_CATCH_EXCEPTION();
59941   }
59942 }
59943
59944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
59945   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59946   uint16_t arg2 ;
59947   uint16_t arg3 ;
59948   uint16_t arg4 ;
59949   uint16_t arg5 ;
59950
59951   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59952   arg2 = (uint16_t)jarg2;
59953   arg3 = (uint16_t)jarg3;
59954   arg4 = (uint16_t)jarg4;
59955   arg5 = (uint16_t)jarg5;
59956   {
59957     try {
59958       (arg1)->Crop(arg2,arg3,arg4,arg5);
59959     } CALL_CATCH_EXCEPTION();
59960   }
59961 }
59962
59963
59964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
59965   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59966   uint16_t arg2 ;
59967   uint16_t arg3 ;
59968
59969   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59970   arg2 = (uint16_t)jarg2;
59971   arg3 = (uint16_t)jarg3;
59972   {
59973     try {
59974       (arg1)->Resize(arg2,arg3);
59975     } CALL_CATCH_EXCEPTION();
59976   }
59977 }
59978
59979 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void* jarg2) {
59980   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59981   Dali::Degree * arg2 ;
59982
59983   bool result = false;
59984
59985   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59986   arg2 = (Dali::Degree *)jarg2;
59987   {
59988     try {
59989       result = (arg1)->Rotate(*arg2);
59990     } CALL_CATCH_EXCEPTION(false);
59991   }
59992   return result;
59993 }
59994
59995 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBrightness(void * jarg1) {
59996   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59997   uint32_t result = 0;
59998
59999   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
60000   {
60001     try {
60002       result = (arg1)->GetBrightness();
60003     } CALL_CATCH_EXCEPTION(0);
60004   }
60005   return result;
60006 }
60007
60008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
60009   void * jresult ;
60010   std::string *arg1 = 0 ;
60011   Dali::ImageDimensions arg2 ;
60012   Dali::FittingMode::Type arg3 ;
60013   Dali::SamplingMode::Type arg4 ;
60014   bool arg5 ;
60015   Dali::ImageDimensions *argp2 ;
60016   Dali::Devel::PixelBuffer result;
60017
60018   if (!jarg1) {
60019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60020     return 0;
60021   }
60022   std::string arg1_str(jarg1);
60023   arg1 = &arg1_str;
60024   argp2 = (Dali::ImageDimensions *)jarg2;
60025   if (!argp2) {
60026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60027     return 0;
60028   }
60029   arg2 = *argp2;
60030   arg3 = (Dali::FittingMode::Type)jarg3;
60031   arg4 = (Dali::SamplingMode::Type)jarg4;
60032   arg5 = jarg5 ? true : false;
60033   {
60034     try {
60035       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
60036     } CALL_CATCH_EXCEPTION(0);
60037   }
60038   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60039   return jresult;
60040 }
60041
60042
60043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
60044   void * jresult ;
60045   std::string *arg1 = 0 ;
60046   Dali::ImageDimensions arg2 ;
60047   Dali::FittingMode::Type arg3 ;
60048   Dali::SamplingMode::Type arg4 ;
60049   Dali::ImageDimensions *argp2 ;
60050   Dali::Devel::PixelBuffer result;
60051
60052   if (!jarg1) {
60053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60054     return 0;
60055   }
60056   std::string arg1_str(jarg1);
60057   arg1 = &arg1_str;
60058   argp2 = (Dali::ImageDimensions *)jarg2;
60059   if (!argp2) {
60060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60061     return 0;
60062   }
60063   arg2 = *argp2;
60064   arg3 = (Dali::FittingMode::Type)jarg3;
60065   arg4 = (Dali::SamplingMode::Type)jarg4;
60066   {
60067     try {
60068       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
60069     } CALL_CATCH_EXCEPTION(0);
60070   }
60071   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60072   return jresult;
60073 }
60074
60075
60076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
60077   void * jresult ;
60078   std::string *arg1 = 0 ;
60079   Dali::ImageDimensions arg2 ;
60080   Dali::FittingMode::Type arg3 ;
60081   Dali::ImageDimensions *argp2 ;
60082   Dali::Devel::PixelBuffer result;
60083
60084   if (!jarg1) {
60085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60086     return 0;
60087   }
60088   std::string arg1_str(jarg1);
60089   arg1 = &arg1_str;
60090   argp2 = (Dali::ImageDimensions *)jarg2;
60091   if (!argp2) {
60092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60093     return 0;
60094   }
60095   arg2 = *argp2;
60096   arg3 = (Dali::FittingMode::Type)jarg3;
60097   {
60098     try {
60099       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
60100     } CALL_CATCH_EXCEPTION(0);
60101   }
60102   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60103   return jresult;
60104 }
60105
60106
60107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
60108   void * jresult ;
60109   std::string *arg1 = 0 ;
60110   Dali::ImageDimensions arg2 ;
60111   Dali::ImageDimensions *argp2 ;
60112   Dali::Devel::PixelBuffer result;
60113
60114   if (!jarg1) {
60115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60116     return 0;
60117   }
60118   std::string arg1_str(jarg1);
60119   arg1 = &arg1_str;
60120   argp2 = (Dali::ImageDimensions *)jarg2;
60121   if (!argp2) {
60122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60123     return 0;
60124   }
60125   arg2 = *argp2;
60126   {
60127     try {
60128       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
60129     } CALL_CATCH_EXCEPTION(0);
60130   }
60131   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60132   return jresult;
60133 }
60134
60135
60136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
60137   void * jresult ;
60138   std::string *arg1 = 0 ;
60139   Dali::Devel::PixelBuffer result;
60140
60141   if (!jarg1) {
60142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60143     return 0;
60144   }
60145   std::string arg1_str(jarg1);
60146   arg1 = &arg1_str;
60147   {
60148     try {
60149       result = Dali::LoadImageFromFile((std::string const &)*arg1);
60150     } CALL_CATCH_EXCEPTION(0);
60151   }
60152   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60153   return jresult;
60154 }
60155
60156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_0(void * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
60157   void * jresult ;
60158   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
60159   Dali::ImageDimensions arg2 ;
60160   Dali::FittingMode::Type arg3 ;
60161   Dali::SamplingMode::Type arg4 ;
60162   bool arg5 ;
60163   Dali::ImageDimensions *argp2 ;
60164   Dali::Devel::PixelBuffer result;
60165
60166   if (!jarg1) {
60167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
60168     return 0;
60169   }
60170   arg1 = (Dali::Vector<uint8_t> *)jarg1;
60171   argp2 = (Dali::ImageDimensions *)jarg2;
60172   if (!argp2) {
60173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60174     return 0;
60175   }
60176   arg2 = *argp2;
60177   arg3 = (Dali::FittingMode::Type)jarg3;
60178   arg4 = (Dali::SamplingMode::Type)jarg4;
60179   arg5 = jarg5 ? true : false;
60180   {
60181     try {
60182       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1, arg2, arg3, arg4, arg5);
60183     } CALL_CATCH_EXCEPTION(0);
60184   }
60185   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60186   return jresult;
60187 }
60188
60189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_1(void * jarg1, void * jarg2, int jarg3, int jarg4) {
60190   void * jresult ;
60191   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
60192   Dali::ImageDimensions arg2 ;
60193   Dali::FittingMode::Type arg3 ;
60194   Dali::SamplingMode::Type arg4 ;
60195   Dali::ImageDimensions *argp2 ;
60196   Dali::Devel::PixelBuffer result;
60197
60198   if (!jarg1) {
60199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
60200     return 0;
60201   }
60202   arg1 = (Dali::Vector<uint8_t> *)jarg1;
60203   argp2 = (Dali::ImageDimensions *)jarg2;
60204   if (!argp2) {
60205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60206     return 0;
60207   }
60208   arg2 = *argp2;
60209   arg3 = (Dali::FittingMode::Type)jarg3;
60210   arg4 = (Dali::SamplingMode::Type)jarg4;
60211   {
60212     try {
60213       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1, arg2, arg3, arg4);
60214     } CALL_CATCH_EXCEPTION(0);
60215   }
60216   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60217   return jresult;
60218 }
60219
60220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_2(void * jarg1, void * jarg2, int jarg3) {
60221   void * jresult ;
60222   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
60223   Dali::ImageDimensions arg2 ;
60224   Dali::FittingMode::Type arg3 ;
60225   Dali::ImageDimensions *argp2 ;
60226   Dali::Devel::PixelBuffer result;
60227
60228   if (!jarg1) {
60229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
60230     return 0;
60231   }
60232   arg1 = (Dali::Vector<uint8_t> *)jarg1;
60233   argp2 = (Dali::ImageDimensions *)jarg2;
60234   if (!argp2) {
60235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60236     return 0;
60237   }
60238   arg2 = *argp2;
60239   arg3 = (Dali::FittingMode::Type)jarg3;
60240   {
60241     try {
60242       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1, arg2, arg3);
60243     } CALL_CATCH_EXCEPTION(0);
60244   }
60245   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60246   return jresult;
60247 }
60248
60249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_3(void * jarg1, void * jarg2) {
60250   void * jresult ;
60251   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
60252   Dali::ImageDimensions arg2 ;
60253   Dali::ImageDimensions *argp2 ;
60254   Dali::Devel::PixelBuffer result;
60255
60256   if (!jarg1) {
60257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
60258     return 0;
60259   }
60260   arg1 = (Dali::Vector<uint8_t> *)jarg1;
60261   argp2 = (Dali::ImageDimensions *)jarg2;
60262   if (!argp2) {
60263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60264     return 0;
60265   }
60266   arg2 = *argp2;
60267   {
60268     try {
60269       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1, arg2);
60270     } CALL_CATCH_EXCEPTION(0);
60271   }
60272   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60273   return jresult;
60274 }
60275
60276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_4(void * jarg1) {
60277   void * jresult ;
60278   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
60279   Dali::Devel::PixelBuffer result;
60280
60281   if (!jarg1) {
60282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
60283     return 0;
60284   }
60285   arg1 = (Dali::Vector<uint8_t> *)jarg1;
60286   {
60287     try {
60288       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1);
60289     } CALL_CATCH_EXCEPTION(0);
60290   }
60291   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60292   return jresult;
60293 }
60294
60295
60296
60297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
60298   void * jresult ;
60299   std::string *arg1 = 0 ;
60300   Dali::ImageDimensions arg2 ;
60301   Dali::FittingMode::Type arg3 ;
60302   Dali::SamplingMode::Type arg4 ;
60303   bool arg5 ;
60304   Dali::ImageDimensions *argp2 ;
60305   Dali::ImageDimensions result;
60306
60307   if (!jarg1) {
60308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60309     return 0;
60310   }
60311   std::string arg1_str(jarg1);
60312   arg1 = &arg1_str;
60313   argp2 = (Dali::ImageDimensions *)jarg2;
60314   if (!argp2) {
60315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60316     return 0;
60317   }
60318   arg2 = *argp2;
60319   arg3 = (Dali::FittingMode::Type)jarg3;
60320   arg4 = (Dali::SamplingMode::Type)jarg4;
60321   arg5 = jarg5 ? true : false;
60322   {
60323     try {
60324       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
60325     } CALL_CATCH_EXCEPTION(0);
60326   }
60327   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
60328   return jresult;
60329 }
60330
60331
60332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
60333   void * jresult ;
60334   std::string *arg1 = 0 ;
60335   Dali::ImageDimensions arg2 ;
60336   Dali::FittingMode::Type arg3 ;
60337   Dali::SamplingMode::Type arg4 ;
60338   Dali::ImageDimensions *argp2 ;
60339   Dali::ImageDimensions result;
60340
60341   if (!jarg1) {
60342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60343     return 0;
60344   }
60345   std::string arg1_str(jarg1);
60346   arg1 = &arg1_str;
60347   argp2 = (Dali::ImageDimensions *)jarg2;
60348   if (!argp2) {
60349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60350     return 0;
60351   }
60352   arg2 = *argp2;
60353   arg3 = (Dali::FittingMode::Type)jarg3;
60354   arg4 = (Dali::SamplingMode::Type)jarg4;
60355   {
60356     try {
60357       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
60358     } CALL_CATCH_EXCEPTION(0);
60359   }
60360   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
60361   return jresult;
60362 }
60363
60364
60365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
60366   void * jresult ;
60367   std::string *arg1 = 0 ;
60368   Dali::ImageDimensions arg2 ;
60369   Dali::FittingMode::Type arg3 ;
60370   Dali::ImageDimensions *argp2 ;
60371   Dali::ImageDimensions result;
60372
60373   if (!jarg1) {
60374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60375     return 0;
60376   }
60377   std::string arg1_str(jarg1);
60378   arg1 = &arg1_str;
60379   argp2 = (Dali::ImageDimensions *)jarg2;
60380   if (!argp2) {
60381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60382     return 0;
60383   }
60384   arg2 = *argp2;
60385   arg3 = (Dali::FittingMode::Type)jarg3;
60386   {
60387     try {
60388       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
60389     } CALL_CATCH_EXCEPTION(0);
60390   }
60391   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
60392   return jresult;
60393 }
60394
60395
60396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
60397   void * jresult ;
60398   std::string *arg1 = 0 ;
60399   Dali::ImageDimensions arg2 ;
60400   Dali::ImageDimensions *argp2 ;
60401   Dali::ImageDimensions result;
60402
60403   if (!jarg1) {
60404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60405     return 0;
60406   }
60407   std::string arg1_str(jarg1);
60408   arg1 = &arg1_str;
60409   argp2 = (Dali::ImageDimensions *)jarg2;
60410   if (!argp2) {
60411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60412     return 0;
60413   }
60414   arg2 = *argp2;
60415   {
60416     try {
60417       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
60418     } CALL_CATCH_EXCEPTION(0);
60419   }
60420   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
60421   return jresult;
60422 }
60423
60424
60425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
60426   void * jresult ;
60427   std::string *arg1 = 0 ;
60428   Dali::ImageDimensions result;
60429
60430   if (!jarg1) {
60431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60432     return 0;
60433   }
60434   std::string arg1_str(jarg1);
60435   arg1 = &arg1_str;
60436   {
60437     try {
60438       result = Dali::GetClosestImageSize((std::string const &)*arg1);
60439     } CALL_CATCH_EXCEPTION(0);
60440   }
60441   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
60442   return jresult;
60443 }
60444
60445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1, bool jarg2) {
60446   void * jresult ;
60447   std::string *arg1 = 0 ;
60448   bool arg2 ;
60449   Dali::ImageDimensions result;
60450
60451   if (!jarg1) {
60452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60453     return 0;
60454   }
60455   std::string arg1_str(jarg1);
60456   arg1 = &arg1_str;
60457   arg2 = jarg2 ? true : false;
60458   {
60459     try {
60460       result = Dali::GetOriginalImageSize((std::string const &)*arg1,arg2);
60461     } CALL_CATCH_EXCEPTION(0);
60462   }
60463   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
60464   return jresult;
60465 }
60466
60467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
60468   void * jresult ;
60469   std::string *arg1 = 0 ;
60470   Dali::ImageDimensions arg2 ;
60471   Dali::FittingMode::Type arg3 ;
60472   Dali::SamplingMode::Type arg4 ;
60473   bool arg5 ;
60474   Dali::ImageDimensions *argp2 ;
60475   Dali::Devel::PixelBuffer result;
60476
60477   if (!jarg1) {
60478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60479     return 0;
60480   }
60481   std::string arg1_str(jarg1);
60482   arg1 = &arg1_str;
60483   argp2 = (Dali::ImageDimensions *)jarg2;
60484   if (!argp2) {
60485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60486     return 0;
60487   }
60488   arg2 = *argp2;
60489   arg3 = (Dali::FittingMode::Type)jarg3;
60490   arg4 = (Dali::SamplingMode::Type)jarg4;
60491   arg5 = jarg5 ? true : false;
60492   {
60493     try {
60494       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
60495     } CALL_CATCH_EXCEPTION(0);
60496   }
60497   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60498   return jresult;
60499 }
60500
60501
60502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
60503   void * jresult ;
60504   std::string *arg1 = 0 ;
60505   Dali::ImageDimensions arg2 ;
60506   Dali::FittingMode::Type arg3 ;
60507   Dali::SamplingMode::Type arg4 ;
60508   Dali::ImageDimensions *argp2 ;
60509   Dali::Devel::PixelBuffer result;
60510
60511   if (!jarg1) {
60512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60513     return 0;
60514   }
60515   std::string arg1_str(jarg1);
60516   arg1 = &arg1_str;
60517   argp2 = (Dali::ImageDimensions *)jarg2;
60518   if (!argp2) {
60519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60520     return 0;
60521   }
60522   arg2 = *argp2;
60523   arg3 = (Dali::FittingMode::Type)jarg3;
60524   arg4 = (Dali::SamplingMode::Type)jarg4;
60525   {
60526     try {
60527       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
60528     } CALL_CATCH_EXCEPTION(0);
60529   }
60530   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60531   return jresult;
60532 }
60533
60534
60535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
60536   void * jresult ;
60537   std::string *arg1 = 0 ;
60538   Dali::ImageDimensions arg2 ;
60539   Dali::FittingMode::Type arg3 ;
60540   Dali::ImageDimensions *argp2 ;
60541   Dali::Devel::PixelBuffer result;
60542
60543   if (!jarg1) {
60544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60545     return 0;
60546   }
60547   std::string arg1_str(jarg1);
60548   arg1 = &arg1_str;
60549   argp2 = (Dali::ImageDimensions *)jarg2;
60550   if (!argp2) {
60551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60552     return 0;
60553   }
60554   arg2 = *argp2;
60555   arg3 = (Dali::FittingMode::Type)jarg3;
60556   {
60557     try {
60558       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
60559     } CALL_CATCH_EXCEPTION(0);
60560   }
60561   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60562   return jresult;
60563 }
60564
60565
60566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
60567   void * jresult ;
60568   std::string *arg1 = 0 ;
60569   Dali::ImageDimensions arg2 ;
60570   Dali::ImageDimensions *argp2 ;
60571   Dali::Devel::PixelBuffer result;
60572
60573   if (!jarg1) {
60574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60575     return 0;
60576   }
60577   std::string arg1_str(jarg1);
60578   arg1 = &arg1_str;
60579   argp2 = (Dali::ImageDimensions *)jarg2;
60580   if (!argp2) {
60581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60582     return 0;
60583   }
60584   arg2 = *argp2;
60585   {
60586     try {
60587       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
60588     } CALL_CATCH_EXCEPTION(0);
60589   }
60590   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60591   return jresult;
60592 }
60593
60594
60595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
60596   void * jresult ;
60597   std::string *arg1 = 0 ;
60598   Dali::Devel::PixelBuffer result;
60599
60600   if (!jarg1) {
60601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60602     return 0;
60603   }
60604   std::string arg1_str(jarg1);
60605   arg1 = &arg1_str;
60606   {
60607     try {
60608       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
60609     } CALL_CATCH_EXCEPTION(0);
60610   }
60611   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60612   return jresult;
60613 }
60614
60615 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
60616   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
60617   char * jresult = SWIG_csharp_string_callback((const char *)result);
60618   return jresult;
60619 }
60620
60621 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
60622   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
60623   return result;
60624 }
60625
60626 struct NativeImageSourcePtrHandle
60627 {
60628   NativeImageSourcePtr Ptr;
60629 };
60630
60631 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
60632 {
60633   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
60634   return (NativeImageInterface*)(arg1);
60635 }
60636
60637 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
60638 {
60639   void* jresult;
60640   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
60641   {
60642     try {
60643       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
60644     }
60645     catch (std::out_of_range & e) {
60646       {
60647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60648       };
60649     }
60650     catch (std::exception & e) {
60651       {
60652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60653       };
60654     }
60655     catch (Dali::DaliException e) {
60656       {
60657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60658       };
60659     }
60660     catch (...) {
60661       {
60662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60663       };
60664     }
60665   }
60666   jresult = (void *)handle;
60667   return jresult;
60668 }
60669
60670 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
60671 {
60672   void* jresult;
60673   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
60674   jresult = (void*)( handle->Ptr.Get() );
60675   return jresult;
60676 }
60677
60678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
60679   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
60680   {
60681     try {
60682       delete arg1;
60683     }
60684     catch (std::out_of_range & e) {
60685       {
60686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
60687       };
60688     }
60689     catch (std::exception & e) {
60690       {
60691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
60692       };
60693     }
60694     catch (Dali::DaliException e) {
60695       {
60696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
60697       };
60698     }
60699     catch (...) {
60700       {
60701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
60702       };
60703     }
60704   }
60705 }
60706
60707 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
60708 {
60709   void* jresult;
60710   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
60711   uint16_t* arg2 = (uint16_t*)(jarg2);
60712   uint16_t* arg3 = (uint16_t*)(jarg3);
60713   uint16_t* arg4 = (uint16_t*)(jarg4);
60714   {
60715     try {
60716       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
60717     }
60718     catch (std::out_of_range & e) {
60719       {
60720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60721       };
60722     }
60723     catch (std::exception & e) {
60724       {
60725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60726       };
60727     }
60728     catch (Dali::DaliException e) {
60729       {
60730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60731       };
60732     }
60733     catch (...) {
60734       {
60735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60736       };
60737     }
60738   }
60739   return jresult;
60740 }
60741
60742 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
60743 {
60744   bool jresult;
60745   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
60746
60747   {
60748     try {
60749       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
60750     }
60751     catch (std::out_of_range & e) {
60752       {
60753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60754       };
60755     }
60756     catch (std::exception & e) {
60757       {
60758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60759       };
60760     }
60761     catch (Dali::DaliException e) {
60762       {
60763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60764       };
60765     }
60766     catch (...) {
60767       {
60768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60769       };
60770     }
60771   }
60772   return jresult;
60773 }
60774
60775 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_GenerateUrl(void* handle)
60776 {
60777   Dali::Toolkit::ImageUrl result;
60778   NativeImageSource* nativeImageSource = (NativeImageSource*)handle;
60779   void *jresult;
60780
60781   if (!nativeImageSource)
60782   {
60783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0);
60784     return 0;
60785   }
60786   {
60787     try
60788     {
60789       result = Dali::Toolkit::Image::GenerateUrl(nativeImageSource);
60790     }
60791     catch (std::out_of_range& e)
60792     {
60793       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
60794       return 0;
60795     }
60796     catch (std::exception& e)
60797     {
60798       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
60799       return 0;
60800     }
60801     catch (Dali::DaliException e)
60802     {
60803       SWIG_CSharpException(SWIG_UnknownError, e.condition);
60804       return 0;
60805     }
60806     catch (...)
60807     {
60808       SWIG_CSharpException(SWIG_UnknownError, "unknown error");
60809       return 0;
60810     }
60811   }
60812
60813   jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl &)result);
60814   return jresult;
60815 }
60816
60817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageUrl(void* jarg1)
60818 {
60819   Dali::Toolkit::ImageUrl* imageUrl = (Dali::Toolkit::ImageUrl*) 0;
60820
60821   imageUrl = (Dali::Toolkit::ImageUrl*)jarg1;
60822   {
60823     try
60824     {
60825       delete imageUrl;
60826     }
60827     catch (std::out_of_range& e)
60828     {
60829       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
60830       return;
60831     }
60832     catch (std::exception& e)
60833     {
60834       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
60835       return;
60836     }
60837     catch (Dali::DaliException e)
60838     {
60839       SWIG_CSharpException(SWIG_UnknownError, e.condition);
60840       return;
60841     }
60842     catch (...)
60843     {
60844       SWIG_CSharpException(SWIG_UnknownError, "unknown error");
60845       return;
60846     }
60847   }
60848 }
60849
60850 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImageUrl_Get(void* jarg1)
60851 {
60852   char *jresult;
60853   Dali::Toolkit::ImageUrl* imageUrl = (Dali::Toolkit::ImageUrl*) 0;
60854   std::string result;
60855
60856   imageUrl = (Dali::Toolkit::ImageUrl*)jarg1;
60857   {
60858     try
60859     {
60860       result = imageUrl->GetUrl();
60861     }
60862     catch (std::out_of_range& e)
60863     {
60864       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
60865       return 0;
60866     }
60867     catch (std::exception& e)
60868     {
60869       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
60870       return 0;
60871     }
60872     catch (Dali::DaliException e)
60873     {
60874       SWIG_CSharpException(SWIG_UnknownError, e.condition);
60875       return 0;
60876     }
60877     catch (...)
60878     {
60879       SWIG_CSharpException(SWIG_UnknownError, "unknown error");
60880       return 0;
60881     }
60882   }
60883
60884   jresult = SWIG_csharp_string_callback((&result)->c_str());
60885   return jresult;
60886 }
60887
60888 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetSuggestedMinimumWidth(void * jarg1) {
60889   Dali::Actor *arg1 = (Dali::Actor *) 0;
60890   Dali::Vector2 maximumSize;
60891   Dali::Vector2 minimumSize;
60892   Dali::Vector3 naturalSize;
60893   bool widthForHeight;
60894   float result;
60895   {
60896     try {
60897       arg1 = (Dali::Actor *)jarg1;
60898       maximumSize = arg1->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
60899       minimumSize = arg1->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
60900       naturalSize = arg1->GetNaturalSize();
60901       widthForHeight = arg1->GetProperty< bool >( Actor::Property::WIDTH_FOR_HEIGHT );
60902
60903       float baseWidth;
60904       if (widthForHeight)
60905       {
60906         float baseHeight = maximumSize.height > 0 ? std::min(maximumSize.height, naturalSize.height) : naturalSize.height;
60907         baseWidth = arg1->GetWidthForHeight(baseHeight);
60908       }
60909       else
60910       {
60911         baseWidth = naturalSize.width;
60912       }
60913
60914       result = minimumSize.width > 0 ? std::max(baseWidth, minimumSize.width) : baseWidth;
60915       result = maximumSize.width > 0 ? std::min(result, maximumSize.width) : result;
60916     } CALL_CATCH_EXCEPTION(0);
60917   }
60918
60919   return result;
60920 }
60921
60922 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetSuggestedMinimumHeight(void * jarg1) {
60923   Dali::Actor *arg1 = (Dali::Actor *) 0;
60924   Dali::Vector2 maximumSize;
60925   Dali::Vector2 minimumSize;
60926   Dali::Vector3 naturalSize;
60927   bool heightForWidth;
60928   float result;
60929   {
60930     try {
60931       arg1 = (Dali::Actor *)jarg1;
60932       maximumSize = arg1->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
60933       minimumSize = arg1->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
60934       naturalSize = arg1->GetNaturalSize();
60935       heightForWidth = arg1->GetProperty< bool >( Actor::Property::HEIGHT_FOR_WIDTH );
60936
60937       float baseHeight;
60938       if (heightForWidth)
60939       {
60940         float baseWidth = maximumSize.width > 0 ? std::min(maximumSize.width, naturalSize.width) : naturalSize.width;
60941         baseHeight = arg1->GetHeightForWidth(baseWidth);
60942       }
60943       else
60944       {
60945         baseHeight = naturalSize.height;
60946       }
60947
60948       result = minimumSize.height > 0 ? std::max(baseHeight, minimumSize.height) : baseHeight;
60949       result = maximumSize.height > 0 ? std::min(result, maximumSize.height) : result;
60950     } CALL_CATCH_EXCEPTION(0);
60951   }
60952
60953   return result;
60954 }
60955
60956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorVector2_BaseType_get() {
60957   int jresult ;
60958   int result;
60959
60960   result = (int)Dali::Vector< Dali::Vector2 >::BaseType;
60961   jresult = (int)result;
60962   return jresult;
60963 }
60964
60965
60966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorVector2__SWIG_0() {
60967   void * jresult ;
60968   Dali::Vector< Dali::Vector2 > *result = 0 ;
60969
60970   {
60971     try {
60972       result = (Dali::Vector< Dali::Vector2 > *)new Dali::Vector< Dali::Vector2 >();
60973     } CALL_CATCH_EXCEPTION(0);
60974   }
60975
60976   jresult = (void *)result;
60977   return jresult;
60978 }
60979
60980
60981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorVector2(void * jarg1) {
60982   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60983
60984   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60985   {
60986     try {
60987       delete arg1;
60988     } CALL_CATCH_EXCEPTION();
60989   }
60990 }
60991
60992
60993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorVector2__SWIG_1(void * jarg1) {
60994   void * jresult ;
60995   Dali::Vector< Dali::Vector2 > *arg1 = 0 ;
60996   Dali::Vector< Dali::Vector2 > *result = 0 ;
60997
60998   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60999   if (!arg1) {
61000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 > const & type is null", 0);
61001     return 0;
61002   }
61003   {
61004     try {
61005       result = (Dali::Vector< Dali::Vector2 > *)new Dali::Vector< Dali::Vector2 >((Dali::Vector< Dali::Vector2 > const &)*arg1);
61006     } CALL_CATCH_EXCEPTION(0);
61007   }
61008
61009   jresult = (void *)result;
61010   return jresult;
61011 }
61012
61013
61014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Assign(void * jarg1, void * jarg2) {
61015   void * jresult ;
61016   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61017   Dali::Vector< Dali::Vector2 > *arg2 = 0 ;
61018   Dali::Vector< Dali::Vector2 > *result = 0 ;
61019
61020   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61021   arg2 = (Dali::Vector< Dali::Vector2 > *)jarg2;
61022   if (!arg2) {
61023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 > const & type is null", 0);
61024     return 0;
61025   }
61026   {
61027     try {
61028       result = (Dali::Vector< Dali::Vector2 > *) &(arg1)->operator =((Dali::Vector< Dali::Vector2 > const &)*arg2);
61029     } CALL_CATCH_EXCEPTION(0);
61030   }
61031
61032   jresult = (void *)result;
61033   return jresult;
61034 }
61035
61036
61037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Begin(void * jarg1) {
61038   void * jresult ;
61039   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61040   Dali::Vector< Dali::Vector2 >::Iterator result;
61041
61042   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61043   {
61044     try {
61045       result = (Dali::Vector< Dali::Vector2 >::Iterator)((Dali::Vector< Dali::Vector2 > const *)arg1)->Begin();
61046     } CALL_CATCH_EXCEPTION(0);
61047   }
61048
61049   jresult = (void *)result;
61050   return jresult;
61051 }
61052
61053
61054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_End(void * jarg1) {
61055   void * jresult ;
61056   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61057   Dali::Vector< Dali::Vector2 >::Iterator result;
61058
61059   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61060   {
61061     try {
61062       result = (Dali::Vector< Dali::Vector2 >::Iterator)((Dali::Vector< Dali::Vector2 > const *)arg1)->End();
61063     } CALL_CATCH_EXCEPTION(0);
61064   }
61065
61066   jresult = (void *)result;
61067   return jresult;
61068 }
61069
61070
61071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
61072   void * jresult ;
61073   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61074   Dali::Vector< Dali::Vector2 >::SizeType arg2 ;
61075   Dali::Vector< Dali::Vector2 >::ItemType *result = 0 ;
61076
61077   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61078   arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2;
61079   {
61080     try {
61081       result = (Dali::Vector< Dali::Vector2 >::ItemType *) &(arg1)->operator [](arg2);
61082     } CALL_CATCH_EXCEPTION(0);
61083   }
61084
61085   jresult = (void *)result;
61086   return jresult;
61087 }
61088
61089
61090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_PushBack(void * jarg1, void * jarg2) {
61091   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61092   Dali::Vector< Dali::Vector2 >::ItemType *arg2 = 0 ;
61093
61094   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61095   arg2 = (Dali::Vector< Dali::Vector2 >::ItemType *)jarg2;
61096   if (!arg2) {
61097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 >::ItemType const & type is null", 0);
61098     return ;
61099   }
61100   {
61101     try {
61102       (arg1)->PushBack((Dali::Vector< Dali::Vector2 >::ItemType const &)*arg2);
61103     } CALL_CATCH_EXCEPTION();
61104   }
61105 }
61106
61107
61108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
61109   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61110   Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
61111   Dali::Vector< Dali::Vector2 >::ItemType *arg3 = 0 ;
61112
61113   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61114   arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2;
61115   arg3 = (Dali::Vector< Dali::Vector2 >::ItemType *)jarg3;
61116   if (!arg3) {
61117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 >::ItemType const & type is null", 0);
61118     return ;
61119   }
61120   {
61121     try {
61122       (arg1)->Insert(arg2,(Dali::Vector< Dali::Vector2 >::ItemType const &)*arg3);
61123     } CALL_CATCH_EXCEPTION();
61124   }
61125 }
61126
61127
61128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
61129   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61130   Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
61131   Dali::Vector< Dali::Vector2 >::Iterator arg3 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
61132   Dali::Vector< Dali::Vector2 >::Iterator arg4 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
61133
61134   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61135   arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2;
61136   arg3 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg3;
61137   arg4 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg4;
61138   {
61139     try {
61140       (arg1)->Insert(arg2,arg3,arg4);
61141     } CALL_CATCH_EXCEPTION();
61142   }
61143 }
61144
61145
61146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Reserve(void * jarg1, unsigned long jarg2) {
61147   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61148   Dali::Vector< Dali::Vector2 >::SizeType arg2 ;
61149
61150   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61151   arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2;
61152   {
61153     try {
61154       (arg1)->Reserve(arg2);
61155     } CALL_CATCH_EXCEPTION();
61156   }
61157 }
61158
61159
61160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
61161   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61162   Dali::Vector< Dali::Vector2 >::SizeType arg2 ;
61163
61164   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61165   arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2;
61166   {
61167     try {
61168       (arg1)->Resize(arg2);
61169     } CALL_CATCH_EXCEPTION();
61170   }
61171 }
61172
61173
61174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
61175   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61176   Dali::Vector< Dali::Vector2 >::SizeType arg2 ;
61177   Dali::Vector< Dali::Vector2 >::ItemType *arg3 = 0 ;
61178
61179   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61180   arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2;
61181   arg3 = (Dali::Vector< Dali::Vector2 >::ItemType *)jarg3;
61182   if (!arg3) {
61183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
61184     return ;
61185   }
61186   {
61187     try {
61188       (arg1)->Resize(arg2,(Dali::Vector< Dali::Vector2 >::ItemType const &)*arg3);
61189     } CALL_CATCH_EXCEPTION();
61190   }
61191 }
61192
61193
61194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Erase__SWIG_0(void * jarg1, void * jarg2) {
61195   void * jresult ;
61196   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61197   Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
61198   Dali::Vector< Dali::Vector2 >::Iterator result;
61199
61200   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61201   arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2;
61202   {
61203     try {
61204       result = (Dali::Vector< Dali::Vector2 >::Iterator)(arg1)->Erase(arg2);
61205     } CALL_CATCH_EXCEPTION(0);
61206   }
61207
61208   jresult = (void *)result;
61209   return jresult;
61210 }
61211
61212
61213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
61214   void * jresult ;
61215   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61216   Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
61217   Dali::Vector< Dali::Vector2 >::Iterator arg3 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
61218   Dali::Vector< Dali::Vector2 >::Iterator result;
61219
61220   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61221   arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2;
61222   arg3 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg3;
61223   {
61224     try {
61225       result = (Dali::Vector< Dali::Vector2 >::Iterator)(arg1)->Erase(arg2,arg3);
61226     } CALL_CATCH_EXCEPTION(0);
61227   }
61228
61229   jresult = (void *)result;
61230   return jresult;
61231 }
61232
61233
61234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Remove(void * jarg1, void * jarg2) {
61235   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61236   Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
61237
61238   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61239   arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2;
61240   {
61241     try {
61242       (arg1)->Remove(arg2);
61243     } CALL_CATCH_EXCEPTION();
61244   }
61245 }
61246
61247
61248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Swap(void * jarg1, void * jarg2) {
61249   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61250   Dali::Vector< Dali::Vector2 > *arg2 = 0 ;
61251
61252   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61253   arg2 = (Dali::Vector< Dali::Vector2 > *)jarg2;
61254   if (!arg2) {
61255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 > & type is null", 0);
61256     return ;
61257   }
61258   {
61259     try {
61260       (arg1)->Swap(*arg2);
61261     } CALL_CATCH_EXCEPTION();
61262   }
61263 }
61264
61265
61266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Clear(void * jarg1) {
61267   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61268
61269   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61270   {
61271     try {
61272       (arg1)->Clear();
61273     } CALL_CATCH_EXCEPTION();
61274   }
61275 }
61276
61277
61278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Release(void * jarg1) {
61279   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61280
61281   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61282   {
61283     try {
61284       (arg1)->Release();
61285     } CALL_CATCH_EXCEPTION();
61286   }
61287 }
61288
61289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorVector2_Size(void * jarg1) {
61290   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61291   int size;
61292
61293   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61294   {
61295     try {
61296       size = (arg1)->Size();
61297     } CALL_CATCH_EXCEPTION(0);
61298   }
61299
61300   return size;
61301 }
61302
61303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetScreenSize() {
61304   void * jresult ;
61305   int width, height;
61306
61307   try {
61308     Dali::DevelWindowSystem::GetScreenSize(width, height);
61309   } CALL_CATCH_EXCEPTION(0);
61310
61311   jresult = new Dali::Size(width, height);
61312   return jresult;
61313 }
61314
61315 #ifdef __cplusplus
61316 }
61317 #endif