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

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #ifndef SWIGCSHARP
  12 #define SWIGCSHARP
  13 #endif
  14
  15 #define SWIG_DIRECTORS
  16
  17
  18 /* -----------------------------------------------------------------------------
  19  *  This section contains generic SWIG labels for method/variable
  20  *  declarations/attributes, and other compiler dependent labels.
  21  * ----------------------------------------------------------------------------- */
  22
  23 /* template workaround for compilers that cannot correctly implement the C++ standard */
  24 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  25 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  26 #  define SWIGTEMPLATEDISAMBIGUATOR template
  27 # elif defined(__HP_aCC)
  28 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  29 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  30 #  define SWIGTEMPLATEDISAMBIGUATOR template
  31 # else
  32 #  define SWIGTEMPLATEDISAMBIGUATOR
  33 # endif
  34 #endif
  35
  36 /* inline attribute */
  37 #ifndef SWIGINLINE
  38 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  39 #   define SWIGINLINE inline
  40 # else
  41 #   define SWIGINLINE
  42 # endif
  43 #endif
  44
  45 /* attribute recognised by some compilers to avoid 'unused' warnings */
  46 #ifndef SWIGUNUSED
  47 # if defined(__GNUC__)
  48 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  49 #     define SWIGUNUSED __attribute__ ((__unused__))
  50 #   else
  51 #     define SWIGUNUSED
  52 #   endif
  53 # elif defined(__ICC)
  54 #   define SWIGUNUSED __attribute__ ((__unused__))
  55 # else
  56 #   define SWIGUNUSED
  57 # endif
  58 #endif
  59
  60 #ifndef SWIG_MSC_UNSUPPRESS_4505
  61 # if defined(_MSC_VER)
  62 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  63 # endif
  64 #endif
  65
  66 #ifndef SWIGUNUSEDPARM
  67 # ifdef __cplusplus
  68 #   define SWIGUNUSEDPARM(p)
  69 # else
  70 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  71 # endif
  72 #endif
  73
  74 /* internal SWIG method */
  75 #ifndef SWIGINTERN
  76 # define SWIGINTERN static SWIGUNUSED
  77 #endif
  78
  79 /* internal inline SWIG method */
  80 #ifndef SWIGINTERNINLINE
  81 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
  82 #endif
  83
  84 /* exporting methods */
  85 #if defined(__GNUC__)
  86 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
  87 #    ifndef GCC_HASCLASSVISIBILITY
  88 #      define GCC_HASCLASSVISIBILITY
  89 #    endif
  90 #  endif
  91 #endif
  92
  93 #ifndef SWIGEXPORT
  94 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
  95 #   if defined(STATIC_LINKED)
  96 #     define SWIGEXPORT
  97 #   else
  98 #     define SWIGEXPORT __declspec(dllexport)
  99 #   endif
 100 # else
 101 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 102 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 103 #   else
 104 #     define SWIGEXPORT
 105 #   endif
 106 # endif
 107 #endif
 108
 109 /* calling conventions for Windows */
 110 #ifndef SWIGSTDCALL
 111 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 112 #   define SWIGSTDCALL __stdcall
 113 # else
 114 #   define SWIGSTDCALL
 115 # endif
 116 #endif
 117
 118 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 119 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 120 # define _CRT_SECURE_NO_DEPRECATE
 121 #endif
 122
 123 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 124 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 125 # define _SCL_SECURE_NO_DEPRECATE
 126 #endif
 127
 128 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 129 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 130 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 131 #endif
 132
 133 /* Intel's compiler complains if a variable which was never initialised is
 134  * cast to void, which is a common idiom which we use to indicate that we
 135  * are aware a variable isn't used.  So we just silence that warning.
 136  * See: https://github.com/swig/swig/issues/192 for more discussion.
 137  */
 138 #ifdef __INTEL_COMPILER
 139 # pragma warning disable 592
 140 #endif
 141
 142
 143 #include <stdlib.h>
 144 #include <string.h>
 145 #include <string_view>
 146 #include <stdio.h>
 147
 148 #include "common.h"
 149 #include "slim-custom-view-impl.h"
 150
 151 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 152   { SWIG_CSharpApplicationException, NULL },
 153   { SWIG_CSharpArithmeticException, NULL },
 154   { SWIG_CSharpDivideByZeroException, NULL },
 155   { SWIG_CSharpIndexOutOfRangeException, NULL },
 156   { SWIG_CSharpInvalidCastException, NULL },
 157   { SWIG_CSharpInvalidOperationException, NULL },
 158   { SWIG_CSharpIOException, NULL },
 159   { SWIG_CSharpNullReferenceException, NULL },
 160   { SWIG_CSharpOutOfMemoryException, NULL },
 161   { SWIG_CSharpOverflowException, NULL },
 162   { SWIG_CSharpSystemException, NULL }
 163 };
 164
 165 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 166   { SWIG_CSharpArgumentException, NULL },
 167   { SWIG_CSharpArgumentNullException, NULL },
 168   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 169 };
 170
 171 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 172   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 173   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 174     callback = SWIG_csharp_exceptions[code].callback;
 175   }
 176   callback(msg);
 177 }
 178
 179 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 180   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 181   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 182     callback = SWIG_csharp_exceptions_argument[code].callback;
 183   }
 184   callback(msg, param_name);
 185 }
 186
 187
 188 #ifdef __cplusplus
 189 extern "C"
 190 #endif
 191 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 192                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 193                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 194                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 195                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 196                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 197                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 198                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 199                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 200                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 201                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 202                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 203   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 204   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 205   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 206   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 207   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 208   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 209   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 210   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 211   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 212   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 213   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 214 }
 215
 216 #ifdef __cplusplus
 217 extern "C"
 218 #endif
 219 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 220                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 221                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 222                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 223   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 224   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 225   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 226 }
 227
 228
 229 /* Callback for returning strings to C# without leaking memory */
 230 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 231 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 232
 233 // keep argWidgetCs and argWidgetV so they're always available to DALi
 234 int argWidgetC = 1;
 235 char **argWidgetV = NULL;
 236
 237 #ifdef __cplusplus
 238 extern "C"
 239 #endif
 240 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 241   SWIG_csharp_string_callback = callback;
 242 }
 243
 244
 245 /* Contract support */
 246 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 247
 248
 249 /* -----------------------------------------------------------------------------
 250  * director_common.swg
 251  *
 252  * This file contains support for director classes which is common between
 253  * languages.
 254  * ----------------------------------------------------------------------------- */
 255
 256 /*
 257   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 258   'Swig' namespace. This could be useful for multi-modules projects.
 259 */
 260 #ifdef SWIG_DIRECTOR_STATIC
 261 /* Force anonymous (static) namespace */
 262 #define Swig
 263 #endif
 264 /* -----------------------------------------------------------------------------
 265  * director.swg
 266  *
 267  * This file contains support for director classes so that C# proxy
 268  * methods can be called from C++.
 269  * ----------------------------------------------------------------------------- */
 270
 271 #if defined(DEBUG_DIRECTOR_OWNED)
 272 #include <iostream>
 273 #endif
 274 #include <string>
 275 #include <exception>
 276
 277 namespace Swig {
 278   /* Director base class - not currently used in C# directors */
 279   class Director {
 280   };
 281
 282   /* Base class for director exceptions */
 283   class DirectorException : public std::exception {
 284   protected:
 285     std::string swig_msg;
 286
 287   public:
 288     DirectorException(const char *msg) : swig_msg(msg) {
 289     }
 290
 291     DirectorException(const std::string &msg) : swig_msg(msg) {
 292     }
 293
 294     virtual ~DirectorException() throw() {
 295     }
 296
 297     const char *what() const throw() {
 298       return swig_msg.c_str();
 299     }
 300   };
 301
 302   /* Pure virtual method exception */
 303   class DirectorPureVirtualException : public DirectorException {
 304   public:
 305     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 306     }
 307   };
 308 }
 309
 310
 311 void SWIG_CSharpException(int code, const char *msg) {
 312   if (code == SWIG_ValueError) {
 313     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 314     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 315   } else {
 316     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 317     switch(code) {
 318     case SWIG_MemoryError:
 319       exception_code = SWIG_CSharpOutOfMemoryException;
 320       break;
 321     case SWIG_IndexError:
 322       exception_code = SWIG_CSharpIndexOutOfRangeException;
 323       break;
 324     case SWIG_DivisionByZero:
 325       exception_code = SWIG_CSharpDivideByZeroException;
 326       break;
 327     case SWIG_IOError:
 328       exception_code = SWIG_CSharpIOException;
 329       break;
 330     case SWIG_OverflowError:
 331       exception_code = SWIG_CSharpOverflowException;
 332       break;
 333     case SWIG_RuntimeError:
 334     case SWIG_TypeError:
 335     case SWIG_SyntaxError:
 336     case SWIG_SystemError:
 337     case SWIG_UnknownError:
 338     default:
 339       exception_code = SWIG_CSharpApplicationException;
 340       break;
 341     }
 342     SWIG_CSharpSetPendingException(exception_code, msg);
 343   }
 344 }
 345
 346
 347 #include <stdexcept>
 348
 349
 350 #define SWIGSTDCALL
 351
 352 #include <time.h>
 353
 354 #include <dali/dali.h>
 355 #include <dali-toolkit/dali-toolkit.h>
 356
 357 #include <dali/devel-api/actors/actor-devel.h>
 358 #include <dali/devel-api/actors/camera-actor-devel.h>
 359 #include <dali/devel-api/animation/key-frames-devel.h>
 360 #include <dali/devel-api/common/stage-devel.h>
 361 #include <dali/devel-api/events/key-event-devel.h>
 362 #include <dali/devel-api/events/wheel-event-devel.h>
 363 #include <dali/devel-api/events/hover-event-devel.h>
 364 #include <dali/devel-api/events/touch-point.h>
 365 #include <dali/devel-api/events/pan-gesture-devel.h>
 366 #include <dali/devel-api/events/pinch-gesture-devel.h>
 367 #include <dali/devel-api/events/long-press-gesture-devel.h>
 368 #include <dali/devel-api/events/tap-gesture-devel.h>
 369
 370 #include <dali/public-api/math/matrix.h>
 371 #include <dali/public-api/math/matrix3.h>
 372 #include <dali/public-api/math/viewport.h>
 373 #include <dali/public-api/object/property-key.h>
 374 #include <dali/devel-api/object/csharp-type-info.h>
 375 #include <dali/devel-api/object/csharp-type-registry.h>
 376
 377 #include <dali/public-api/adaptor-framework/timer.h>
 378 #include <dali/public-api/adaptor-framework/style-change.h>
 379 #include <dali/devel-api/adaptor-framework/environment-variable.h>
 380
 381 #include <dali-toolkit/devel-api/accessibility-manager/accessibility-manager.h>
 382
 383 #include <dali-toolkit/devel-api/builder/builder.h>
 384
 385 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 386 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 387
 388 #include <dali-toolkit/devel-api/controls/control-devel.h>
 389 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 390 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 391 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 392 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 393 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 394 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 395 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 396 #include <dali-toolkit/devel-api/controls/alignment/alignment.h>
 397 #include <dali-toolkit/devel-api/controls/scroll-bar/scroll-bar.h>
 398 #include <dali-toolkit/devel-api/controls/table-view/table-view.h>
 399
 400 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 401 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 402 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 403
 404 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 405 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 406 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 407
 408 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 409 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 410 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
 411
 412 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 413
 414 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 415 #include <dali/devel-api/adaptor-framework/image-loading.h>
 416
 417 #include <dali/public-api/events/mouse-button.h>
 418
 419 #include <dali/integration-api/debug.h>
 420
 421 #include <dali-toolkit/devel-api/controls/video-view/video-view-devel.h>
 422
 423 #include <dali/devel-api/adaptor-framework/native-image-source-devel.h>
 424 #include <dali/devel-api/adaptor-framework/window-system-devel.h>
 425
 426 #include <dali-toolkit/devel-api/text/rendering-backend.h>
 427
 428 #include <dali/devel-api/update/frame-callback-interface.h>
 429 #include <dali/devel-api/update/update-proxy.h>
 430
 431 #include <dali-toolkit/public-api/image-loader/image.h>
 432 #include <dali-toolkit/public-api/image-loader/image-url.h>
 433
 434
 435 // add here SWIG version check
 436
 437 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 438 // disable Swig-dependent warnings
 439
 440 // 'identifier1' has C-linkage specified,
 441 // but returns UDT 'identifier2' which is incompatible with C
 442 #pragma warning(disable: 4190)
 443
 444 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 445 #pragma warning(disable: 4800)
 446
 447 // debug info too long etc etc
 448 #pragma warning(disable: 4786)
 449 #endif
 450
 451
 452 #include <stdexcept>
 453
 454
 455 #include <string>
 456
 457
 458 #include <vector>
 459 #include <algorithm>
 460 #include <stdexcept>
 461
 462
 463 #include <map>
 464 #include <algorithm>
 465 #include <stdexcept>
 466
 467
 468 #include <utility>
 469
 470
 471 typedef float floatp;
 472
 473 SWIGINTERN floatp *new_floatp(){
 474   return new float();
 475 }
 476 SWIGINTERN void delete_floatp(floatp *self){
 477   if (self) delete self;
 478 }
 479 SWIGINTERN void floatp_assign(floatp *self,float value){
 480   *self = value;
 481 }
 482 SWIGINTERN float floatp_value(floatp *self){
 483   return *self;
 484 }
 485 SWIGINTERN float *floatp_cast(floatp *self){
 486   return self;
 487 }
 488 SWIGINTERN floatp *floatp_frompointer(float *t){
 489   return (floatp *) t;
 490 }
 491
 492 typedef int intp;
 493
 494 SWIGINTERN intp *new_intp(){
 495   return new int();
 496 }
 497 SWIGINTERN void delete_intp(intp *self){
 498   if (self) delete self;
 499 }
 500 SWIGINTERN void intp_assign(intp *self,int value){
 501   *self = value;
 502 }
 503 SWIGINTERN int intp_value(intp *self){
 504   return *self;
 505 }
 506 SWIGINTERN int *intp_cast(intp *self){
 507   return self;
 508 }
 509 SWIGINTERN intp *intp_frompointer(int *t){
 510   return (intp *) t;
 511 }
 512
 513 typedef double doublep;
 514
 515 SWIGINTERN doublep *new_doublep(){
 516   return new double();
 517 }
 518 SWIGINTERN void delete_doublep(doublep *self){
 519   if (self) delete self;
 520 }
 521 SWIGINTERN void doublep_assign(doublep *self,double value){
 522   *self = value;
 523 }
 524 SWIGINTERN double doublep_value(doublep *self){
 525   return *self;
 526 }
 527 SWIGINTERN double *doublep_cast(doublep *self){
 528   return self;
 529 }
 530 SWIGINTERN doublep *doublep_frompointer(double *t){
 531   return (doublep *) t;
 532 }
 533
 534 typedef unsigned int uintp;
 535
 536 SWIGINTERN uintp *new_uintp(){
 537   return new unsigned int();
 538 }
 539 SWIGINTERN void delete_uintp(uintp *self){
 540   if (self) delete self;
 541 }
 542 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 543   *self = value;
 544 }
 545 SWIGINTERN unsigned int uintp_value(uintp *self){
 546   return *self;
 547 }
 548 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 549   return self;
 550 }
 551 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 552   return (uintp *) t;
 553 }
 554
 555 typedef unsigned short ushortp;
 556
 557 SWIGINTERN ushortp *new_ushortp(){
 558   return new unsigned short();
 559 }
 560 SWIGINTERN void delete_ushortp(ushortp *self){
 561   if (self) delete self;
 562 }
 563 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 564   *self = value;
 565 }
 566 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 567   return *self;
 568 }
 569 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 570   return self;
 571 }
 572 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 573   return (ushortp *) t;
 574 }
 575
 576 unsigned int int_to_uint(int x) {
 577    return (unsigned int) x;
 578 }
 579
 580
 581 using namespace Dali;
 582 using namespace Dali::Toolkit;
 583
 584 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 585 {
 586   bool result = false;
 587   try
 588   {
 589     // C++ code. DALi uses Handle <-> Body design pattern.
 590     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 591     // Handles in DALi can be converted into a boolean type
 592     // to check if the handle has a valid body attached to it.
 593     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 594     if( *self )
 595     {
 596       result = true;
 597     }
 598     else
 599     {
 600       result = false;
 601     }
 602   }
 603   CALL_CATCH_EXCEPTION(false);
 604   return result;
 605 }
 606
 607 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 608 {
 609   bool result = false;
 610   try
 611   {
 612     // C++ code. Check if two handles reference the same implemtion
 613     if( *self == rhs)
 614     {
 615       result = true;
 616     }
 617     else
 618     {
 619       result = false;
 620     }
 621   }
 622   CALL_CATCH_EXCEPTION(false);
 623   return result;
 624 }
 625
 626
 627 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 628      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 629    }
 630 SWIGINTERN void Dali_TypeRegistration_RegisterProperty(std::string const &controlName,std::string const &propertyName,int index,Dali::Property::Type type,Dali::CSharpTypeInfo::SetPropertyFunction setFunc,Dali::CSharpTypeInfo::GetPropertyFunction getFunc){
 631      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 632    }
 633 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 634         std::vector< Dali::TouchPoint >* pv = 0;
 635         if (capacity >= 0) {
 636           pv = new std::vector< Dali::TouchPoint >();
 637           pv->reserve(capacity);
 638        } else {
 639           throw std::out_of_range("capacity");
 640        }
 641        return pv;
 642       }
 643 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 644         if (index>=0 && index<(int)self->size())
 645           return (*self)[index];
 646         else
 647           throw std::out_of_range("index");
 648       }
 649 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 650         if (index>=0 && index<(int)self->size())
 651           return (*self)[index];
 652         else
 653           throw std::out_of_range("index");
 654       }
 655 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 656         if (index>=0 && index<(int)self->size())
 657           (*self)[index] = val;
 658         else
 659           throw std::out_of_range("index");
 660       }
 661 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 662         self->insert(self->end(), values.begin(), values.end());
 663       }
 664 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 665         if (index < 0)
 666           throw std::out_of_range("index");
 667         if (count < 0)
 668           throw std::out_of_range("count");
 669         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 670           throw std::invalid_argument("invalid range");
 671         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 672       }
 673 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 674         if (index>=0 && index<(int)self->size()+1)
 675           self->insert(self->begin()+index, x);
 676         else
 677           throw std::out_of_range("index");
 678       }
 679 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 680         if (index>=0 && index<(int)self->size()+1)
 681           self->insert(self->begin()+index, values.begin(), values.end());
 682         else
 683           throw std::out_of_range("index");
 684       }
 685 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 686         if (index>=0 && index<(int)self->size())
 687           self->erase(self->begin() + index);
 688         else
 689           throw std::out_of_range("index");
 690       }
 691 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 692         if (index < 0)
 693           throw std::out_of_range("index");
 694         if (count < 0)
 695           throw std::out_of_range("count");
 696         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 697           throw std::invalid_argument("invalid range");
 698         self->erase(self->begin()+index, self->begin()+index+count);
 699       }
 700 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 701         if (count < 0)
 702           throw std::out_of_range("count");
 703         return new std::vector< Dali::TouchPoint >(count, value);
 704       }
 705 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 706         std::reverse(self->begin(), self->end());
 707       }
 708 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 709         if (index < 0)
 710           throw std::out_of_range("index");
 711         if (count < 0)
 712           throw std::out_of_range("count");
 713         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 714           throw std::invalid_argument("invalid range");
 715         std::reverse(self->begin()+index, self->begin()+index+count);
 716       }
 717 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 718         if (index < 0)
 719           throw std::out_of_range("index");
 720         if (index+values.size() > self->size())
 721           throw std::out_of_range("index");
 722         std::copy(values.begin(), values.end(), self->begin()+index);
 723       }
 724 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 725          return self->Empty();
 726       }
 727 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 728         return self->GetConnectionCount();
 729       }
 730 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 731           self->Connect( func );
 732       }
 733 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 734           self->Disconnect( func );
 735       }
 736 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 737           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 738 /*@SWIG@*/ self->Emit( arg );
 739       }
 740 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 741          return self->Empty();
 742       }
 743 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 744         return self->GetConnectionCount();
 745       }
 746 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 747           self->Connect( func );
 748       }
 749 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 750           self->Disconnect( func );
 751       }
 752 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 753           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 754 /*@SWIG@*/ self->Emit( arg );
 755       }
 756 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 757          return self->Empty();
 758       }
 759 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::RefObject const *) > const *self){
 760         return self->GetConnectionCount();
 761       }
 762 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 763           self->Connect( func );
 764       }
 765 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 766           self->Disconnect( func );
 767       }
 768 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::RefObject const *) > *self,Dali::RefObject const *arg){
 769           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 770 /*@SWIG@*/ self->Emit( arg );
 771       }
 772 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 773          return self->Empty();
 774       }
 775 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 776         return self->GetConnectionCount();
 777       }
 778 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 779           self->Connect( func );
 780       }
 781 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 782           self->Disconnect( func );
 783       }
 784 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 785           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 786 /*@SWIG@*/ self->Emit( arg );
 787       }
 788 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 789          return self->Empty();
 790       }
 791 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 792         return self->GetConnectionCount();
 793       }
 794 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 795         self->Connect( func );
 796       }
 797 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 798         self->Disconnect( func );
 799       }
 800 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,Dali::Actor arg1,Dali::LongPressGesture const &arg2){
 801         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 802 /*@SWIG@*/ self->Emit( arg1, arg2 );
 803       }
 804 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > const *self){
 805          return self->Empty();
 806       }
 807 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > const *self){
 808         return self->GetConnectionCount();
 809       }
 810 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *self,bool (*func)(Dali::Actor,Dali::TouchEvent const &)){
 811         self->Connect( func );
 812       }
 813 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *self,bool (*func)(Dali::Actor,Dali::TouchEvent const &)){
 814         self->Disconnect( func );
 815       }
 816 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *self,Dali::Actor arg1,Dali::TouchEvent const &arg2){
 817         return self->Emit( arg1, arg2 );
 818       }
 819 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 820          return self->Empty();
 821       }
 822 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 823         return self->GetConnectionCount();
 824       }
 825 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 826         self->Connect( func );
 827       }
 828 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 829         self->Disconnect( func );
 830       }
 831 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,Dali::Actor arg1,Dali::HoverEvent const &arg2){
 832         return self->Emit( arg1, arg2 );
 833       }
 834 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 835          return self->Empty();
 836       }
 837 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 838         return self->GetConnectionCount();
 839       }
 840 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 841         self->Connect( func );
 842       }
 843 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 844         self->Disconnect( func );
 845       }
 846 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,Dali::Actor arg1,Dali::WheelEvent const &arg2){
 847         return self->Emit( arg1, arg2 );
 848       }
 849 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 850          return self->Empty();
 851       }
 852 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 853         return self->GetConnectionCount();
 854       }
 855 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 856           self->Connect( func );
 857       }
 858 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 859           self->Disconnect( func );
 860       }
 861 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 862           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 863 /*@SWIG@*/ self->Emit( arg );
 864       }
 865 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 866          return self->Empty();
 867       }
 868 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 869         return self->GetConnectionCount();
 870       }
 871 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 872           self->Connect( func );
 873       }
 874 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 875           self->Disconnect( func );
 876       }
 877 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::KeyEvent const &) > *self,Dali::KeyEvent const &arg){
 878           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 879 /*@SWIG@*/ self->Emit( arg );
 880       }
 881 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchEvent const &) > const *self){
 882          return self->Empty();
 883       }
 884 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchEvent const &) > const *self){
 885         return self->GetConnectionCount();
 886       }
 887 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchEvent const &) > *self,void (*func)(Dali::TouchEvent const &)){
 888           self->Connect( func );
 889       }
 890 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchEvent const &) > *self,void (*func)(Dali::TouchEvent const &)){
 891           self->Disconnect( func );
 892       }
 893 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchEvent const &) > *self,Dali::TouchEvent const &arg){
 894           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 895 /*@SWIG@*/ self->Emit( arg );
 896       }
 897 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 898          return self->Empty();
 899       }
 900 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 901         return self->GetConnectionCount();
 902       }
 903 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
 904           self->Connect( func );
 905       }
 906 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
 907           self->Disconnect( func );
 908       }
 909 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::WheelEvent const &) > *self,Dali::WheelEvent const &arg){
 910           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 911 /*@SWIG@*/ self->Emit( arg );
 912       }
 913 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
 914          return self->Empty();
 915       }
 916 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
 917         return self->GetConnectionCount();
 918       }
 919 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
 920         self->Connect( func );
 921       }
 922 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
 923         self->Disconnect( func );
 924       }
 925 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,Dali::Actor arg1,Dali::PanGesture const &arg2){
 926         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 927 /*@SWIG@*/ self->Emit( arg1, arg2 );
 928       }
 929 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
 930          return self->Empty();
 931       }
 932 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
 933         return self->GetConnectionCount();
 934       }
 935 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
 936         self->Connect( func );
 937       }
 938 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
 939         self->Disconnect( func );
 940       }
 941 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,Dali::Actor arg1,Dali::PinchGesture const &arg2){
 942         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 943 /*@SWIG@*/ self->Emit( arg1, arg2 );
 944       }
 945 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
 946          return self->Empty();
 947       }
 948 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
 949         return self->GetConnectionCount();
 950       }
 951 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
 952         self->Connect( func );
 953       }
 954 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
 955         self->Disconnect( func );
 956       }
 957 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,Dali::Actor arg1,Dali::TapGesture const &arg2){
 958         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 959 /*@SWIG@*/ self->Emit( arg1, arg2 );
 960       }
 961 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
 962          return self->Empty();
 963       }
 964 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
 965         return self->GetConnectionCount();
 966       }
 967 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
 968           return self->Connect( func );
 969       }
 970 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
 971           self->Disconnect( func );
 972       }
 973 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,Dali::Actor arg1, Dali::LayoutDirection::Type arg3){
 974           self->Emit( arg1, arg3 );
 975       }
 976 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
 977          return self->Empty();
 978       }
 979 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
 980         return self->GetConnectionCount();
 981       }
 982 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
 983           return self->Connect( func );
 984       }
 985 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
 986           self->Disconnect( func );
 987       }
 988 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,Dali::Actor arg1,bool arg2,Dali::DevelActor::VisibilityChange::Type arg3){
 989           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 990 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
 991       }
 992
 993 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
 994          return self->Empty();
 995       }
 996 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
 997         return self->GetConnectionCount();
 998       }
 999 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1000           self->Connect( func );
1001       }
1002 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1003           self->Disconnect( func );
1004       }
1005 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1006           return self->Emit();
1007       }
1008
1009 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1010         std::vector< unsigned int >* pv = 0;
1011         if (capacity >= 0) {
1012           pv = new std::vector< unsigned int >();
1013           pv->reserve(capacity);
1014        } else {
1015           throw std::out_of_range("capacity");
1016        }
1017        return pv;
1018       }
1019 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1020         if (index>=0 && index<(int)self->size())
1021           return (*self)[index];
1022         else
1023           throw std::out_of_range("index");
1024       }
1025 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1026         if (index>=0 && index<(int)self->size())
1027           return (*self)[index];
1028         else
1029           throw std::out_of_range("index");
1030       }
1031 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1032         if (index>=0 && index<(int)self->size())
1033           (*self)[index] = val;
1034         else
1035           throw std::out_of_range("index");
1036       }
1037 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1038         self->insert(self->end(), values.begin(), values.end());
1039       }
1040 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1041         if (index < 0)
1042           throw std::out_of_range("index");
1043         if (count < 0)
1044           throw std::out_of_range("count");
1045         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1046           throw std::invalid_argument("invalid range");
1047         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1048       }
1049 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1050         if (index>=0 && index<(int)self->size()+1)
1051           self->insert(self->begin()+index, x);
1052         else
1053           throw std::out_of_range("index");
1054       }
1055 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1056         if (index>=0 && index<(int)self->size()+1)
1057           self->insert(self->begin()+index, values.begin(), values.end());
1058         else
1059           throw std::out_of_range("index");
1060       }
1061 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1062         if (index>=0 && index<(int)self->size())
1063           self->erase(self->begin() + index);
1064         else
1065           throw std::out_of_range("index");
1066       }
1067 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1068         if (index < 0)
1069           throw std::out_of_range("index");
1070         if (count < 0)
1071           throw std::out_of_range("count");
1072         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1073           throw std::invalid_argument("invalid range");
1074         self->erase(self->begin()+index, self->begin()+index+count);
1075       }
1076 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1077         if (count < 0)
1078           throw std::out_of_range("count");
1079         return new std::vector< unsigned int >(count, value);
1080       }
1081 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1082         std::reverse(self->begin(), self->end());
1083       }
1084 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1085         if (index < 0)
1086           throw std::out_of_range("index");
1087         if (count < 0)
1088           throw std::out_of_range("count");
1089         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1090           throw std::invalid_argument("invalid range");
1091         std::reverse(self->begin()+index, self->begin()+index+count);
1092       }
1093 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1094         if (index < 0)
1095           throw std::out_of_range("index");
1096         if (index+values.size() > self->size())
1097           throw std::out_of_range("index");
1098         std::copy(values.begin(), values.end(), self->begin()+index);
1099       }
1100 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1101         return std::find(self->begin(), self->end(), value) != self->end();
1102       }
1103 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1104         int index = -1;
1105         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1106         if (it != self->end())
1107           index = (int)(it - self->begin());
1108         return index;
1109       }
1110 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1111         int index = -1;
1112         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1113         if (rit != self->rend())
1114           index = (int)(self->rend() - 1 - rit);
1115         return index;
1116       }
1117 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1118         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1119         if (it != self->end()) {
1120           self->erase(it);
1121           return true;
1122         }
1123         return false;
1124       }
1125 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *new_std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg___SWIG_2(int capacity){
1126         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1127         if (capacity >= 0) {
1128           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1129           pv->reserve(capacity);
1130        } else {
1131           throw std::out_of_range("capacity");
1132        }
1133        return pv;
1134       }
1135 SWIGINTERN std::pair< unsigned int,Dali::Actor > std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1136         if (index>=0 && index<(int)self->size())
1137           return (*self)[index];
1138         else
1139           throw std::out_of_range("index");
1140       }
1141 SWIGINTERN std::pair< unsigned int,Dali::Actor > const &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1142         if (index>=0 && index<(int)self->size())
1143           return (*self)[index];
1144         else
1145           throw std::out_of_range("index");
1146       }
1147 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &val){
1148         if (index>=0 && index<(int)self->size())
1149           (*self)[index] = val;
1150         else
1151           throw std::out_of_range("index");
1152       }
1153 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1154         self->insert(self->end(), values.begin(), values.end());
1155       }
1156 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__GetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1157         if (index < 0)
1158           throw std::out_of_range("index");
1159         if (count < 0)
1160           throw std::out_of_range("count");
1161         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1162           throw std::invalid_argument("invalid range");
1163         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1164       }
1165 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Insert(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &x){
1166         if (index>=0 && index<(int)self->size()+1)
1167           self->insert(self->begin()+index, x);
1168         else
1169           throw std::out_of_range("index");
1170       }
1171 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__InsertRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1172         if (index>=0 && index<(int)self->size()+1)
1173           self->insert(self->begin()+index, values.begin(), values.end());
1174         else
1175           throw std::out_of_range("index");
1176       }
1177 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1178         if (index>=0 && index<(int)self->size())
1179           self->erase(self->begin() + index);
1180         else
1181           throw std::out_of_range("index");
1182       }
1183 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1184         if (index < 0)
1185           throw std::out_of_range("index");
1186         if (count < 0)
1187           throw std::out_of_range("count");
1188         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1189           throw std::invalid_argument("invalid range");
1190         self->erase(self->begin()+index, self->begin()+index+count);
1191       }
1192 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Repeat(std::pair< unsigned int,Dali::Actor > const &value,int count){
1193         if (count < 0)
1194           throw std::out_of_range("count");
1195         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1196       }
1197 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(std::vector< std::pair< unsigned int,Dali::Actor > > *self){
1198         std::reverse(self->begin(), self->end());
1199       }
1200 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1201         if (index < 0)
1202           throw std::out_of_range("index");
1203         if (count < 0)
1204           throw std::out_of_range("count");
1205         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1206           throw std::invalid_argument("invalid range");
1207         std::reverse(self->begin()+index, self->begin()+index+count);
1208       }
1209 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__SetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1210         if (index < 0)
1211           throw std::out_of_range("index");
1212         if (index+values.size() > self->size())
1213           throw std::out_of_range("index");
1214         std::copy(values.begin(), values.end(), self->begin()+index);
1215       }
1216 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1217         std::vector< Dali::Actor >* pv = 0;
1218         if (capacity >= 0) {
1219           pv = new std::vector< Dali::Actor >();
1220           pv->reserve(capacity);
1221        } else {
1222           throw std::out_of_range("capacity");
1223        }
1224        return pv;
1225       }
1226 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1227         if (index>=0 && index<(int)self->size())
1228           return (*self)[index];
1229         else
1230           throw std::out_of_range("index");
1231       }
1232 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1233         if (index>=0 && index<(int)self->size())
1234           return (*self)[index];
1235         else
1236           throw std::out_of_range("index");
1237       }
1238 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1239         if (index>=0 && index<(int)self->size())
1240           (*self)[index] = val;
1241         else
1242           throw std::out_of_range("index");
1243       }
1244 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1245         self->insert(self->end(), values.begin(), values.end());
1246       }
1247 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1248         if (index < 0)
1249           throw std::out_of_range("index");
1250         if (count < 0)
1251           throw std::out_of_range("count");
1252         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1253           throw std::invalid_argument("invalid range");
1254         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1255       }
1256 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1257         if (index>=0 && index<(int)self->size()+1)
1258           self->insert(self->begin()+index, x);
1259         else
1260           throw std::out_of_range("index");
1261       }
1262 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1263         if (index>=0 && index<(int)self->size()+1)
1264           self->insert(self->begin()+index, values.begin(), values.end());
1265         else
1266           throw std::out_of_range("index");
1267       }
1268 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1269         if (index>=0 && index<(int)self->size())
1270           self->erase(self->begin() + index);
1271         else
1272           throw std::out_of_range("index");
1273       }
1274 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1275         if (index < 0)
1276           throw std::out_of_range("index");
1277         if (count < 0)
1278           throw std::out_of_range("count");
1279         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1280           throw std::invalid_argument("invalid range");
1281         self->erase(self->begin()+index, self->begin()+index+count);
1282       }
1283 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1284         if (count < 0)
1285           throw std::out_of_range("count");
1286         return new std::vector< Dali::Actor >(count, value);
1287       }
1288 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1289         std::reverse(self->begin(), self->end());
1290       }
1291 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1292         if (index < 0)
1293           throw std::out_of_range("index");
1294         if (count < 0)
1295           throw std::out_of_range("count");
1296         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1297           throw std::invalid_argument("invalid range");
1298         std::reverse(self->begin()+index, self->begin()+index+count);
1299       }
1300 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1301         if (index < 0)
1302           throw std::out_of_range("index");
1303         if (index+values.size() > self->size())
1304           throw std::out_of_range("index");
1305         std::copy(values.begin(), values.end(), self->begin()+index);
1306       }
1307 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1308          return self->Empty();
1309       }
1310 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1311         return self->GetConnectionCount();
1312       }
1313 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1314           self->Connect( func );
1315       }
1316 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1317           self->Disconnect( func );
1318       }
1319 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,Dali::Toolkit::AccessibilityManager &arg){
1320           return self->Emit( arg );
1321       }
1322 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1323          return self->Empty();
1324       }
1325 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1326         return self->GetConnectionCount();
1327       }
1328 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1329         self->Connect( func );
1330       }
1331 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1332         self->Disconnect( func );
1333       }
1334 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,Dali::Actor arg1,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg2){
1335         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1336 /*@SWIG@*/ self->Emit( arg1, arg2 );
1337       }
1338 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1339          return self->Empty();
1340       }
1341 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1342         return self->GetConnectionCount();
1343       }
1344 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1345         self->Connect( func );
1346       }
1347 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1348         self->Disconnect( func );
1349       }
1350 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,Dali::Actor arg1,Dali::Actor arg2){
1351         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1352 /*@SWIG@*/ self->Emit( arg1, arg2 );
1353       }
1354 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1355          return self->Empty();
1356       }
1357 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1358         return self->GetConnectionCount();
1359       }
1360 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1361         self->Connect( func );
1362       }
1363 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1364         self->Disconnect( func );
1365       }
1366 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool) > *self,Dali::Actor arg1,bool arg2){
1367         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1368 /*@SWIG@*/ self->Emit( arg1, arg2 );
1369       }
1370 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1371          return self->Empty();
1372       }
1373 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1374         return self->GetConnectionCount();
1375       }
1376 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1377         self->Connect( func );
1378       }
1379 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1380         self->Disconnect( func );
1381       }
1382 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,Dali::Toolkit::StyleManager arg1,Dali::StyleChange::Type arg2){
1383         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1384 /*@SWIG@*/ self->Emit( arg1, arg2 );
1385       }
1386 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1387          return self->Empty();
1388       }
1389 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1390         return self->GetConnectionCount();
1391       }
1392 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1393           self->Connect( func );
1394       }
1395 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1396           self->Disconnect( func );
1397       }
1398 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1399           return self->Emit( arg );
1400       }
1401 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1402          return self->Empty();
1403       }
1404 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1405         return self->GetConnectionCount();
1406       }
1407 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1408           self->Connect( func );
1409       }
1410 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1411           self->Disconnect( func );
1412       }
1413 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1414           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1415 /*@SWIG@*/ self->Emit( arg );
1416       }
1417 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1418          return self->Empty();
1419       }
1420 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1421         return self->GetConnectionCount();
1422       }
1423 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1424           return self->Connect( func );
1425       }
1426 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1427           self->Disconnect( func );
1428       }
1429 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,Dali::Toolkit::PageTurnView arg1,unsigned int arg2,bool arg3){
1430           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1431 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1432       }
1433 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1434          return self->Empty();
1435       }
1436 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1437         return self->GetConnectionCount();
1438       }
1439 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1440           self->Connect( func );
1441       }
1442 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1443           self->Disconnect( func );
1444       }
1445 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1446           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1447 /*@SWIG@*/ self->Emit( arg );
1448       }
1449 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1450          return self->Empty();
1451       }
1452 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1453         return self->GetConnectionCount();
1454       }
1455 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1456           return self->Connect( func );
1457       }
1458 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1459           self->Disconnect( func );
1460       }
1461 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,Dali::Toolkit::ProgressBar arg1,float arg2,float arg3){
1462           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1463 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1464       }
1465 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1466          return self->Empty();
1467       }
1468 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1469         return self->GetConnectionCount();
1470       }
1471 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1472           self->Connect( func );
1473       }
1474 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1475           self->Disconnect( func );
1476       }
1477 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,Dali::Toolkit::ScrollView::SnapEvent const &arg){
1478           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1479 /*@SWIG@*/ self->Emit( arg );
1480       }
1481 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1482          return self->Empty();
1483       }
1484 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1485         return self->GetConnectionCount();
1486       }
1487 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1488           self->Connect( func );
1489       }
1490 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1491           self->Disconnect( func );
1492       }
1493 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Vector2 const &) > *self,Dali::Vector2 const &arg){
1494           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1495 /*@SWIG@*/ self->Emit( arg );
1496       }
1497
1498
1499 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1500          return self->Empty();
1501       }
1502 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1503         return self->GetConnectionCount();
1504       }
1505 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1506         self->Connect( func );
1507       }
1508 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1509         self->Disconnect( func );
1510       }
1511 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,Dali::Toolkit::Control arg1,Dali::KeyEvent const &arg2){
1512         return self->Emit( arg1, arg2 );
1513       }
1514 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1515          return self->Empty();
1516       }
1517 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1518         return self->GetConnectionCount();
1519       }
1520 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1521           self->Connect( func );
1522       }
1523 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1524           self->Disconnect( func );
1525       }
1526 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1527           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1528 /*@SWIG@*/ self->Emit( arg );
1529       }
1530 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1531          return self->Empty();
1532       }
1533 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1534         return self->GetConnectionCount();
1535       }
1536 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1537           self->Connect( func );
1538       }
1539 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1540           self->Disconnect( func );
1541       }
1542 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,Dali::Toolkit::VideoView &arg){
1543           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1544 /*@SWIG@*/ self->Emit( arg );
1545       }
1546 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1547          return self->Empty();
1548       }
1549 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1550         return self->GetConnectionCount();
1551       }
1552 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1553         self->Connect( func );
1554       }
1555 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1556         self->Disconnect( func );
1557       }
1558 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,Dali::Toolkit::Slider arg1,float arg2){
1559         return self->Emit( arg1, arg2 );
1560       }
1561 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1562          return self->Empty();
1563       }
1564 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1565         return self->GetConnectionCount();
1566       }
1567 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1568         self->Connect( func );
1569       }
1570 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1571         self->Disconnect( func );
1572       }
1573 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,Dali::Toolkit::Slider arg1,int arg2){
1574         return self->Emit( arg1, arg2 );
1575       }
1576
1577 /* ---------------------------------------------------
1578  * C++ director class methods
1579  * --------------------------------------------------- */
1580
1581 #include "dali-wrap.h"
1582
1583 /*
1584  *  Widget director
1585  */
1586 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1587   swig_init_callbacks();
1588 }
1589
1590 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1591 }
1592
1593 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1594   char * jcontentInfo = 0 ;
1595   void * jwindow  ;
1596
1597   if (!swig_callbackOnCreate) {
1598     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1599     return;
1600   } else {
1601     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1602     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1603     swig_callbackOnCreate(jcontentInfo, jwindow);
1604   }
1605 }
1606
1607 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1608   char * jcontentInfo = 0 ;
1609   int jtype  ;
1610
1611   if (!swig_callbackOnTerminate) {
1612     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1613     return;
1614   } else {
1615     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1616     jtype = (int)type;
1617     swig_callbackOnTerminate(jcontentInfo, jtype);
1618   }
1619 }
1620
1621 void SwigDirector_WidgetImpl::OnPause() {
1622   if (!swig_callbackOnPause) {
1623     Dali::Internal::Adaptor::Widget::OnPause();
1624     return;
1625   } else {
1626     swig_callbackOnPause();
1627   }
1628 }
1629
1630 void SwigDirector_WidgetImpl::OnResume() {
1631   if (!swig_callbackOnResume) {
1632     Dali::Internal::Adaptor::Widget::OnResume();
1633     return;
1634   } else {
1635     swig_callbackOnResume();
1636   }
1637 }
1638
1639 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1640   void * jwindow  ;
1641
1642   if (!swig_callbackOnResize) {
1643     Dali::Internal::Adaptor::Widget::OnResize(window);
1644     return;
1645   } else {
1646     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1647     swig_callbackOnResize(jwindow);
1648   }
1649 }
1650
1651 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1652   char * jcontentInfo = 0 ;
1653   int jforce  ;
1654
1655   if (!swig_callbackOnUpdate) {
1656     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1657     return;
1658   } else {
1659     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1660     jforce = force;
1661     swig_callbackOnUpdate(jcontentInfo, jforce);
1662   }
1663 }
1664
1665 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1666   void * jslotObserver = 0 ;
1667   void * jcallback = 0 ;
1668
1669   if (!swig_callbackSignalConnected) {
1670     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1671     return;
1672   } else {
1673     jslotObserver = (void *) slotObserver;
1674     jcallback = (void *) callback;
1675     swig_callbackSignalConnected(jslotObserver, jcallback);
1676   }
1677 }
1678
1679 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1680   void * jslotObserver = 0 ;
1681   void * jcallback = 0 ;
1682
1683   if (!swig_callbackSignalDisconnected) {
1684     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1685     return;
1686   } else {
1687     jslotObserver = (void *) slotObserver;
1688     jcallback = (void *) callback;
1689     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1690   }
1691 }
1692
1693 void SwigDirector_WidgetImpl::swig_connect_director(SWIG_Callback0_t callbackOnCreate, SWIG_Callback1_t callbackOnTerminate, SWIG_Callback2_t callbackOnPause, SWIG_Callback3_t callbackOnResume, SWIG_Callback4_t callbackOnResize, SWIG_Callback5_t callbackOnUpdate, SWIG_Callback6_t callbackSignalConnected, SWIG_Callback7_t callbackSignalDisconnected) {
1694
1695   swig_callbackOnCreate = callbackOnCreate;
1696   swig_callbackOnTerminate = callbackOnTerminate;
1697   swig_callbackOnPause = callbackOnPause;
1698   swig_callbackOnResume = callbackOnResume;
1699   swig_callbackOnResize = callbackOnResize;
1700   swig_callbackOnUpdate = callbackOnUpdate;
1701   swig_callbackSignalConnected = callbackSignalConnected;
1702   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1703 }
1704
1705 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1706   swig_callbackOnCreate = 0;
1707   swig_callbackOnTerminate = 0;
1708   swig_callbackOnPause = 0;
1709   swig_callbackOnResume = 0;
1710   swig_callbackOnResize = 0;
1711   swig_callbackOnUpdate = 0;
1712   swig_callbackSignalConnected = 0;
1713   swig_callbackSignalDisconnected = 0;
1714 }
1715
1716
1717 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1718   swig_init_callbacks();
1719 }
1720
1721 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1722
1723 }
1724
1725
1726 void SwigDirector_ViewImpl::OnSceneConnection(int depth) {
1727   int jdepth  ;
1728
1729   if (!swig_callbackOnSceneConnection) {
1730     Dali::Toolkit::Internal::Control::OnSceneConnection(depth);
1731     return;
1732   } else {
1733     jdepth = depth;
1734     swig_callbackOnSceneConnection(jdepth);
1735   }
1736 }
1737
1738 void SwigDirector_ViewImpl::OnSceneDisconnection() {
1739   if (!swig_callbackOnSceneDisconnection) {
1740     Dali::Toolkit::Internal::Control::OnSceneDisconnection();
1741     return;
1742   } else {
1743     swig_callbackOnSceneDisconnection();
1744   }
1745 }
1746
1747 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1748   void * jchild = 0 ;
1749
1750   if (!swig_callbackOnChildAdd) {
1751     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1752     return;
1753   } else {
1754     jchild = (Dali::Actor *) &child;
1755     swig_callbackOnChildAdd(jchild);
1756   }
1757 }
1758
1759 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1760   void * jchild = 0 ;
1761
1762   if (!swig_callbackOnChildRemove) {
1763     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1764     return;
1765   } else {
1766     jchild = (Dali::Actor *) &child;
1767     swig_callbackOnChildRemove(jchild);
1768   }
1769 }
1770
1771 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, const Dali::Property::Value& propertyValue) {
1772   int jindex  ;
1773   void * jpropertyValue  ;
1774
1775   if (!swig_callbackOnPropertySet) {
1776     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1777     return;
1778   } else {
1779     jindex = index;
1780     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1781     swig_callbackOnPropertySet(jindex, jpropertyValue);
1782   }
1783 }
1784
1785 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1786   void * jtargetSize = 0 ;
1787
1788   if (!swig_callbackOnSizeSet) {
1789     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1790     return;
1791   } else {
1792     jtargetSize = (Dali::Vector3 *) &targetSize;
1793     swig_callbackOnSizeSet(jtargetSize);
1794   }
1795 }
1796
1797 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1798   void * janimation = 0 ;
1799   void * jtargetSize = 0 ;
1800
1801   if (!swig_callbackOnSizeAnimation) {
1802     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1803     return;
1804   } else {
1805     janimation = (Dali::Animation *) &animation;
1806     jtargetSize = (Dali::Vector3 *) &targetSize;
1807     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1808   }
1809 }
1810
1811 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1812   bool c_result = SwigValueInit< bool >() ;
1813   unsigned int jresult = 0 ;
1814   void * jarg0 = 0 ;
1815
1816   if (!swig_callbackOnKeyEvent) {
1817     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1818   } else {
1819     jarg0 = (Dali::KeyEvent *) &event;
1820     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1821     c_result = jresult ? true : false;
1822   }
1823   return c_result;
1824 }
1825
1826 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1827   void * jsize = 0 ;
1828   void * jcontainer = 0 ;
1829
1830   if (!swig_callbackOnRelayout) {
1831     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1832     return;
1833   } else {
1834     jsize = (Dali::Vector2 *) &size;
1835     jcontainer = (Dali::RelayoutContainer *) &container;
1836     swig_callbackOnRelayout(jsize, jcontainer);
1837   }
1838 }
1839
1840 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1841   int jpolicy  ;
1842   int jdimension  ;
1843
1844   if (!swig_callbackOnSetResizePolicy) {
1845     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1846     return;
1847   } else {
1848     jpolicy = (int)policy;
1849     jdimension = (int)dimension;
1850     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1851   }
1852 }
1853
1854 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1855   Dali::Vector3 c_result ;
1856   void * jresult = 0 ;
1857
1858   if (!swig_callbackGetNaturalSize) {
1859     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1860   } else {
1861     jresult = (void *) swig_callbackGetNaturalSize();
1862     if (!jresult) {
1863       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1864       return c_result;
1865     }
1866     c_result = *(Dali::Vector3 *)jresult;
1867   }
1868   return c_result;
1869 }
1870
1871 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1872   float c_result = SwigValueInit< float >() ;
1873   float jresult = 0 ;
1874   void * jchild = 0 ;
1875   int jdimension  ;
1876
1877   if (!swig_callbackCalculateChildSize) {
1878     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1879   } else {
1880     jchild = (Dali::Actor *) &child;
1881     jdimension = (int)dimension;
1882     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1883     c_result = (float)jresult;
1884   }
1885   return c_result;
1886 }
1887
1888 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1889   float c_result = SwigValueInit< float >() ;
1890   float jresult = 0 ;
1891   float jwidth  ;
1892
1893   if (!swig_callbackGetHeightForWidth) {
1894     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1895   } else {
1896     jwidth = width;
1897     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1898     c_result = (float)jresult;
1899   }
1900   return c_result;
1901 }
1902
1903 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1904   float c_result = SwigValueInit< float >() ;
1905   float jresult = 0 ;
1906   float jheight  ;
1907
1908   if (!swig_callbackGetWidthForHeight) {
1909     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1910   } else {
1911     jheight = height;
1912     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1913     c_result = (float)jresult;
1914   }
1915   return c_result;
1916 }
1917
1918 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1919   bool c_result = SwigValueInit< bool >() ;
1920   unsigned int jresult = 0 ;
1921   int jdimension  ;
1922
1923   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1924     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1925   } else {
1926     jdimension = (int)dimension;
1927     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1928     c_result = jresult ? true : false;
1929   }
1930   return c_result;
1931 }
1932
1933 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1934   int jdimension  ;
1935
1936   if (!swig_callbackOnCalculateRelayoutSize) {
1937     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1938     return;
1939   } else {
1940     jdimension = (int)dimension;
1941     swig_callbackOnCalculateRelayoutSize(jdimension);
1942   }
1943 }
1944
1945 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1946   float jsize  ;
1947   int jdimension  ;
1948
1949   if (!swig_callbackOnLayoutNegotiated) {
1950     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
1951     return;
1952   } else {
1953     jsize = size;
1954     jdimension = (int)dimension;
1955     swig_callbackOnLayoutNegotiated(jsize, jdimension);
1956   }
1957 }
1958
1959 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
1960   return Dali::CustomActorImpl::GetExtension();
1961 }
1962
1963 void SwigDirector_ViewImpl::OnInitialize() {
1964   if (!swig_callbackOnInitialize) {
1965     Dali::Toolkit::Internal::Control::OnInitialize();
1966     return;
1967   } else {
1968     swig_callbackOnInitialize();
1969   }
1970 }
1971
1972 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
1973   void * jstyleManager  ;
1974   int jchange  ;
1975
1976   if (!swig_callbackOnStyleChange) {
1977     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
1978     return;
1979   } else {
1980     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
1981     jchange = (int)change;
1982     swig_callbackOnStyleChange(jstyleManager, jchange);
1983   }
1984 }
1985
1986 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
1987   bool c_result = SwigValueInit< bool >() ;
1988   unsigned int jresult = 0 ;
1989
1990   if (!swig_callbackOnAccessibilityActivated) {
1991     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
1992   } else {
1993     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
1994     c_result = jresult ? true : false;
1995   }
1996   return c_result;
1997 }
1998
1999 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2000   bool c_result = SwigValueInit< bool >() ;
2001   unsigned int jresult = 0 ;
2002   void * jgesture  ;
2003
2004   if (!swig_callbackOnAccessibilityPan) {
2005     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2006   } else {
2007     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2008     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2009     c_result = jresult ? true : false;
2010   }
2011   return c_result;
2012 }
2013
2014 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2015   bool c_result = SwigValueInit< bool >() ;
2016   unsigned int jresult = 0 ;
2017   unsigned int jisIncrease  ;
2018
2019   if (!swig_callbackOnAccessibilityValueChange) {
2020     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2021   } else {
2022     jisIncrease = isIncrease;
2023     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2024     c_result = jresult ? true : false;
2025   }
2026   return c_result;
2027 }
2028
2029 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2030   bool c_result = SwigValueInit< bool >() ;
2031   unsigned int jresult = 0 ;
2032
2033   if (!swig_callbackOnAccessibilityZoom) {
2034     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2035   } else {
2036     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2037     c_result = jresult ? true : false;
2038   }
2039   return c_result;
2040 }
2041
2042 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2043   if (!swig_callbackOnKeyInputFocusGained) {
2044     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2045     return;
2046   } else {
2047     swig_callbackOnKeyInputFocusGained();
2048   }
2049 }
2050
2051 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2052   if (!swig_callbackOnKeyInputFocusLost) {
2053     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2054     return;
2055   } else {
2056     swig_callbackOnKeyInputFocusLost();
2057   }
2058 }
2059
2060
2061 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled)
2062 {
2063   Dali::Actor c_result;
2064   void* jresult = 0;
2065
2066   if(!swig_callbackGetNextKeyboardFocusableActor)
2067   {
2068     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2069   }
2070   else
2071   {
2072     jresult = (void*)swig_callbackGetNextKeyboardFocusableActor((void*)(&currentFocusedActor), (int)direction, loopEnabled);
2073
2074     if(!jresult)
2075     {
2076       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2077       return c_result;
2078     }
2079     c_result = *(Dali::Actor*)jresult;
2080   }
2081   return c_result;
2082 }
2083
2084 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor)
2085 {
2086   if(!swig_callbackOnKeyboardFocusChangeCommitted)
2087   {
2088     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2089     return;
2090   }
2091   else
2092   {
2093     swig_callbackOnKeyboardFocusChangeCommitted((void*)(&commitedFocusableActor));
2094   }
2095 }
2096
2097 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2098   bool c_result = SwigValueInit< bool >() ;
2099   unsigned int jresult = 0 ;
2100
2101   if (!swig_callbackOnKeyboardEnter) {
2102     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2103   } else {
2104     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2105     c_result = jresult ? true : false;
2106   }
2107   return c_result;
2108 }
2109
2110 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2111   void * jpinch = 0 ;
2112
2113   if (!swig_callbackOnPinch) {
2114     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2115     return;
2116   } else {
2117     jpinch = (Dali::PinchGesture *) &pinch;
2118     swig_callbackOnPinch(jpinch);
2119   }
2120 }
2121
2122 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2123   void * jpan = 0 ;
2124
2125   if (!swig_callbackOnPan) {
2126     Dali::Toolkit::Internal::Control::OnPan(pan);
2127     return;
2128   } else {
2129     jpan = (Dali::PanGesture *) &pan;
2130     swig_callbackOnPan(jpan);
2131   }
2132 }
2133
2134 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2135   void * jtap = 0 ;
2136
2137   if (!swig_callbackOnTap) {
2138     Dali::Toolkit::Internal::Control::OnTap(tap);
2139     return;
2140   } else {
2141     jtap = (Dali::TapGesture *) &tap;
2142     swig_callbackOnTap(jtap);
2143   }
2144 }
2145
2146 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2147   void * jlongPress = 0 ;
2148
2149   if (!swig_callbackOnLongPress) {
2150     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2151     return;
2152   } else {
2153     jlongPress = (Dali::LongPressGesture *) &longPress;
2154     swig_callbackOnLongPress(jlongPress);
2155   }
2156 }
2157
2158 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2159   void * jslotObserver = 0 ;
2160   void * jcallback = 0 ;
2161
2162   if (!swig_callbackSignalConnected) {
2163     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2164     return;
2165   } else {
2166     jslotObserver = (void *) slotObserver;
2167     jcallback = (void *) callback;
2168     swig_callbackSignalConnected(jslotObserver, jcallback);
2169   }
2170 }
2171
2172 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2173   void * jslotObserver = 0 ;
2174   void * jcallback = 0 ;
2175
2176   if (!swig_callbackSignalDisconnected) {
2177     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2178     return;
2179   } else {
2180     jslotObserver = (void *) slotObserver;
2181     jcallback = (void *) callback;
2182     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2183   }
2184 }
2185
2186 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2187   return Dali::Toolkit::Internal::Control::GetControlExtension();
2188 }
2189
2190 void SwigDirector_ViewImpl::swig_connect_director(SWIG_Callback0_t callbackOnSceneConnection, SWIG_Callback1_t callbackOnSceneDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected) {
2191   swig_callbackOnSceneConnection = callbackOnSceneConnection;
2192   swig_callbackOnSceneDisconnection = callbackOnSceneDisconnection;
2193   swig_callbackOnChildAdd = callbackOnChildAdd;
2194   swig_callbackOnChildRemove = callbackOnChildRemove;
2195   swig_callbackOnPropertySet = callbackOnPropertySet;
2196   swig_callbackOnSizeSet = callbackOnSizeSet;
2197   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2198   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2199   swig_callbackOnRelayout = callbackOnRelayout;
2200   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2201   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2202   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2203   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2204   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2205   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2206   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2207   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2208   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2209   swig_callbackOnInitialize = callbackOnInitialize;
2210   swig_callbackOnStyleChange = callbackOnStyleChange;
2211   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2212   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2213   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2214   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2215   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2216   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2217   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2218   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2219   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2220   swig_callbackOnPinch = callbackOnPinch;
2221   swig_callbackOnPan = callbackOnPan;
2222   swig_callbackOnTap = callbackOnTap;
2223   swig_callbackOnLongPress = callbackOnLongPress;
2224   swig_callbackSignalConnected = callbackSignalConnected;
2225   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2226 }
2227
2228 void SwigDirector_ViewImpl::swig_init_callbacks() {
2229   swig_callbackOnSceneConnection = 0;
2230   swig_callbackOnSceneDisconnection = 0;
2231   swig_callbackOnChildAdd = 0;
2232   swig_callbackOnChildRemove = 0;
2233   swig_callbackOnPropertySet = 0;
2234   swig_callbackOnSizeSet = 0;
2235   swig_callbackOnSizeAnimation = 0;
2236   swig_callbackOnKeyEvent = 0;
2237   swig_callbackOnRelayout = 0;
2238   swig_callbackOnSetResizePolicy = 0;
2239   swig_callbackGetNaturalSize = 0;
2240   swig_callbackCalculateChildSize = 0;
2241   swig_callbackGetHeightForWidth = 0;
2242   swig_callbackGetWidthForHeight = 0;
2243   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2244   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2245   swig_callbackOnCalculateRelayoutSize = 0;
2246   swig_callbackOnLayoutNegotiated = 0;
2247   swig_callbackOnInitialize = 0;
2248   swig_callbackOnStyleChange = 0;
2249   swig_callbackOnAccessibilityActivated = 0;
2250   swig_callbackOnAccessibilityPan = 0;
2251   swig_callbackOnAccessibilityValueChange = 0;
2252   swig_callbackOnAccessibilityZoom = 0;
2253   swig_callbackOnKeyInputFocusGained = 0;
2254   swig_callbackOnKeyInputFocusLost = 0;
2255   swig_callbackGetNextKeyboardFocusableActor = 0;
2256   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2257   swig_callbackOnKeyboardEnter = 0;
2258   swig_callbackOnPinch = 0;
2259   swig_callbackOnPan = 0;
2260   swig_callbackOnTap = 0;
2261   swig_callbackOnLongPress = 0;
2262   swig_callbackSignalConnected = 0;
2263   swig_callbackSignalDisconnected = 0;
2264 }
2265
2266 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2267   swig_init_callbacks();
2268 }
2269
2270 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2271
2272 }
2273
2274
2275 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2276   unsigned int c_result = SwigValueInit< unsigned int >() ;
2277   unsigned int jresult = 0 ;
2278
2279   if (!swig_callbackGetNumberOfItems) {
2280     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2281   } else {
2282     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2283     c_result = (unsigned int)jresult;
2284   }
2285   return c_result;
2286 }
2287
2288 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2289   Dali::Actor c_result ;
2290   void * jresult = 0 ;
2291   unsigned int jitemId  ;
2292
2293   if (!swig_callbackNewItem) {
2294     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2295   } else {
2296     jitemId = itemId;
2297     jresult = (void *) swig_callbackNewItem(jitemId);
2298     if (!jresult) {
2299       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2300       return c_result;
2301     }
2302     c_result = *(Dali::Actor *)jresult;
2303   }
2304   return c_result;
2305 }
2306
2307 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor)
2308 {
2309   if(!swig_callbackItemReleased)
2310   {
2311     Dali::Toolkit::ItemFactory::ItemReleased(itemId, actor);
2312     return;
2313   }
2314   else
2315   {
2316     swig_callbackItemReleased(itemId, (void*)(&actor));
2317   }
2318 }
2319
2320 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2321   return Dali::Toolkit::ItemFactory::GetExtension();
2322 }
2323
2324 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2325   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2326   swig_callbackNewItem = callbackNewItem;
2327   swig_callbackItemReleased = callbackItemReleased;
2328 }
2329
2330 void SwigDirector_ItemFactory::swig_init_callbacks() {
2331   swig_callbackGetNumberOfItems = 0;
2332   swig_callbackNewItem = 0;
2333   swig_callbackItemReleased = 0;
2334 }
2335
2336 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2337   swig_init_callbacks();
2338 }
2339
2340 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2341
2342 }
2343
2344
2345 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction, const std::string& deviceName)
2346 {
2347   Dali::Actor c_result;
2348   void* jresult = 0;
2349
2350   if(!swig_callbackGetNextFocusableActor)
2351   {
2352     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2353   }
2354   else
2355   {
2356     jresult = (void*)swig_callbackGetNextFocusableActor((void*)(&current), (void*)(&proposed), direction, deviceName.c_str());
2357     if(!jresult)
2358     {
2359       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::Actor! Next focus will be NULL, please be cautious to handle the keyboard foucs!", __FILE__, __LINE__);
2360       return c_result;
2361     }
2362     c_result = *(Dali::Actor*)jresult;
2363   }
2364   return c_result;
2365 }
2366
2367 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2368   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2369 }
2370
2371 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2372   swig_callbackGetNextFocusableActor = 0;
2373 }
2374
2375 SwigDirector_FrameCallbackInterface::SwigDirector_FrameCallbackInterface() : Dali::FrameCallbackInterface(), Swig::Director() {
2376   swig_callbackOnUpdate = 0;
2377 }
2378
2379 SwigDirector_FrameCallbackInterface::~SwigDirector_FrameCallbackInterface() {
2380
2381 }
2382
2383 void SwigDirector_FrameCallbackInterface::swig_connect_director(SWIG_Callback0_t callbackUpdate) {
2384   swig_callbackOnUpdate = callbackUpdate;
2385 }
2386
2387
2388 void SwigDirector_FrameCallbackInterface::Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) {
2389   void * jcurrent  ;
2390
2391   if (!swig_callbackOnUpdate) {
2392     throw Swig::DirectorPureVirtualException("Dali::FrameCallbackInterface::Update");
2393   } else {
2394     Dali::UpdateProxy* proxy = &updateProxy;
2395     jcurrent = (void *)proxy;
2396     swig_callbackOnUpdate(jcurrent, elapsedSeconds);
2397     if (!jcurrent) {
2398       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::UpdateProxy! ", __FILE__, __LINE__);
2399       return;
2400     }
2401   }
2402   return;
2403 }
2404
2405
2406 #ifdef __cplusplus
2407 extern "C" {
2408 #endif
2409
2410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2411   void * jresult ;
2412   floatp *result = 0 ;
2413
2414   {
2415     try {
2416       result = (floatp *)new_floatp();
2417     } CALL_CATCH_EXCEPTION(0);
2418   }
2419   jresult = (void *)result;
2420   return jresult;
2421 }
2422
2423
2424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2425   floatp *arg1 = (floatp *) 0 ;
2426
2427   arg1 = (floatp *)jarg1;
2428   {
2429     try {
2430       delete_floatp(arg1);
2431     } CALL_CATCH_EXCEPTION();
2432   }
2433
2434 }
2435
2436
2437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2438   floatp *arg1 = (floatp *) 0 ;
2439   float arg2 ;
2440
2441   arg1 = (floatp *)jarg1;
2442   arg2 = (float)jarg2;
2443   {
2444     try {
2445       floatp_assign(arg1,arg2);
2446     } CALL_CATCH_EXCEPTION();
2447   }
2448
2449 }
2450
2451
2452 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2453   float jresult ;
2454   floatp *arg1 = (floatp *) 0 ;
2455   float result;
2456
2457   arg1 = (floatp *)jarg1;
2458   {
2459     try {
2460       result = (float)floatp_value(arg1);
2461     } CALL_CATCH_EXCEPTION(0);
2462   }
2463   jresult = result;
2464   return jresult;
2465 }
2466
2467
2468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2469   void * jresult ;
2470   floatp *arg1 = (floatp *) 0 ;
2471   float *result = 0 ;
2472
2473   arg1 = (floatp *)jarg1;
2474   {
2475     try {
2476       result = (float *)floatp_cast(arg1);
2477     } CALL_CATCH_EXCEPTION(0);
2478   }
2479
2480   jresult = (void *)result;
2481   return jresult;
2482 }
2483
2484
2485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2486   void * jresult ;
2487   float *arg1 = (float *) 0 ;
2488   floatp *result = 0 ;
2489
2490   arg1 = (float *)jarg1;
2491   {
2492     try {
2493       result = (floatp *)floatp_frompointer(arg1);
2494     } CALL_CATCH_EXCEPTION(0);
2495   }
2496
2497   jresult = (void *)result;
2498   return jresult;
2499 }
2500
2501
2502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2503   void * jresult ;
2504   intp *result = 0 ;
2505
2506   {
2507     try {
2508       result = (intp *)new_intp();
2509     } CALL_CATCH_EXCEPTION(0);
2510   }
2511
2512   jresult = (void *)result;
2513   return jresult;
2514 }
2515
2516
2517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2518   intp *arg1 = (intp *) 0 ;
2519
2520   arg1 = (intp *)jarg1;
2521   {
2522     try {
2523       delete_intp(arg1);
2524     } CALL_CATCH_EXCEPTION();
2525   }
2526
2527 }
2528
2529
2530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2531   intp *arg1 = (intp *) 0 ;
2532   int arg2 ;
2533
2534   arg1 = (intp *)jarg1;
2535   arg2 = (int)jarg2;
2536   {
2537     try {
2538       intp_assign(arg1,arg2);
2539     } CALL_CATCH_EXCEPTION();
2540   }
2541
2542 }
2543
2544
2545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2546   int jresult ;
2547   intp *arg1 = (intp *) 0 ;
2548   int result;
2549
2550   arg1 = (intp *)jarg1;
2551   {
2552     try {
2553       result = (int)intp_value(arg1);
2554     } CALL_CATCH_EXCEPTION(0);
2555   }
2556
2557   jresult = result;
2558   return jresult;
2559 }
2560
2561
2562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2563   void * jresult ;
2564   intp *arg1 = (intp *) 0 ;
2565   int *result = 0 ;
2566
2567   arg1 = (intp *)jarg1;
2568   {
2569     try {
2570       result = (int *)intp_cast(arg1);
2571     } CALL_CATCH_EXCEPTION(0);
2572   }
2573
2574   jresult = (void *)result;
2575   return jresult;
2576 }
2577
2578
2579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2580   void * jresult ;
2581   int *arg1 = (int *) 0 ;
2582   intp *result = 0 ;
2583
2584   arg1 = (int *)jarg1;
2585   {
2586     try {
2587       result = (intp *)intp_frompointer(arg1);
2588     } CALL_CATCH_EXCEPTION(0);
2589   }
2590
2591   jresult = (void *)result;
2592   return jresult;
2593 }
2594
2595
2596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2597   void * jresult ;
2598   doublep *result = 0 ;
2599
2600   {
2601     try {
2602       result = (doublep *)new_doublep();
2603     } CALL_CATCH_EXCEPTION(0);
2604   }
2605
2606   jresult = (void *)result;
2607   return jresult;
2608 }
2609
2610
2611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2612   doublep *arg1 = (doublep *) 0 ;
2613
2614   arg1 = (doublep *)jarg1;
2615   {
2616     try {
2617       delete_doublep(arg1);
2618     } CALL_CATCH_EXCEPTION();
2619   }
2620
2621 }
2622
2623
2624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2625   doublep *arg1 = (doublep *) 0 ;
2626   double arg2 ;
2627
2628   arg1 = (doublep *)jarg1;
2629   arg2 = (double)jarg2;
2630   {
2631     try {
2632       doublep_assign(arg1,arg2);
2633     } CALL_CATCH_EXCEPTION();
2634   }
2635
2636 }
2637
2638
2639 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2640   double jresult ;
2641   doublep *arg1 = (doublep *) 0 ;
2642   double result;
2643
2644   arg1 = (doublep *)jarg1;
2645   {
2646     try {
2647       result = (double)doublep_value(arg1);
2648     } CALL_CATCH_EXCEPTION(0);
2649   }
2650
2651   jresult = result;
2652   return jresult;
2653 }
2654
2655
2656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2657   void * jresult ;
2658   doublep *arg1 = (doublep *) 0 ;
2659   double *result = 0 ;
2660
2661   arg1 = (doublep *)jarg1;
2662   {
2663     try {
2664       result = (double *)doublep_cast(arg1);
2665     } CALL_CATCH_EXCEPTION(0);
2666   }
2667
2668   jresult = (void *)result;
2669   return jresult;
2670 }
2671
2672
2673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2674   void * jresult ;
2675   double *arg1 = (double *) 0 ;
2676   doublep *result = 0 ;
2677
2678   arg1 = (double *)jarg1;
2679   {
2680     try {
2681       result = (doublep *)doublep_frompointer(arg1);
2682     } CALL_CATCH_EXCEPTION(0);
2683   }
2684
2685   jresult = (void *)result;
2686   return jresult;
2687 }
2688
2689
2690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2691   void * jresult ;
2692   uintp *result = 0 ;
2693
2694   {
2695     try {
2696       result = (uintp *)new_uintp();
2697     } CALL_CATCH_EXCEPTION(0);
2698   }
2699
2700   jresult = (void *)result;
2701   return jresult;
2702 }
2703
2704
2705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2706   uintp *arg1 = (uintp *) 0 ;
2707
2708   arg1 = (uintp *)jarg1;
2709   {
2710     try {
2711       delete_uintp(arg1);
2712     } CALL_CATCH_EXCEPTION();
2713   }
2714
2715 }
2716
2717
2718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2719   uintp *arg1 = (uintp *) 0 ;
2720   unsigned int arg2 ;
2721
2722   arg1 = (uintp *)jarg1;
2723   arg2 = (unsigned int)jarg2;
2724   {
2725     try {
2726       uintp_assign(arg1,arg2);
2727     } CALL_CATCH_EXCEPTION();
2728   }
2729
2730 }
2731
2732
2733 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
2734   unsigned int jresult ;
2735   uintp *arg1 = (uintp *) 0 ;
2736   unsigned int result;
2737
2738   arg1 = (uintp *)jarg1;
2739   {
2740     try {
2741       result = (unsigned int)uintp_value(arg1);
2742     } CALL_CATCH_EXCEPTION(0);
2743   }
2744
2745   jresult = result;
2746   return jresult;
2747 }
2748
2749
2750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
2751   void * jresult ;
2752   uintp *arg1 = (uintp *) 0 ;
2753   unsigned int *result = 0 ;
2754
2755   arg1 = (uintp *)jarg1;
2756   {
2757     try {
2758       result = (unsigned int *)uintp_cast(arg1);
2759     } CALL_CATCH_EXCEPTION(0);
2760   }
2761
2762   jresult = (void *)result;
2763   return jresult;
2764 }
2765
2766
2767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
2768   void * jresult ;
2769   unsigned int *arg1 = (unsigned int *) 0 ;
2770   uintp *result = 0 ;
2771
2772   arg1 = (unsigned int *)jarg1;
2773   {
2774     try {
2775       result = (uintp *)uintp_frompointer(arg1);
2776     } CALL_CATCH_EXCEPTION(0);
2777   }
2778
2779   jresult = (void *)result;
2780   return jresult;
2781 }
2782
2783
2784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
2785   void * jresult ;
2786   ushortp *result = 0 ;
2787
2788   {
2789     try {
2790       result = (ushortp *)new_ushortp();
2791     } CALL_CATCH_EXCEPTION(0);
2792   }
2793
2794   jresult = (void *)result;
2795   return jresult;
2796 }
2797
2798
2799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
2800   ushortp *arg1 = (ushortp *) 0 ;
2801
2802   arg1 = (ushortp *)jarg1;
2803   {
2804     try {
2805       delete_ushortp(arg1);
2806     } CALL_CATCH_EXCEPTION();
2807   }
2808
2809 }
2810
2811
2812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
2813   ushortp *arg1 = (ushortp *) 0 ;
2814   unsigned short arg2 ;
2815
2816   arg1 = (ushortp *)jarg1;
2817   arg2 = (unsigned short)jarg2;
2818   {
2819     try {
2820       ushortp_assign(arg1,arg2);
2821     } CALL_CATCH_EXCEPTION();
2822   }
2823
2824 }
2825
2826
2827 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
2828   unsigned short jresult ;
2829   ushortp *arg1 = (ushortp *) 0 ;
2830   unsigned short result;
2831
2832   arg1 = (ushortp *)jarg1;
2833   {
2834     try {
2835       result = (unsigned short)ushortp_value(arg1);
2836     } CALL_CATCH_EXCEPTION(0);
2837   }
2838
2839   jresult = result;
2840   return jresult;
2841 }
2842
2843
2844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
2845   void * jresult ;
2846   ushortp *arg1 = (ushortp *) 0 ;
2847   unsigned short *result = 0 ;
2848
2849   arg1 = (ushortp *)jarg1;
2850   {
2851     try {
2852       result = (unsigned short *)ushortp_cast(arg1);
2853     } CALL_CATCH_EXCEPTION(0);
2854   }
2855
2856   jresult = (void *)result;
2857   return jresult;
2858 }
2859
2860
2861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
2862   void * jresult ;
2863   unsigned short *arg1 = (unsigned short *) 0 ;
2864   ushortp *result = 0 ;
2865
2866   arg1 = (unsigned short *)jarg1;
2867   {
2868     try {
2869       result = (ushortp *)ushortp_frompointer(arg1);
2870     } CALL_CATCH_EXCEPTION(0);
2871   }
2872
2873   jresult = (void *)result;
2874   return jresult;
2875 }
2876
2877
2878 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
2879   unsigned int jresult ;
2880   int arg1 ;
2881   unsigned int result;
2882
2883   arg1 = (int)jarg1;
2884   {
2885     try {
2886       result = (unsigned int)int_to_uint(arg1);
2887     } CALL_CATCH_EXCEPTION(0);
2888   }
2889
2890   jresult = result;
2891   return jresult;
2892 }
2893
2894
2895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
2896   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
2897
2898   arg1 = (Dali::RefObject *)jarg1;
2899   {
2900     try {
2901       (arg1)->Reference();
2902     } CALL_CATCH_EXCEPTION();
2903   }
2904
2905 }
2906
2907
2908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
2909   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
2910
2911   arg1 = (Dali::RefObject *)jarg1;
2912   {
2913     try {
2914       (arg1)->Unreference();
2915     } CALL_CATCH_EXCEPTION();
2916   }
2917
2918 }
2919
2920
2921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
2922   int jresult ;
2923   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
2924   int result;
2925
2926   arg1 = (Dali::RefObject *)jarg1;
2927   {
2928     try {
2929       result = (int)(arg1)->ReferenceCount();
2930     } CALL_CATCH_EXCEPTION(0);
2931   }
2932
2933   jresult = result;
2934   return jresult;
2935 }
2936
2937
2938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
2939   void * jresult ;
2940   Dali::Any *result = 0 ;
2941
2942   {
2943     try {
2944       result = (Dali::Any *)new Dali::Any();
2945     } CALL_CATCH_EXCEPTION(0);
2946   }
2947
2948   jresult = (void *)result;
2949   return jresult;
2950 }
2951
2952
2953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
2954   Dali::Any *arg1 = (Dali::Any *) 0 ;
2955
2956   arg1 = (Dali::Any *)jarg1;
2957   {
2958     try {
2959       delete arg1;
2960     } CALL_CATCH_EXCEPTION();
2961   }
2962
2963 }
2964
2965
2966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
2967   char *arg1 = (char *) 0 ;
2968
2969   arg1 = (char *)jarg1;
2970   {
2971     try {
2972       Dali::Any::AssertAlways((char const *)arg1);
2973     } CALL_CATCH_EXCEPTION();
2974   }
2975
2976 }
2977
2978
2979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
2980   void * jresult ;
2981   Dali::Any *arg1 = 0 ;
2982   Dali::Any *result = 0 ;
2983
2984   arg1 = (Dali::Any *)jarg1;
2985   if (!arg1) {
2986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
2987     return 0;
2988   }
2989   {
2990     try {
2991       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
2992     } CALL_CATCH_EXCEPTION(0);
2993   }
2994
2995   jresult = (void *)result;
2996   return jresult;
2997 }
2998
2999
3000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3001   void * jresult ;
3002   Dali::Any *arg1 = (Dali::Any *) 0 ;
3003   Dali::Any *arg2 = 0 ;
3004   Dali::Any *result = 0 ;
3005
3006   arg1 = (Dali::Any *)jarg1;
3007   arg2 = (Dali::Any *)jarg2;
3008   if (!arg2) {
3009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3010     return 0;
3011   }
3012   {
3013     try {
3014       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3015     } CALL_CATCH_EXCEPTION(0);
3016   }
3017
3018   jresult = (void *)result;
3019   return jresult;
3020 }
3021
3022
3023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3024   void * jresult ;
3025   Dali::Any *arg1 = (Dali::Any *) 0 ;
3026   std::type_info *result = 0 ;
3027
3028   arg1 = (Dali::Any *)jarg1;
3029   {
3030     try {
3031       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3032     } CALL_CATCH_EXCEPTION(0);
3033   }
3034
3035   jresult = (void *)result;
3036   return jresult;
3037 }
3038
3039
3040 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3041   bool jresult ;
3042   Dali::Any *arg1 = (Dali::Any *) 0 ;
3043   bool result;
3044
3045   arg1 = (Dali::Any *)jarg1;
3046   {
3047     try {
3048       result = (bool)((Dali::Any const *)arg1)->Empty();
3049     } CALL_CATCH_EXCEPTION(0);
3050   }
3051
3052   jresult = result;
3053   return jresult;
3054 }
3055
3056
3057
3058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3059   char *arg1 = (char *) 0 ;
3060   char *arg2 = (char *) 0 ;
3061
3062   arg1 = (char *)jarg1;
3063   arg2 = (char *)jarg2;
3064   {
3065     try {
3066       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3067     } CALL_CATCH_EXCEPTION();
3068   }
3069
3070 }
3071
3072
3073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3074   void * jresult ;
3075   char *arg1 = (char *) 0 ;
3076   char *arg2 = (char *) 0 ;
3077   Dali::DaliException *result = 0 ;
3078
3079   arg1 = (char *)jarg1;
3080   arg2 = (char *)jarg2;
3081   {
3082     try {
3083       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3084     } CALL_CATCH_EXCEPTION(0);
3085   }
3086
3087   jresult = (void *)result;
3088   return jresult;
3089 }
3090
3091
3092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3093   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3094   std::string arg2 = std::string(jarg2);
3095
3096   arg1 = (Dali::DaliException *)jarg1;
3097   {
3098     if (!arg2.empty()) {
3099       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
3100     } else {
3101       arg1->location = 0;
3102     }
3103   }
3104 }
3105
3106 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3107   char * jresult ;
3108   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3109   char *result = 0 ;
3110
3111   arg1 = (Dali::DaliException *)jarg1;
3112   result = (char *) ((arg1)->location);
3113   jresult = SWIG_csharp_string_callback((const char *)result);
3114   return jresult;
3115 }
3116
3117
3118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3119   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3120   std::string arg2 = std::string(jarg2);
3121
3122   arg1 = (Dali::DaliException *)jarg1;
3123   {
3124     if (!arg2.empty()) {
3125       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
3126     } else {
3127       arg1->condition = 0;
3128     }
3129   }
3130 }
3131
3132
3133 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3134   char * jresult ;
3135   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3136   char *result = 0 ;
3137
3138   arg1 = (Dali::DaliException *)jarg1;
3139   result = (char *) ((arg1)->condition);
3140   jresult = SWIG_csharp_string_callback((const char *)result);
3141   return jresult;
3142 }
3143
3144
3145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3146   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3147
3148   arg1 = (Dali::DaliException *)jarg1;
3149   {
3150     try {
3151       delete arg1;
3152     } CALL_CATCH_EXCEPTION();
3153   }
3154
3155 }
3156
3157
3158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3159   void * jresult ;
3160   Dali::Vector2 *result = 0 ;
3161
3162   {
3163     try {
3164       result = (Dali::Vector2 *)new Dali::Vector2();
3165     } CALL_CATCH_EXCEPTION(0);
3166   }
3167
3168   jresult = (void *)result;
3169   return jresult;
3170 }
3171
3172
3173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3174   void * jresult ;
3175   float arg1 ;
3176   float arg2 ;
3177   Dali::Vector2 *result = 0 ;
3178
3179   arg1 = (float)jarg1;
3180   arg2 = (float)jarg2;
3181   {
3182     try {
3183       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3184     } CALL_CATCH_EXCEPTION(0);
3185   }
3186
3187   jresult = (void *)result;
3188   return jresult;
3189 }
3190
3191
3192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3193   void * jresult ;
3194   float *arg1 = (float *) 0 ;
3195   Dali::Vector2 *result = 0 ;
3196
3197   arg1 = jarg1;
3198   {
3199     try {
3200       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3201     } CALL_CATCH_EXCEPTION(0);
3202   }
3203
3204   jresult = (void *)result;
3205
3206
3207   return jresult;
3208 }
3209
3210
3211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3212   void * jresult ;
3213   Dali::Vector3 *arg1 = 0 ;
3214   Dali::Vector2 *result = 0 ;
3215
3216   arg1 = (Dali::Vector3 *)jarg1;
3217   if (!arg1) {
3218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3219     return 0;
3220   }
3221   {
3222     try {
3223       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3224     } CALL_CATCH_EXCEPTION(0);
3225   }
3226
3227   jresult = (void *)result;
3228   return jresult;
3229 }
3230
3231
3232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
3233   void * jresult ;
3234   Dali::Vector4 *arg1 = 0 ;
3235   Dali::Vector2 *result = 0 ;
3236
3237   arg1 = (Dali::Vector4 *)jarg1;
3238   if (!arg1) {
3239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3240     return 0;
3241   }
3242   {
3243     try {
3244       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3245     } CALL_CATCH_EXCEPTION(0);
3246   }
3247
3248   jresult = (void *)result;
3249   return jresult;
3250 }
3251
3252
3253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
3254   void * jresult ;
3255   Dali::Vector2 *result = 0 ;
3256
3257   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
3258   jresult = (void *)result;
3259   return jresult;
3260 }
3261
3262
3263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
3264   void * jresult ;
3265   Dali::Vector2 *result = 0 ;
3266
3267   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
3268   jresult = (void *)result;
3269   return jresult;
3270 }
3271
3272
3273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
3274   void * jresult ;
3275   Dali::Vector2 *result = 0 ;
3276
3277   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
3278   jresult = (void *)result;
3279   return jresult;
3280 }
3281
3282
3283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
3284   void * jresult ;
3285   Dali::Vector2 *result = 0 ;
3286
3287   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
3288   jresult = (void *)result;
3289   return jresult;
3290 }
3291
3292
3293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
3294   void * jresult ;
3295   Dali::Vector2 *result = 0 ;
3296
3297   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
3298   jresult = (void *)result;
3299   return jresult;
3300 }
3301
3302
3303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
3304   void * jresult ;
3305   Dali::Vector2 *result = 0 ;
3306
3307   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
3308   jresult = (void *)result;
3309   return jresult;
3310 }
3311
3312
3313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
3314   void * jresult ;
3315   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3316   float *arg2 = (float *) 0 ;
3317   Dali::Vector2 *result = 0 ;
3318
3319   arg1 = (Dali::Vector2 *)jarg1;
3320   arg2 = jarg2;
3321   {
3322     try {
3323       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
3324     } CALL_CATCH_EXCEPTION(0);
3325   }
3326
3327   jresult = (void *)result;
3328
3329
3330   return jresult;
3331 }
3332
3333
3334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
3335   void * jresult ;
3336   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3337   Dali::Vector3 *arg2 = 0 ;
3338   Dali::Vector2 *result = 0 ;
3339
3340   arg1 = (Dali::Vector2 *)jarg1;
3341   arg2 = (Dali::Vector3 *)jarg2;
3342   if (!arg2) {
3343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3344     return 0;
3345   }
3346   {
3347     try {
3348       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
3349     } CALL_CATCH_EXCEPTION(0);
3350   }
3351
3352   jresult = (void *)result;
3353   return jresult;
3354 }
3355
3356
3357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
3358   void * jresult ;
3359   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3360   Dali::Vector4 *arg2 = 0 ;
3361   Dali::Vector2 *result = 0 ;
3362
3363   arg1 = (Dali::Vector2 *)jarg1;
3364   arg2 = (Dali::Vector4 *)jarg2;
3365   if (!arg2) {
3366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3367     return 0;
3368   }
3369   {
3370     try {
3371       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
3372     } CALL_CATCH_EXCEPTION(0);
3373   }
3374
3375   jresult = (void *)result;
3376   return jresult;
3377 }
3378
3379
3380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
3381   void * jresult ;
3382   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3383   Dali::Vector2 *arg2 = 0 ;
3384   Dali::Vector2 result;
3385
3386   arg1 = (Dali::Vector2 *)jarg1;
3387   arg2 = (Dali::Vector2 *)jarg2;
3388   if (!arg2) {
3389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3390     return 0;
3391   }
3392   {
3393     try {
3394       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
3395     } CALL_CATCH_EXCEPTION(0);
3396   }
3397
3398   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3399   return jresult;
3400 }
3401
3402
3403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
3404   void * jresult ;
3405   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3406   Dali::Vector2 *arg2 = 0 ;
3407   Dali::Vector2 *result = 0 ;
3408
3409   arg1 = (Dali::Vector2 *)jarg1;
3410   arg2 = (Dali::Vector2 *)jarg2;
3411   if (!arg2) {
3412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3413     return 0;
3414   }
3415   {
3416     try {
3417       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
3418     } CALL_CATCH_EXCEPTION(0);
3419   }
3420
3421   jresult = (void *)result;
3422   return jresult;
3423 }
3424
3425
3426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
3427   void * jresult ;
3428   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3429   Dali::Vector2 *arg2 = 0 ;
3430   Dali::Vector2 result;
3431
3432   arg1 = (Dali::Vector2 *)jarg1;
3433   arg2 = (Dali::Vector2 *)jarg2;
3434   if (!arg2) {
3435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3436     return 0;
3437   }
3438   {
3439     try {
3440       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
3441     } CALL_CATCH_EXCEPTION(0);
3442   }
3443
3444   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3445   return jresult;
3446 }
3447
3448
3449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
3450   void * jresult ;
3451   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3452   Dali::Vector2 *arg2 = 0 ;
3453   Dali::Vector2 *result = 0 ;
3454
3455   arg1 = (Dali::Vector2 *)jarg1;
3456   arg2 = (Dali::Vector2 *)jarg2;
3457   if (!arg2) {
3458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3459     return 0;
3460   }
3461   {
3462     try {
3463       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
3464     } CALL_CATCH_EXCEPTION(0);
3465   }
3466
3467   jresult = (void *)result;
3468   return jresult;
3469 }
3470
3471
3472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
3473   void * jresult ;
3474   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3475   Dali::Vector2 *arg2 = 0 ;
3476   Dali::Vector2 result;
3477
3478   arg1 = (Dali::Vector2 *)jarg1;
3479   arg2 = (Dali::Vector2 *)jarg2;
3480   if (!arg2) {
3481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3482     return 0;
3483   }
3484   {
3485     try {
3486       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
3487     } CALL_CATCH_EXCEPTION(0);
3488   }
3489
3490   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3491   return jresult;
3492 }
3493
3494
3495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
3496   void * jresult ;
3497   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3498   float arg2 ;
3499   Dali::Vector2 result;
3500
3501   arg1 = (Dali::Vector2 *)jarg1;
3502   arg2 = (float)jarg2;
3503   {
3504     try {
3505       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
3506     } CALL_CATCH_EXCEPTION(0);
3507   }
3508
3509   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3510   return jresult;
3511 }
3512
3513
3514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
3515   void * jresult ;
3516   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3517   Dali::Vector2 *arg2 = 0 ;
3518   Dali::Vector2 *result = 0 ;
3519
3520   arg1 = (Dali::Vector2 *)jarg1;
3521   arg2 = (Dali::Vector2 *)jarg2;
3522   if (!arg2) {
3523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3524     return 0;
3525   }
3526   {
3527     try {
3528       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
3529     } CALL_CATCH_EXCEPTION(0);
3530   }
3531
3532   jresult = (void *)result;
3533   return jresult;
3534 }
3535
3536
3537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
3538   void * jresult ;
3539   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3540   float arg2 ;
3541   Dali::Vector2 *result = 0 ;
3542
3543   arg1 = (Dali::Vector2 *)jarg1;
3544   arg2 = (float)jarg2;
3545   {
3546     try {
3547       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
3548     } CALL_CATCH_EXCEPTION(0);
3549   }
3550
3551   jresult = (void *)result;
3552   return jresult;
3553 }
3554
3555
3556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
3557   void * jresult ;
3558   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3559   Dali::Vector2 *arg2 = 0 ;
3560   Dali::Vector2 result;
3561
3562   arg1 = (Dali::Vector2 *)jarg1;
3563   arg2 = (Dali::Vector2 *)jarg2;
3564   if (!arg2) {
3565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3566     return 0;
3567   }
3568   {
3569     try {
3570       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
3571     } CALL_CATCH_EXCEPTION(0);
3572   }
3573
3574   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3575   return jresult;
3576 }
3577
3578
3579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
3580   void * jresult ;
3581   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3582   float arg2 ;
3583   Dali::Vector2 result;
3584
3585   arg1 = (Dali::Vector2 *)jarg1;
3586   arg2 = (float)jarg2;
3587   {
3588     try {
3589       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
3590     } CALL_CATCH_EXCEPTION(0);
3591   }
3592
3593   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3594   return jresult;
3595 }
3596
3597
3598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
3599   void * jresult ;
3600   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3601   Dali::Vector2 *arg2 = 0 ;
3602   Dali::Vector2 *result = 0 ;
3603
3604   arg1 = (Dali::Vector2 *)jarg1;
3605   arg2 = (Dali::Vector2 *)jarg2;
3606   if (!arg2) {
3607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3608     return 0;
3609   }
3610   {
3611     try {
3612       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
3613     } CALL_CATCH_EXCEPTION(0);
3614   }
3615
3616   jresult = (void *)result;
3617   return jresult;
3618 }
3619
3620
3621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
3622   void * jresult ;
3623   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3624   float arg2 ;
3625   Dali::Vector2 *result = 0 ;
3626
3627   arg1 = (Dali::Vector2 *)jarg1;
3628   arg2 = (float)jarg2;
3629   {
3630     try {
3631       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
3632     } CALL_CATCH_EXCEPTION(0);
3633   }
3634
3635   jresult = (void *)result;
3636   return jresult;
3637 }
3638
3639
3640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
3641   void * jresult ;
3642   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3643   Dali::Vector2 result;
3644
3645   arg1 = (Dali::Vector2 *)jarg1;
3646   {
3647     try {
3648       result = ((Dali::Vector2 const *)arg1)->operator -();
3649     } CALL_CATCH_EXCEPTION(0);
3650   }
3651
3652   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3653   return jresult;
3654 }
3655
3656
3657 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
3658   bool jresult ;
3659   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3660   Dali::Vector2 *arg2 = 0 ;
3661   bool result;
3662
3663   arg1 = (Dali::Vector2 *)jarg1;
3664   arg2 = (Dali::Vector2 *)jarg2;
3665   if (!arg2) {
3666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3667     return 0;
3668   }
3669   {
3670     try {
3671       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
3672     } CALL_CATCH_EXCEPTION(0);
3673   }
3674
3675   jresult = result;
3676   return jresult;
3677 }
3678
3679
3680 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
3681   bool jresult ;
3682   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3683   Dali::Vector2 *arg2 = 0 ;
3684   bool result;
3685
3686   arg1 = (Dali::Vector2 *)jarg1;
3687   arg2 = (Dali::Vector2 *)jarg2;
3688   if (!arg2) {
3689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3690     return 0;
3691   }
3692   {
3693     try {
3694       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
3695     } CALL_CATCH_EXCEPTION(0);
3696   }
3697
3698   jresult = result;
3699   return jresult;
3700 }
3701
3702
3703 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
3704   float jresult ;
3705   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3706   unsigned int arg2 ;
3707   float *result = 0 ;
3708
3709   arg1 = (Dali::Vector2 *)jarg1;
3710   arg2 = (unsigned int)jarg2;
3711   {
3712     try {
3713       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
3714     } CALL_CATCH_EXCEPTION(0);
3715   }
3716
3717   jresult = *result;
3718   return jresult;
3719 }
3720
3721
3722 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
3723   float jresult ;
3724   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3725   float result;
3726
3727   arg1 = (Dali::Vector2 *)jarg1;
3728   {
3729     try {
3730       result = (float)((Dali::Vector2 const *)arg1)->Length();
3731     } CALL_CATCH_EXCEPTION(0);
3732   }
3733
3734   jresult = result;
3735   return jresult;
3736 }
3737
3738
3739 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
3740   float jresult ;
3741   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3742   float result;
3743
3744   arg1 = (Dali::Vector2 *)jarg1;
3745   {
3746     try {
3747       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
3748     } CALL_CATCH_EXCEPTION(0);
3749   }
3750
3751   jresult = result;
3752   return jresult;
3753 }
3754
3755
3756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
3757   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3758
3759   arg1 = (Dali::Vector2 *)jarg1;
3760   {
3761     try {
3762       (arg1)->Normalize();
3763     } CALL_CATCH_EXCEPTION();
3764   }
3765
3766 }
3767
3768
3769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
3770   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3771   Dali::Vector2 *arg2 = 0 ;
3772   Dali::Vector2 *arg3 = 0 ;
3773
3774   arg1 = (Dali::Vector2 *)jarg1;
3775   arg2 = (Dali::Vector2 *)jarg2;
3776   if (!arg2) {
3777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3778     return ;
3779   }
3780   arg3 = (Dali::Vector2 *)jarg3;
3781   if (!arg3) {
3782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3783     return ;
3784   }
3785   {
3786     try {
3787       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
3788     } CALL_CATCH_EXCEPTION();
3789   }
3790
3791 }
3792
3793
3794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
3795   void * jresult ;
3796   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3797   float *result = 0 ;
3798
3799   arg1 = (Dali::Vector2 *)jarg1;
3800   {
3801     try {
3802       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
3803     } CALL_CATCH_EXCEPTION(0);
3804   }
3805
3806   jresult = (void *)result;
3807   return jresult;
3808 }
3809
3810
3811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
3812   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3813   float arg2 ;
3814
3815   arg1 = (Dali::Vector2 *)jarg1;
3816   arg2 = (float)jarg2;
3817   if (arg1) (arg1)->x = arg2;
3818 }
3819
3820
3821 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
3822   float jresult ;
3823   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3824   float result;
3825
3826   arg1 = (Dali::Vector2 *)jarg1;
3827   result = (float) ((arg1)->x);
3828   jresult = result;
3829   return jresult;
3830 }
3831
3832
3833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
3834   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3835   float arg2 ;
3836
3837   arg1 = (Dali::Vector2 *)jarg1;
3838   arg2 = (float)jarg2;
3839   if (arg1) (arg1)->width = arg2;
3840 }
3841
3842
3843 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
3844   float jresult ;
3845   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3846   float result;
3847
3848   arg1 = (Dali::Vector2 *)jarg1;
3849   result = (float) ((arg1)->width);
3850   jresult = result;
3851   return jresult;
3852 }
3853
3854
3855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
3856   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3857   float arg2 ;
3858
3859   arg1 = (Dali::Vector2 *)jarg1;
3860   arg2 = (float)jarg2;
3861   if (arg1) (arg1)->y = arg2;
3862 }
3863
3864
3865 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
3866   float jresult ;
3867   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3868   float result;
3869
3870   arg1 = (Dali::Vector2 *)jarg1;
3871   result = (float) ((arg1)->y);
3872   jresult = result;
3873   return jresult;
3874 }
3875
3876
3877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
3878   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3879   float arg2 ;
3880
3881   arg1 = (Dali::Vector2 *)jarg1;
3882   arg2 = (float)jarg2;
3883   if (arg1) (arg1)->height = arg2;
3884 }
3885
3886
3887 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
3888   float jresult ;
3889   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3890   float result;
3891
3892   arg1 = (Dali::Vector2 *)jarg1;
3893   result = (float) ((arg1)->height);
3894   jresult = result;
3895   return jresult;
3896 }
3897
3898
3899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
3900   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3901
3902   arg1 = (Dali::Vector2 *)jarg1;
3903   {
3904     try {
3905       delete arg1;
3906     } CALL_CATCH_EXCEPTION();
3907   }
3908
3909 }
3910
3911
3912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
3913   void * jresult ;
3914   Dali::Vector2 *arg1 = 0 ;
3915   Dali::Vector2 *arg2 = 0 ;
3916   Dali::Vector2 result;
3917
3918   arg1 = (Dali::Vector2 *)jarg1;
3919   if (!arg1) {
3920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3921     return 0;
3922   }
3923   arg2 = (Dali::Vector2 *)jarg2;
3924   if (!arg2) {
3925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3926     return 0;
3927   }
3928   {
3929     try {
3930       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
3931     } CALL_CATCH_EXCEPTION(0);
3932   }
3933
3934   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3935   return jresult;
3936 }
3937
3938
3939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
3940   void * jresult ;
3941   Dali::Vector2 *arg1 = 0 ;
3942   Dali::Vector2 *arg2 = 0 ;
3943   Dali::Vector2 result;
3944
3945   arg1 = (Dali::Vector2 *)jarg1;
3946   if (!arg1) {
3947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3948     return 0;
3949   }
3950   arg2 = (Dali::Vector2 *)jarg2;
3951   if (!arg2) {
3952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3953     return 0;
3954   }
3955   {
3956     try {
3957       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
3958     } CALL_CATCH_EXCEPTION(0);
3959   }
3960
3961   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3962   return jresult;
3963 }
3964
3965
3966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
3967   void * jresult ;
3968   Dali::Vector2 *arg1 = 0 ;
3969   float *arg2 = 0 ;
3970   float *arg3 = 0 ;
3971   float temp2 ;
3972   float temp3 ;
3973   Dali::Vector2 result;
3974
3975   arg1 = (Dali::Vector2 *)jarg1;
3976   if (!arg1) {
3977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3978     return 0;
3979   }
3980   temp2 = (float)jarg2;
3981   arg2 = &temp2;
3982   temp3 = (float)jarg3;
3983   arg3 = &temp3;
3984   {
3985     try {
3986       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
3987     } CALL_CATCH_EXCEPTION(0);
3988   }
3989
3990   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3991   return jresult;
3992 }
3993
3994
3995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
3996   void * jresult ;
3997   Dali::Vector3 *result = 0 ;
3998
3999   {
4000     try {
4001       result = (Dali::Vector3 *)new Dali::Vector3();
4002     } CALL_CATCH_EXCEPTION(0);
4003   }
4004
4005   jresult = (void *)result;
4006   return jresult;
4007 }
4008
4009
4010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
4011   void * jresult ;
4012   float arg1 ;
4013   float arg2 ;
4014   float arg3 ;
4015   Dali::Vector3 *result = 0 ;
4016
4017   arg1 = (float)jarg1;
4018   arg2 = (float)jarg2;
4019   arg3 = (float)jarg3;
4020   {
4021     try {
4022       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
4023     } CALL_CATCH_EXCEPTION(0);
4024   }
4025
4026   jresult = (void *)result;
4027   return jresult;
4028 }
4029
4030
4031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
4032   void * jresult ;
4033   float *arg1 = (float *) 0 ;
4034   Dali::Vector3 *result = 0 ;
4035
4036   arg1 = jarg1;
4037   {
4038     try {
4039       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
4040     } CALL_CATCH_EXCEPTION(0);
4041   }
4042
4043   jresult = (void *)result;
4044
4045
4046   return jresult;
4047 }
4048
4049
4050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
4051   void * jresult ;
4052   Dali::Vector2 *arg1 = 0 ;
4053   Dali::Vector3 *result = 0 ;
4054
4055   arg1 = (Dali::Vector2 *)jarg1;
4056   if (!arg1) {
4057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4058     return 0;
4059   }
4060   {
4061     try {
4062       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
4063     } CALL_CATCH_EXCEPTION(0);
4064   }
4065
4066   jresult = (void *)result;
4067   return jresult;
4068 }
4069
4070
4071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
4072   void * jresult ;
4073   Dali::Vector4 *arg1 = 0 ;
4074   Dali::Vector3 *result = 0 ;
4075
4076   arg1 = (Dali::Vector4 *)jarg1;
4077   if (!arg1) {
4078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4079     return 0;
4080   }
4081   {
4082     try {
4083       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
4084     } CALL_CATCH_EXCEPTION(0);
4085   }
4086
4087   jresult = (void *)result;
4088   return jresult;
4089 }
4090
4091
4092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
4093   void * jresult ;
4094   Dali::Vector3 *result = 0 ;
4095
4096   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
4097   jresult = (void *)result;
4098   return jresult;
4099 }
4100
4101
4102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
4103   void * jresult ;
4104   Dali::Vector3 *result = 0 ;
4105
4106   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
4107   jresult = (void *)result;
4108   return jresult;
4109 }
4110
4111
4112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
4113   void * jresult ;
4114   Dali::Vector3 *result = 0 ;
4115
4116   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
4117   jresult = (void *)result;
4118   return jresult;
4119 }
4120
4121
4122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
4123   void * jresult ;
4124   Dali::Vector3 *result = 0 ;
4125
4126   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
4127   jresult = (void *)result;
4128   return jresult;
4129 }
4130
4131
4132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
4133   void * jresult ;
4134   Dali::Vector3 *result = 0 ;
4135
4136   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
4137   jresult = (void *)result;
4138   return jresult;
4139 }
4140
4141
4142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
4143   void * jresult ;
4144   Dali::Vector3 *result = 0 ;
4145
4146   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
4147   jresult = (void *)result;
4148   return jresult;
4149 }
4150
4151
4152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
4153   void * jresult ;
4154   Dali::Vector3 *result = 0 ;
4155
4156   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
4157   jresult = (void *)result;
4158   return jresult;
4159 }
4160
4161
4162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
4163   void * jresult ;
4164   Dali::Vector3 *result = 0 ;
4165
4166   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
4167   jresult = (void *)result;
4168   return jresult;
4169 }
4170
4171
4172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
4173   void * jresult ;
4174   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4175   float *arg2 = (float *) 0 ;
4176   Dali::Vector3 *result = 0 ;
4177
4178   arg1 = (Dali::Vector3 *)jarg1;
4179   arg2 = jarg2;
4180   {
4181     try {
4182       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
4183     } CALL_CATCH_EXCEPTION(0);
4184   }
4185
4186   jresult = (void *)result;
4187
4188
4189   return jresult;
4190 }
4191
4192
4193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
4194   void * jresult ;
4195   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4196   Dali::Vector2 *arg2 = 0 ;
4197   Dali::Vector3 *result = 0 ;
4198
4199   arg1 = (Dali::Vector3 *)jarg1;
4200   arg2 = (Dali::Vector2 *)jarg2;
4201   if (!arg2) {
4202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4203     return 0;
4204   }
4205   {
4206     try {
4207       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
4208     } CALL_CATCH_EXCEPTION(0);
4209   }
4210
4211   jresult = (void *)result;
4212   return jresult;
4213 }
4214
4215
4216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
4217   void * jresult ;
4218   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4219   Dali::Vector4 *arg2 = 0 ;
4220   Dali::Vector3 *result = 0 ;
4221
4222   arg1 = (Dali::Vector3 *)jarg1;
4223   arg2 = (Dali::Vector4 *)jarg2;
4224   if (!arg2) {
4225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4226     return 0;
4227   }
4228   {
4229     try {
4230       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4231     } CALL_CATCH_EXCEPTION(0);
4232   }
4233
4234   jresult = (void *)result;
4235   return jresult;
4236 }
4237
4238
4239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
4240   void * jresult ;
4241   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4242   Dali::Vector3 *arg2 = 0 ;
4243   Dali::Vector3 result;
4244
4245   arg1 = (Dali::Vector3 *)jarg1;
4246   arg2 = (Dali::Vector3 *)jarg2;
4247   if (!arg2) {
4248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4249     return 0;
4250   }
4251   {
4252     try {
4253       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
4254     } CALL_CATCH_EXCEPTION(0);
4255   }
4256
4257   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4258   return jresult;
4259 }
4260
4261
4262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
4263   void * jresult ;
4264   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4265   Dali::Vector3 *arg2 = 0 ;
4266   Dali::Vector3 *result = 0 ;
4267
4268   arg1 = (Dali::Vector3 *)jarg1;
4269   arg2 = (Dali::Vector3 *)jarg2;
4270   if (!arg2) {
4271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4272     return 0;
4273   }
4274   {
4275     try {
4276       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
4277     } CALL_CATCH_EXCEPTION(0);
4278   }
4279
4280   jresult = (void *)result;
4281   return jresult;
4282 }
4283
4284
4285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4286   void * jresult ;
4287   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4288   Dali::Vector3 *arg2 = 0 ;
4289   Dali::Vector3 result;
4290
4291   arg1 = (Dali::Vector3 *)jarg1;
4292   arg2 = (Dali::Vector3 *)jarg2;
4293   if (!arg2) {
4294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4295     return 0;
4296   }
4297   {
4298     try {
4299       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
4300     } CALL_CATCH_EXCEPTION(0);
4301   }
4302
4303   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4304   return jresult;
4305 }
4306
4307
4308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
4309   void * jresult ;
4310   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4311   Dali::Vector3 *arg2 = 0 ;
4312   Dali::Vector3 *result = 0 ;
4313
4314   arg1 = (Dali::Vector3 *)jarg1;
4315   arg2 = (Dali::Vector3 *)jarg2;
4316   if (!arg2) {
4317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4318     return 0;
4319   }
4320   {
4321     try {
4322       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
4323     } CALL_CATCH_EXCEPTION(0);
4324   }
4325
4326   jresult = (void *)result;
4327   return jresult;
4328 }
4329
4330
4331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4332   void * jresult ;
4333   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4334   Dali::Vector3 *arg2 = 0 ;
4335   Dali::Vector3 result;
4336
4337   arg1 = (Dali::Vector3 *)jarg1;
4338   arg2 = (Dali::Vector3 *)jarg2;
4339   if (!arg2) {
4340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4341     return 0;
4342   }
4343   {
4344     try {
4345       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
4346     } CALL_CATCH_EXCEPTION(0);
4347   }
4348
4349   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4350   return jresult;
4351 }
4352
4353
4354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
4355   void * jresult ;
4356   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4357   float arg2 ;
4358   Dali::Vector3 result;
4359
4360   arg1 = (Dali::Vector3 *)jarg1;
4361   arg2 = (float)jarg2;
4362   {
4363     try {
4364       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
4365     } CALL_CATCH_EXCEPTION(0);
4366   }
4367
4368   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4369   return jresult;
4370 }
4371
4372
4373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4374   void * jresult ;
4375   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4376   Dali::Vector3 *arg2 = 0 ;
4377   Dali::Vector3 *result = 0 ;
4378
4379   arg1 = (Dali::Vector3 *)jarg1;
4380   arg2 = (Dali::Vector3 *)jarg2;
4381   if (!arg2) {
4382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4383     return 0;
4384   }
4385   {
4386     try {
4387       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
4388     } CALL_CATCH_EXCEPTION(0);
4389   }
4390
4391   jresult = (void *)result;
4392   return jresult;
4393 }
4394
4395
4396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4397   void * jresult ;
4398   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4399   float arg2 ;
4400   Dali::Vector3 *result = 0 ;
4401
4402   arg1 = (Dali::Vector3 *)jarg1;
4403   arg2 = (float)jarg2;
4404   {
4405     try {
4406       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
4407     } CALL_CATCH_EXCEPTION(0);
4408   }
4409
4410   jresult = (void *)result;
4411   return jresult;
4412 }
4413
4414
4415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
4416   void * jresult ;
4417   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4418   Dali::Quaternion *arg2 = 0 ;
4419   Dali::Vector3 *result = 0 ;
4420
4421   arg1 = (Dali::Vector3 *)jarg1;
4422   arg2 = (Dali::Quaternion *)jarg2;
4423   if (!arg2) {
4424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
4425     return 0;
4426   }
4427   {
4428     try {
4429       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
4430     } CALL_CATCH_EXCEPTION(0);
4431   }
4432
4433   jresult = (void *)result;
4434   return jresult;
4435 }
4436
4437
4438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
4439   void * jresult ;
4440   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4441   Dali::Vector3 *arg2 = 0 ;
4442   Dali::Vector3 result;
4443
4444   arg1 = (Dali::Vector3 *)jarg1;
4445   arg2 = (Dali::Vector3 *)jarg2;
4446   if (!arg2) {
4447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4448     return 0;
4449   }
4450   {
4451     try {
4452       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
4453     } CALL_CATCH_EXCEPTION(0);
4454   }
4455
4456   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4457   return jresult;
4458 }
4459
4460
4461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
4462   void * jresult ;
4463   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4464   float arg2 ;
4465   Dali::Vector3 result;
4466
4467   arg1 = (Dali::Vector3 *)jarg1;
4468   arg2 = (float)jarg2;
4469   {
4470     try {
4471       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
4472     } CALL_CATCH_EXCEPTION(0);
4473   }
4474
4475   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4476   return jresult;
4477 }
4478
4479
4480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4481   void * jresult ;
4482   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4483   Dali::Vector3 *arg2 = 0 ;
4484   Dali::Vector3 *result = 0 ;
4485
4486   arg1 = (Dali::Vector3 *)jarg1;
4487   arg2 = (Dali::Vector3 *)jarg2;
4488   if (!arg2) {
4489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4490     return 0;
4491   }
4492   {
4493     try {
4494       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
4495     } CALL_CATCH_EXCEPTION(0);
4496   }
4497
4498   jresult = (void *)result;
4499   return jresult;
4500 }
4501
4502
4503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4504   void * jresult ;
4505   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4506   float arg2 ;
4507   Dali::Vector3 *result = 0 ;
4508
4509   arg1 = (Dali::Vector3 *)jarg1;
4510   arg2 = (float)jarg2;
4511   {
4512     try {
4513       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
4514     } CALL_CATCH_EXCEPTION(0);
4515   }
4516
4517   jresult = (void *)result;
4518   return jresult;
4519 }
4520
4521
4522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
4523   void * jresult ;
4524   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4525   Dali::Vector3 result;
4526
4527   arg1 = (Dali::Vector3 *)jarg1;
4528   {
4529     try {
4530       result = ((Dali::Vector3 const *)arg1)->operator -();
4531     } CALL_CATCH_EXCEPTION(0);
4532   }
4533
4534   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4535   return jresult;
4536 }
4537
4538
4539 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
4540   bool jresult ;
4541   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4542   Dali::Vector3 *arg2 = 0 ;
4543   bool result;
4544
4545   arg1 = (Dali::Vector3 *)jarg1;
4546   arg2 = (Dali::Vector3 *)jarg2;
4547   if (!arg2) {
4548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4549     return 0;
4550   }
4551   {
4552     try {
4553       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
4554     } CALL_CATCH_EXCEPTION(0);
4555   }
4556
4557   jresult = result;
4558   return jresult;
4559 }
4560
4561
4562 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
4563   bool jresult ;
4564   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4565   Dali::Vector3 *arg2 = 0 ;
4566   bool result;
4567
4568   arg1 = (Dali::Vector3 *)jarg1;
4569   arg2 = (Dali::Vector3 *)jarg2;
4570   if (!arg2) {
4571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4572     return 0;
4573   }
4574   {
4575     try {
4576       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
4577     } CALL_CATCH_EXCEPTION(0);
4578   }
4579
4580   jresult = result;
4581   return jresult;
4582 }
4583
4584
4585 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4586   float jresult ;
4587   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4588   unsigned int arg2 ;
4589   float *result = 0 ;
4590
4591   arg1 = (Dali::Vector3 *)jarg1;
4592   arg2 = (unsigned int)jarg2;
4593   {
4594     try {
4595       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
4596     } CALL_CATCH_EXCEPTION(0);
4597   }
4598
4599   jresult = *result;
4600   return jresult;
4601 }
4602
4603
4604 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
4605   float jresult ;
4606   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4607   Dali::Vector3 *arg2 = 0 ;
4608   float result;
4609
4610   arg1 = (Dali::Vector3 *)jarg1;
4611   arg2 = (Dali::Vector3 *)jarg2;
4612   if (!arg2) {
4613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4614     return 0;
4615   }
4616   {
4617     try {
4618       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
4619     } CALL_CATCH_EXCEPTION(0);
4620   }
4621
4622   jresult = result;
4623   return jresult;
4624 }
4625
4626
4627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
4628   void * jresult ;
4629   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4630   Dali::Vector3 *arg2 = 0 ;
4631   Dali::Vector3 result;
4632
4633   arg1 = (Dali::Vector3 *)jarg1;
4634   arg2 = (Dali::Vector3 *)jarg2;
4635   if (!arg2) {
4636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4637     return 0;
4638   }
4639   {
4640     try {
4641       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
4642     } CALL_CATCH_EXCEPTION(0);
4643   }
4644
4645   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4646   return jresult;
4647 }
4648
4649
4650 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
4651   float jresult ;
4652   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4653   float result;
4654
4655   arg1 = (Dali::Vector3 *)jarg1;
4656   {
4657     try {
4658       result = (float)((Dali::Vector3 const *)arg1)->Length();
4659     } CALL_CATCH_EXCEPTION(0);
4660   }
4661
4662   jresult = result;
4663   return jresult;
4664 }
4665
4666
4667 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
4668   float jresult ;
4669   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4670   float result;
4671
4672   arg1 = (Dali::Vector3 *)jarg1;
4673   {
4674     try {
4675       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
4676     } CALL_CATCH_EXCEPTION(0);
4677   }
4678
4679   jresult = result;
4680   return jresult;
4681 }
4682
4683
4684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
4685   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4686
4687   arg1 = (Dali::Vector3 *)jarg1;
4688   {
4689     try {
4690       (arg1)->Normalize();
4691     } CALL_CATCH_EXCEPTION();
4692   }
4693
4694 }
4695
4696
4697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4698   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4699   Dali::Vector3 *arg2 = 0 ;
4700   Dali::Vector3 *arg3 = 0 ;
4701
4702   arg1 = (Dali::Vector3 *)jarg1;
4703   arg2 = (Dali::Vector3 *)jarg2;
4704   if (!arg2) {
4705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4706     return ;
4707   }
4708   arg3 = (Dali::Vector3 *)jarg3;
4709   if (!arg3) {
4710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4711     return ;
4712   }
4713   {
4714     try {
4715       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
4716     } CALL_CATCH_EXCEPTION();
4717   }
4718
4719 }
4720
4721
4722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
4723   void * jresult ;
4724   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4725   float *result = 0 ;
4726
4727   arg1 = (Dali::Vector3 *)jarg1;
4728   {
4729     try {
4730       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
4731     } CALL_CATCH_EXCEPTION(0);
4732   }
4733
4734   jresult = (void *)result;
4735   return jresult;
4736 }
4737
4738
4739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
4740   void * jresult ;
4741   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4742   Dali::Vector2 *result = 0 ;
4743
4744   arg1 = (Dali::Vector3 *)jarg1;
4745   {
4746     try {
4747       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
4748     } CALL_CATCH_EXCEPTION(0);
4749   }
4750
4751   jresult = (void *)result;
4752   return jresult;
4753 }
4754
4755
4756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
4757   void * jresult ;
4758   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4759   Dali::Vector2 *result = 0 ;
4760
4761   arg1 = (Dali::Vector3 *)jarg1;
4762   {
4763     try {
4764       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
4765     } CALL_CATCH_EXCEPTION(0);
4766   }
4767
4768   jresult = (void *)result;
4769   return jresult;
4770 }
4771
4772
4773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
4774   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4775   float arg2 ;
4776
4777   arg1 = (Dali::Vector3 *)jarg1;
4778   arg2 = (float)jarg2;
4779   if (arg1) (arg1)->x = arg2;
4780 }
4781
4782
4783 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
4784   float jresult ;
4785   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4786   float result;
4787
4788   arg1 = (Dali::Vector3 *)jarg1;
4789   result = (float) ((arg1)->x);
4790   jresult = result;
4791   return jresult;
4792 }
4793
4794
4795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
4796   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4797   float arg2 ;
4798
4799   arg1 = (Dali::Vector3 *)jarg1;
4800   arg2 = (float)jarg2;
4801   if (arg1) (arg1)->width = arg2;
4802 }
4803
4804
4805 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
4806   float jresult ;
4807   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4808   float result;
4809
4810   arg1 = (Dali::Vector3 *)jarg1;
4811   result = (float) ((arg1)->width);
4812   jresult = result;
4813   return jresult;
4814 }
4815
4816
4817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
4818   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4819   float arg2 ;
4820
4821   arg1 = (Dali::Vector3 *)jarg1;
4822   arg2 = (float)jarg2;
4823   if (arg1) (arg1)->r = arg2;
4824 }
4825
4826
4827 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
4828   float jresult ;
4829   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4830   float result;
4831
4832   arg1 = (Dali::Vector3 *)jarg1;
4833   result = (float) ((arg1)->r);
4834   jresult = result;
4835   return jresult;
4836 }
4837
4838
4839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
4840   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4841   float arg2 ;
4842
4843   arg1 = (Dali::Vector3 *)jarg1;
4844   arg2 = (float)jarg2;
4845   if (arg1) (arg1)->y = arg2;
4846 }
4847
4848
4849 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
4850   float jresult ;
4851   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4852   float result;
4853
4854   arg1 = (Dali::Vector3 *)jarg1;
4855   result = (float) ((arg1)->y);
4856   jresult = result;
4857   return jresult;
4858 }
4859
4860
4861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
4862   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4863   float arg2 ;
4864
4865   arg1 = (Dali::Vector3 *)jarg1;
4866   arg2 = (float)jarg2;
4867   if (arg1) (arg1)->height = arg2;
4868 }
4869
4870
4871 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
4872   float jresult ;
4873   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4874   float result;
4875
4876   arg1 = (Dali::Vector3 *)jarg1;
4877   result = (float) ((arg1)->height);
4878   jresult = result;
4879   return jresult;
4880 }
4881
4882
4883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
4884   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4885   float arg2 ;
4886
4887   arg1 = (Dali::Vector3 *)jarg1;
4888   arg2 = (float)jarg2;
4889   if (arg1) (arg1)->g = arg2;
4890 }
4891
4892
4893 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
4894   float jresult ;
4895   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4896   float result;
4897
4898   arg1 = (Dali::Vector3 *)jarg1;
4899   result = (float) ((arg1)->g);
4900   jresult = result;
4901   return jresult;
4902 }
4903
4904
4905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
4906   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4907   float arg2 ;
4908
4909   arg1 = (Dali::Vector3 *)jarg1;
4910   arg2 = (float)jarg2;
4911   if (arg1) (arg1)->z = arg2;
4912 }
4913
4914
4915 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
4916   float jresult ;
4917   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4918   float result;
4919
4920   arg1 = (Dali::Vector3 *)jarg1;
4921   result = (float) ((arg1)->z);
4922   jresult = result;
4923   return jresult;
4924 }
4925
4926
4927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
4928   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4929   float arg2 ;
4930
4931   arg1 = (Dali::Vector3 *)jarg1;
4932   arg2 = (float)jarg2;
4933   if (arg1) (arg1)->depth = arg2;
4934 }
4935
4936
4937 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
4938   float jresult ;
4939   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4940   float result;
4941
4942   arg1 = (Dali::Vector3 *)jarg1;
4943   result = (float) ((arg1)->depth);
4944   jresult = result;
4945   return jresult;
4946 }
4947
4948
4949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
4950   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4951   float arg2 ;
4952
4953   arg1 = (Dali::Vector3 *)jarg1;
4954   arg2 = (float)jarg2;
4955   if (arg1) (arg1)->b = arg2;
4956 }
4957
4958
4959 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
4960   float jresult ;
4961   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4962   float result;
4963
4964   arg1 = (Dali::Vector3 *)jarg1;
4965   result = (float) ((arg1)->b);
4966   jresult = result;
4967   return jresult;
4968 }
4969
4970
4971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
4972   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4973
4974   arg1 = (Dali::Vector3 *)jarg1;
4975   {
4976     try {
4977       delete arg1;
4978     } CALL_CATCH_EXCEPTION();
4979   }
4980
4981 }
4982
4983
4984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
4985   void * jresult ;
4986   Dali::Vector3 *arg1 = 0 ;
4987   Dali::Vector3 *arg2 = 0 ;
4988   Dali::Vector3 result;
4989
4990   arg1 = (Dali::Vector3 *)jarg1;
4991   if (!arg1) {
4992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4993     return 0;
4994   }
4995   arg2 = (Dali::Vector3 *)jarg2;
4996   if (!arg2) {
4997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4998     return 0;
4999   }
5000   {
5001     try {
5002       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
5003     } CALL_CATCH_EXCEPTION(0);
5004   }
5005
5006   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5007   return jresult;
5008 }
5009
5010
5011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
5012   void * jresult ;
5013   Dali::Vector3 *arg1 = 0 ;
5014   Dali::Vector3 *arg2 = 0 ;
5015   Dali::Vector3 result;
5016
5017   arg1 = (Dali::Vector3 *)jarg1;
5018   if (!arg1) {
5019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5020     return 0;
5021   }
5022   arg2 = (Dali::Vector3 *)jarg2;
5023   if (!arg2) {
5024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5025     return 0;
5026   }
5027   {
5028     try {
5029       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
5030     } CALL_CATCH_EXCEPTION(0);
5031   }
5032
5033   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5034   return jresult;
5035 }
5036
5037
5038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
5039   void * jresult ;
5040   Dali::Vector3 *arg1 = 0 ;
5041   float *arg2 = 0 ;
5042   float *arg3 = 0 ;
5043   float temp2 ;
5044   float temp3 ;
5045   Dali::Vector3 result;
5046
5047   arg1 = (Dali::Vector3 *)jarg1;
5048   if (!arg1) {
5049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5050     return 0;
5051   }
5052   temp2 = (float)jarg2;
5053   arg2 = &temp2;
5054   temp3 = (float)jarg3;
5055   arg3 = &temp3;
5056   {
5057     try {
5058       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5059     } CALL_CATCH_EXCEPTION(0);
5060   }
5061
5062   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5063   return jresult;
5064 }
5065
5066
5067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
5068   void * jresult ;
5069   Dali::Vector4 *result = 0 ;
5070
5071   {
5072     try {
5073       result = (Dali::Vector4 *)new Dali::Vector4();
5074     } CALL_CATCH_EXCEPTION(0);
5075   }
5076
5077   jresult = (void *)result;
5078   return jresult;
5079 }
5080
5081
5082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
5083   void * jresult ;
5084   float arg1 ;
5085   float arg2 ;
5086   float arg3 ;
5087   float arg4 ;
5088   Dali::Vector4 *result = 0 ;
5089
5090   arg1 = (float)jarg1;
5091   arg2 = (float)jarg2;
5092   arg3 = (float)jarg3;
5093   arg4 = (float)jarg4;
5094   {
5095     try {
5096       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
5097     } CALL_CATCH_EXCEPTION(0);
5098   }
5099
5100   jresult = (void *)result;
5101   return jresult;
5102 }
5103
5104
5105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
5106   void * jresult ;
5107   float *arg1 = (float *) 0 ;
5108   Dali::Vector4 *result = 0 ;
5109
5110   arg1 = jarg1;
5111   {
5112     try {
5113       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
5114     } CALL_CATCH_EXCEPTION(0);
5115   }
5116
5117   jresult = (void *)result;
5118
5119
5120   return jresult;
5121 }
5122
5123
5124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
5125   void * jresult ;
5126   Dali::Vector2 *arg1 = 0 ;
5127   Dali::Vector4 *result = 0 ;
5128
5129   arg1 = (Dali::Vector2 *)jarg1;
5130   if (!arg1) {
5131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5132     return 0;
5133   }
5134   {
5135     try {
5136       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
5137     } CALL_CATCH_EXCEPTION(0);
5138   }
5139
5140   jresult = (void *)result;
5141   return jresult;
5142 }
5143
5144
5145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
5146   void * jresult ;
5147   Dali::Vector3 *arg1 = 0 ;
5148   Dali::Vector4 *result = 0 ;
5149
5150   arg1 = (Dali::Vector3 *)jarg1;
5151   if (!arg1) {
5152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5153     return 0;
5154   }
5155   {
5156     try {
5157       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
5158     } CALL_CATCH_EXCEPTION(0);
5159   }
5160
5161   jresult = (void *)result;
5162   return jresult;
5163 }
5164
5165
5166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
5167   void * jresult ;
5168   Dali::Vector4 *result = 0 ;
5169
5170   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
5171   jresult = (void *)result;
5172   return jresult;
5173 }
5174
5175
5176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
5177   void * jresult ;
5178   Dali::Vector4 *result = 0 ;
5179
5180   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
5181   jresult = (void *)result;
5182   return jresult;
5183 }
5184
5185
5186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
5187   void * jresult ;
5188   Dali::Vector4 *result = 0 ;
5189
5190   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
5191   jresult = (void *)result;
5192   return jresult;
5193 }
5194
5195
5196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
5197   void * jresult ;
5198   Dali::Vector4 *result = 0 ;
5199
5200   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
5201   jresult = (void *)result;
5202   return jresult;
5203 }
5204
5205
5206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
5207   void * jresult ;
5208   Dali::Vector4 *result = 0 ;
5209
5210   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
5211   jresult = (void *)result;
5212   return jresult;
5213 }
5214
5215
5216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
5217   void * jresult ;
5218   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5219   float *arg2 = (float *) 0 ;
5220   Dali::Vector4 *result = 0 ;
5221
5222   arg1 = (Dali::Vector4 *)jarg1;
5223   arg2 = jarg2;
5224   {
5225     try {
5226       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
5227     } CALL_CATCH_EXCEPTION(0);
5228   }
5229
5230   jresult = (void *)result;
5231
5232
5233   return jresult;
5234 }
5235
5236
5237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
5238   void * jresult ;
5239   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5240   Dali::Vector2 *arg2 = 0 ;
5241   Dali::Vector4 *result = 0 ;
5242
5243   arg1 = (Dali::Vector4 *)jarg1;
5244   arg2 = (Dali::Vector2 *)jarg2;
5245   if (!arg2) {
5246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5247     return 0;
5248   }
5249   {
5250     try {
5251       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5252     } CALL_CATCH_EXCEPTION(0);
5253   }
5254
5255   jresult = (void *)result;
5256   return jresult;
5257 }
5258
5259
5260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
5261   void * jresult ;
5262   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5263   Dali::Vector3 *arg2 = 0 ;
5264   Dali::Vector4 *result = 0 ;
5265
5266   arg1 = (Dali::Vector4 *)jarg1;
5267   arg2 = (Dali::Vector3 *)jarg2;
5268   if (!arg2) {
5269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5270     return 0;
5271   }
5272   {
5273     try {
5274       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
5275     } CALL_CATCH_EXCEPTION(0);
5276   }
5277
5278   jresult = (void *)result;
5279   return jresult;
5280 }
5281
5282
5283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
5284   void * jresult ;
5285   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5286   Dali::Vector4 *arg2 = 0 ;
5287   Dali::Vector4 result;
5288
5289   arg1 = (Dali::Vector4 *)jarg1;
5290   arg2 = (Dali::Vector4 *)jarg2;
5291   if (!arg2) {
5292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5293     return 0;
5294   }
5295   {
5296     try {
5297       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
5298     } CALL_CATCH_EXCEPTION(0);
5299   }
5300
5301   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5302   return jresult;
5303 }
5304
5305
5306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
5307   void * jresult ;
5308   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5309   Dali::Vector4 *arg2 = 0 ;
5310   Dali::Vector4 *result = 0 ;
5311
5312   arg1 = (Dali::Vector4 *)jarg1;
5313   arg2 = (Dali::Vector4 *)jarg2;
5314   if (!arg2) {
5315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5316     return 0;
5317   }
5318   {
5319     try {
5320       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
5321     } CALL_CATCH_EXCEPTION(0);
5322   }
5323
5324   jresult = (void *)result;
5325   return jresult;
5326 }
5327
5328
5329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5330   void * jresult ;
5331   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5332   Dali::Vector4 *arg2 = 0 ;
5333   Dali::Vector4 result;
5334
5335   arg1 = (Dali::Vector4 *)jarg1;
5336   arg2 = (Dali::Vector4 *)jarg2;
5337   if (!arg2) {
5338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5339     return 0;
5340   }
5341   {
5342     try {
5343       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
5344     } CALL_CATCH_EXCEPTION(0);
5345   }
5346
5347   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5348   return jresult;
5349 }
5350
5351
5352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
5353   void * jresult ;
5354   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5355   Dali::Vector4 *arg2 = 0 ;
5356   Dali::Vector4 *result = 0 ;
5357
5358   arg1 = (Dali::Vector4 *)jarg1;
5359   arg2 = (Dali::Vector4 *)jarg2;
5360   if (!arg2) {
5361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5362     return 0;
5363   }
5364   {
5365     try {
5366       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
5367     } CALL_CATCH_EXCEPTION(0);
5368   }
5369
5370   jresult = (void *)result;
5371   return jresult;
5372 }
5373
5374
5375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5376   void * jresult ;
5377   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5378   Dali::Vector4 *arg2 = 0 ;
5379   Dali::Vector4 result;
5380
5381   arg1 = (Dali::Vector4 *)jarg1;
5382   arg2 = (Dali::Vector4 *)jarg2;
5383   if (!arg2) {
5384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5385     return 0;
5386   }
5387   {
5388     try {
5389       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
5390     } CALL_CATCH_EXCEPTION(0);
5391   }
5392
5393   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5394   return jresult;
5395 }
5396
5397
5398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
5399   void * jresult ;
5400   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5401   float arg2 ;
5402   Dali::Vector4 result;
5403
5404   arg1 = (Dali::Vector4 *)jarg1;
5405   arg2 = (float)jarg2;
5406   {
5407     try {
5408       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
5409     } CALL_CATCH_EXCEPTION(0);
5410   }
5411
5412   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5413   return jresult;
5414 }
5415
5416
5417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5418   void * jresult ;
5419   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5420   Dali::Vector4 *arg2 = 0 ;
5421   Dali::Vector4 *result = 0 ;
5422
5423   arg1 = (Dali::Vector4 *)jarg1;
5424   arg2 = (Dali::Vector4 *)jarg2;
5425   if (!arg2) {
5426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5427     return 0;
5428   }
5429   {
5430     try {
5431       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
5432     } CALL_CATCH_EXCEPTION(0);
5433   }
5434
5435   jresult = (void *)result;
5436   return jresult;
5437 }
5438
5439
5440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5441   void * jresult ;
5442   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5443   float arg2 ;
5444   Dali::Vector4 *result = 0 ;
5445
5446   arg1 = (Dali::Vector4 *)jarg1;
5447   arg2 = (float)jarg2;
5448   {
5449     try {
5450       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
5451     } CALL_CATCH_EXCEPTION(0);
5452   }
5453
5454   jresult = (void *)result;
5455   return jresult;
5456 }
5457
5458
5459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
5460   void * jresult ;
5461   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5462   Dali::Vector4 *arg2 = 0 ;
5463   Dali::Vector4 result;
5464
5465   arg1 = (Dali::Vector4 *)jarg1;
5466   arg2 = (Dali::Vector4 *)jarg2;
5467   if (!arg2) {
5468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5469     return 0;
5470   }
5471   {
5472     try {
5473       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
5474     } CALL_CATCH_EXCEPTION(0);
5475   }
5476
5477   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5478   return jresult;
5479 }
5480
5481
5482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
5483   void * jresult ;
5484   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5485   float arg2 ;
5486   Dali::Vector4 result;
5487
5488   arg1 = (Dali::Vector4 *)jarg1;
5489   arg2 = (float)jarg2;
5490   {
5491     try {
5492       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
5493     } CALL_CATCH_EXCEPTION(0);
5494   }
5495
5496   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5497   return jresult;
5498 }
5499
5500
5501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5502   void * jresult ;
5503   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5504   Dali::Vector4 *arg2 = 0 ;
5505   Dali::Vector4 *result = 0 ;
5506
5507   arg1 = (Dali::Vector4 *)jarg1;
5508   arg2 = (Dali::Vector4 *)jarg2;
5509   if (!arg2) {
5510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5511     return 0;
5512   }
5513   {
5514     try {
5515       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
5516     } CALL_CATCH_EXCEPTION(0);
5517   }
5518
5519   jresult = (void *)result;
5520   return jresult;
5521 }
5522
5523
5524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5525   void * jresult ;
5526   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5527   float arg2 ;
5528   Dali::Vector4 *result = 0 ;
5529
5530   arg1 = (Dali::Vector4 *)jarg1;
5531   arg2 = (float)jarg2;
5532   {
5533     try {
5534       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
5535     } CALL_CATCH_EXCEPTION(0);
5536   }
5537
5538   jresult = (void *)result;
5539   return jresult;
5540 }
5541
5542
5543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
5544   void * jresult ;
5545   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5546   Dali::Vector4 result;
5547
5548   arg1 = (Dali::Vector4 *)jarg1;
5549   {
5550     try {
5551       result = ((Dali::Vector4 const *)arg1)->operator -();
5552     } CALL_CATCH_EXCEPTION(0);
5553   }
5554
5555   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5556   return jresult;
5557 }
5558
5559
5560 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
5561   bool jresult ;
5562   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5563   Dali::Vector4 *arg2 = 0 ;
5564   bool result;
5565
5566   arg1 = (Dali::Vector4 *)jarg1;
5567   arg2 = (Dali::Vector4 *)jarg2;
5568   if (!arg2) {
5569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5570     return 0;
5571   }
5572   {
5573     try {
5574       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
5575     } CALL_CATCH_EXCEPTION(0);
5576   }
5577
5578   jresult = result;
5579   return jresult;
5580 }
5581
5582
5583 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
5584   bool jresult ;
5585   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5586   Dali::Vector4 *arg2 = 0 ;
5587   bool result;
5588
5589   arg1 = (Dali::Vector4 *)jarg1;
5590   arg2 = (Dali::Vector4 *)jarg2;
5591   if (!arg2) {
5592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5593     return 0;
5594   }
5595   {
5596     try {
5597       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
5598     } CALL_CATCH_EXCEPTION(0);
5599   }
5600
5601   jresult = result;
5602   return jresult;
5603 }
5604
5605
5606 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5607   float jresult ;
5608   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5609   unsigned int arg2 ;
5610   float *result = 0 ;
5611
5612   arg1 = (Dali::Vector4 *)jarg1;
5613   arg2 = (unsigned int)jarg2;
5614   {
5615     try {
5616       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
5617     } CALL_CATCH_EXCEPTION(0);
5618   }
5619
5620   jresult = *result;
5621   return jresult;
5622 }
5623
5624
5625 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
5626   float jresult ;
5627   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5628   Dali::Vector3 *arg2 = 0 ;
5629   float result;
5630
5631   arg1 = (Dali::Vector4 *)jarg1;
5632   arg2 = (Dali::Vector3 *)jarg2;
5633   if (!arg2) {
5634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5635     return 0;
5636   }
5637   {
5638     try {
5639       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5640     } CALL_CATCH_EXCEPTION(0);
5641   }
5642
5643   jresult = result;
5644   return jresult;
5645 }
5646
5647
5648 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
5649   float jresult ;
5650   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5651   Dali::Vector4 *arg2 = 0 ;
5652   float result;
5653
5654   arg1 = (Dali::Vector4 *)jarg1;
5655   arg2 = (Dali::Vector4 *)jarg2;
5656   if (!arg2) {
5657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5658     return 0;
5659   }
5660   {
5661     try {
5662       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
5663     } CALL_CATCH_EXCEPTION(0);
5664   }
5665
5666   jresult = result;
5667   return jresult;
5668 }
5669
5670
5671 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
5672   float jresult ;
5673   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5674   Dali::Vector4 *arg2 = 0 ;
5675   float result;
5676
5677   arg1 = (Dali::Vector4 *)jarg1;
5678   arg2 = (Dali::Vector4 *)jarg2;
5679   if (!arg2) {
5680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5681     return 0;
5682   }
5683   {
5684     try {
5685       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
5686     } CALL_CATCH_EXCEPTION(0);
5687   }
5688
5689   jresult = result;
5690   return jresult;
5691 }
5692
5693
5694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
5695   void * jresult ;
5696   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5697   Dali::Vector4 *arg2 = 0 ;
5698   Dali::Vector4 result;
5699
5700   arg1 = (Dali::Vector4 *)jarg1;
5701   arg2 = (Dali::Vector4 *)jarg2;
5702   if (!arg2) {
5703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5704     return 0;
5705   }
5706   {
5707     try {
5708       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
5709     } CALL_CATCH_EXCEPTION(0);
5710   }
5711
5712   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5713   return jresult;
5714 }
5715
5716
5717 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
5718   float jresult ;
5719   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5720   float result;
5721
5722   arg1 = (Dali::Vector4 *)jarg1;
5723   {
5724     try {
5725       result = (float)((Dali::Vector4 const *)arg1)->Length();
5726     } CALL_CATCH_EXCEPTION(0);
5727   }
5728
5729   jresult = result;
5730   return jresult;
5731 }
5732
5733
5734 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
5735   float jresult ;
5736   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5737   float result;
5738
5739   arg1 = (Dali::Vector4 *)jarg1;
5740   {
5741     try {
5742       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
5743     } CALL_CATCH_EXCEPTION(0);
5744   }
5745
5746   jresult = result;
5747   return jresult;
5748 }
5749
5750
5751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
5752   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5753
5754   arg1 = (Dali::Vector4 *)jarg1;
5755   {
5756     try {
5757       (arg1)->Normalize();
5758     } CALL_CATCH_EXCEPTION();
5759   }
5760
5761 }
5762
5763
5764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5765   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5766   Dali::Vector4 *arg2 = 0 ;
5767   Dali::Vector4 *arg3 = 0 ;
5768
5769   arg1 = (Dali::Vector4 *)jarg1;
5770   arg2 = (Dali::Vector4 *)jarg2;
5771   if (!arg2) {
5772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5773     return ;
5774   }
5775   arg3 = (Dali::Vector4 *)jarg3;
5776   if (!arg3) {
5777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5778     return ;
5779   }
5780   {
5781     try {
5782       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
5783     } CALL_CATCH_EXCEPTION();
5784   }
5785
5786 }
5787
5788
5789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
5790   void * jresult ;
5791   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5792   float *result = 0 ;
5793
5794   arg1 = (Dali::Vector4 *)jarg1;
5795   {
5796     try {
5797       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
5798     } CALL_CATCH_EXCEPTION(0);
5799   }
5800
5801   jresult = (void *)result;
5802   return jresult;
5803 }
5804
5805
5806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
5807   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5808   float arg2 ;
5809
5810   arg1 = (Dali::Vector4 *)jarg1;
5811   arg2 = (float)jarg2;
5812   if (arg1) (arg1)->x = arg2;
5813 }
5814
5815
5816 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
5817   float jresult ;
5818   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5819   float result;
5820
5821   arg1 = (Dali::Vector4 *)jarg1;
5822   result = (float) ((arg1)->x);
5823   jresult = result;
5824   return jresult;
5825 }
5826
5827
5828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
5829   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5830   float arg2 ;
5831
5832   arg1 = (Dali::Vector4 *)jarg1;
5833   arg2 = (float)jarg2;
5834   if (arg1) (arg1)->r = arg2;
5835 }
5836
5837
5838 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
5839   float jresult ;
5840   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5841   float result;
5842
5843   arg1 = (Dali::Vector4 *)jarg1;
5844   result = (float) ((arg1)->r);
5845   jresult = result;
5846   return jresult;
5847 }
5848
5849
5850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
5851   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5852   float arg2 ;
5853
5854   arg1 = (Dali::Vector4 *)jarg1;
5855   arg2 = (float)jarg2;
5856   if (arg1) (arg1)->s = arg2;
5857 }
5858
5859
5860 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
5861   float jresult ;
5862   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5863   float result;
5864
5865   arg1 = (Dali::Vector4 *)jarg1;
5866   result = (float) ((arg1)->s);
5867   jresult = result;
5868   return jresult;
5869 }
5870
5871
5872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
5873   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5874   float arg2 ;
5875
5876   arg1 = (Dali::Vector4 *)jarg1;
5877   arg2 = (float)jarg2;
5878   if (arg1) (arg1)->y = arg2;
5879 }
5880
5881
5882 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
5883   float jresult ;
5884   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5885   float result;
5886
5887   arg1 = (Dali::Vector4 *)jarg1;
5888   result = (float) ((arg1)->y);
5889   jresult = result;
5890   return jresult;
5891 }
5892
5893
5894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
5895   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5896   float arg2 ;
5897
5898   arg1 = (Dali::Vector4 *)jarg1;
5899   arg2 = (float)jarg2;
5900   if (arg1) (arg1)->g = arg2;
5901 }
5902
5903
5904 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
5905   float jresult ;
5906   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5907   float result;
5908
5909   arg1 = (Dali::Vector4 *)jarg1;
5910   result = (float) ((arg1)->g);
5911   jresult = result;
5912   return jresult;
5913 }
5914
5915
5916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
5917   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5918   float arg2 ;
5919
5920   arg1 = (Dali::Vector4 *)jarg1;
5921   arg2 = (float)jarg2;
5922   if (arg1) (arg1)->t = arg2;
5923 }
5924
5925
5926 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
5927   float jresult ;
5928   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5929   float result;
5930
5931   arg1 = (Dali::Vector4 *)jarg1;
5932   result = (float) ((arg1)->t);
5933   jresult = result;
5934   return jresult;
5935 }
5936
5937
5938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
5939   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5940   float arg2 ;
5941
5942   arg1 = (Dali::Vector4 *)jarg1;
5943   arg2 = (float)jarg2;
5944   if (arg1) (arg1)->z = arg2;
5945 }
5946
5947
5948 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
5949   float jresult ;
5950   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5951   float result;
5952
5953   arg1 = (Dali::Vector4 *)jarg1;
5954   result = (float) ((arg1)->z);
5955   jresult = result;
5956   return jresult;
5957 }
5958
5959
5960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
5961   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5962   float arg2 ;
5963
5964   arg1 = (Dali::Vector4 *)jarg1;
5965   arg2 = (float)jarg2;
5966   if (arg1) (arg1)->b = arg2;
5967 }
5968
5969
5970 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
5971   float jresult ;
5972   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5973   float result;
5974
5975   arg1 = (Dali::Vector4 *)jarg1;
5976   result = (float) ((arg1)->b);
5977   jresult = result;
5978   return jresult;
5979 }
5980
5981
5982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
5983   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5984   float arg2 ;
5985
5986   arg1 = (Dali::Vector4 *)jarg1;
5987   arg2 = (float)jarg2;
5988   if (arg1) (arg1)->p = arg2;
5989 }
5990
5991
5992 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
5993   float jresult ;
5994   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5995   float result;
5996
5997   arg1 = (Dali::Vector4 *)jarg1;
5998   result = (float) ((arg1)->p);
5999   jresult = result;
6000   return jresult;
6001 }
6002
6003
6004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
6005   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6006   float arg2 ;
6007
6008   arg1 = (Dali::Vector4 *)jarg1;
6009   arg2 = (float)jarg2;
6010   if (arg1) (arg1)->w = arg2;
6011 }
6012
6013
6014 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
6015   float jresult ;
6016   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6017   float result;
6018
6019   arg1 = (Dali::Vector4 *)jarg1;
6020   result = (float) ((arg1)->w);
6021   jresult = result;
6022   return jresult;
6023 }
6024
6025
6026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
6027   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6028   float arg2 ;
6029
6030   arg1 = (Dali::Vector4 *)jarg1;
6031   arg2 = (float)jarg2;
6032   if (arg1) (arg1)->a = arg2;
6033 }
6034
6035
6036 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
6037   float jresult ;
6038   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6039   float result;
6040
6041   arg1 = (Dali::Vector4 *)jarg1;
6042   result = (float) ((arg1)->a);
6043   jresult = result;
6044   return jresult;
6045 }
6046
6047
6048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
6049   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6050   float arg2 ;
6051
6052   arg1 = (Dali::Vector4 *)jarg1;
6053   arg2 = (float)jarg2;
6054   if (arg1) (arg1)->q = arg2;
6055 }
6056
6057
6058 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
6059   float jresult ;
6060   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6061   float result;
6062
6063   arg1 = (Dali::Vector4 *)jarg1;
6064   result = (float) ((arg1)->q);
6065   jresult = result;
6066   return jresult;
6067 }
6068
6069
6070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
6071   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6072
6073   arg1 = (Dali::Vector4 *)jarg1;
6074   {
6075     try {
6076       delete arg1;
6077     } CALL_CATCH_EXCEPTION();
6078   }
6079
6080 }
6081
6082
6083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
6084   void * jresult ;
6085   Dali::Vector4 *arg1 = 0 ;
6086   Dali::Vector4 *arg2 = 0 ;
6087   Dali::Vector4 result;
6088
6089   arg1 = (Dali::Vector4 *)jarg1;
6090   if (!arg1) {
6091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6092     return 0;
6093   }
6094   arg2 = (Dali::Vector4 *)jarg2;
6095   if (!arg2) {
6096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6097     return 0;
6098   }
6099   {
6100     try {
6101       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
6102     } CALL_CATCH_EXCEPTION(0);
6103   }
6104
6105   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6106   return jresult;
6107 }
6108
6109
6110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
6111   void * jresult ;
6112   Dali::Vector4 *arg1 = 0 ;
6113   Dali::Vector4 *arg2 = 0 ;
6114   Dali::Vector4 result;
6115
6116   arg1 = (Dali::Vector4 *)jarg1;
6117   if (!arg1) {
6118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6119     return 0;
6120   }
6121   arg2 = (Dali::Vector4 *)jarg2;
6122   if (!arg2) {
6123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6124     return 0;
6125   }
6126   {
6127     try {
6128       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
6129     } CALL_CATCH_EXCEPTION(0);
6130   }
6131
6132   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6133   return jresult;
6134 }
6135
6136
6137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
6138   void * jresult ;
6139   Dali::Vector4 *arg1 = 0 ;
6140   float *arg2 = 0 ;
6141   float *arg3 = 0 ;
6142   float temp2 ;
6143   float temp3 ;
6144   Dali::Vector4 result;
6145
6146   arg1 = (Dali::Vector4 *)jarg1;
6147   if (!arg1) {
6148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6149     return 0;
6150   }
6151   temp2 = (float)jarg2;
6152   arg2 = &temp2;
6153   temp3 = (float)jarg3;
6154   arg3 = &temp3;
6155   {
6156     try {
6157       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6158     } CALL_CATCH_EXCEPTION(0);
6159   }
6160
6161   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6162   return jresult;
6163 }
6164
6165
6166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
6167   void * jresult ;
6168   Dali::Uint16Pair *result = 0 ;
6169
6170   {
6171     try {
6172       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
6173     } CALL_CATCH_EXCEPTION(0);
6174   }
6175
6176   jresult = (void *)result;
6177   return jresult;
6178 }
6179
6180
6181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
6182   void * jresult ;
6183   uint32_t arg1 ;
6184   uint32_t arg2 ;
6185   Dali::Uint16Pair *result = 0 ;
6186
6187   arg1 = (uint32_t)jarg1;
6188   arg2 = (uint32_t)jarg2;
6189   {
6190     try {
6191       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
6192     } CALL_CATCH_EXCEPTION(0);
6193   }
6194
6195   jresult = (void *)result;
6196   return jresult;
6197 }
6198
6199
6200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
6201   void * jresult ;
6202   Dali::Uint16Pair *arg1 = 0 ;
6203   Dali::Uint16Pair *result = 0 ;
6204
6205   arg1 = (Dali::Uint16Pair *)jarg1;
6206   if (!arg1) {
6207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6208     return 0;
6209   }
6210   {
6211     try {
6212       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
6213     } CALL_CATCH_EXCEPTION(0);
6214   }
6215
6216   jresult = (void *)result;
6217   return jresult;
6218 }
6219
6220
6221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
6222   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6223   uint16_t arg2 ;
6224
6225   arg1 = (Dali::Uint16Pair *)jarg1;
6226   arg2 = (uint16_t)jarg2;
6227   {
6228     try {
6229       (arg1)->SetWidth(arg2);
6230     } CALL_CATCH_EXCEPTION();
6231   }
6232
6233 }
6234
6235
6236 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
6237   unsigned short jresult ;
6238   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6239   uint16_t result;
6240
6241   arg1 = (Dali::Uint16Pair *)jarg1;
6242   {
6243     try {
6244       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
6245     } CALL_CATCH_EXCEPTION(0);
6246   }
6247
6248   jresult = result;
6249   return jresult;
6250 }
6251
6252
6253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
6254   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6255   uint16_t arg2 ;
6256
6257   arg1 = (Dali::Uint16Pair *)jarg1;
6258   arg2 = (uint16_t)jarg2;
6259   {
6260     try {
6261       (arg1)->SetHeight(arg2);
6262     } CALL_CATCH_EXCEPTION();
6263   }
6264
6265 }
6266
6267
6268 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
6269   unsigned short jresult ;
6270   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6271   uint16_t result;
6272
6273   arg1 = (Dali::Uint16Pair *)jarg1;
6274   {
6275     try {
6276       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
6277     } CALL_CATCH_EXCEPTION(0);
6278   }
6279
6280   jresult = result;
6281   return jresult;
6282 }
6283
6284
6285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
6286   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6287   uint16_t arg2 ;
6288
6289   arg1 = (Dali::Uint16Pair *)jarg1;
6290   arg2 = (uint16_t)jarg2;
6291   {
6292     try {
6293       (arg1)->SetX(arg2);
6294     } CALL_CATCH_EXCEPTION();
6295   }
6296
6297 }
6298
6299
6300 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
6301   unsigned short jresult ;
6302   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6303   uint16_t result;
6304
6305   arg1 = (Dali::Uint16Pair *)jarg1;
6306   {
6307     try {
6308       result = ((Dali::Uint16Pair const *)arg1)->GetX();
6309     } CALL_CATCH_EXCEPTION(0);
6310   }
6311
6312   jresult = result;
6313   return jresult;
6314 }
6315
6316
6317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
6318   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6319   uint16_t arg2 ;
6320
6321   arg1 = (Dali::Uint16Pair *)jarg1;
6322   arg2 = (uint16_t)jarg2;
6323   {
6324     try {
6325       (arg1)->SetY(arg2);
6326     } CALL_CATCH_EXCEPTION();
6327   }
6328
6329 }
6330
6331
6332 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
6333   unsigned short jresult ;
6334   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6335   uint16_t result;
6336
6337   arg1 = (Dali::Uint16Pair *)jarg1;
6338   {
6339     try {
6340       result = ((Dali::Uint16Pair const *)arg1)->GetY();
6341     } CALL_CATCH_EXCEPTION(0);
6342   }
6343
6344   jresult = result;
6345   return jresult;
6346 }
6347
6348
6349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
6350   void * jresult ;
6351   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6352   Dali::Uint16Pair *arg2 = 0 ;
6353   Dali::Uint16Pair *result = 0 ;
6354
6355   arg1 = (Dali::Uint16Pair *)jarg1;
6356   arg2 = (Dali::Uint16Pair *)jarg2;
6357   if (!arg2) {
6358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6359     return 0;
6360   }
6361   {
6362     try {
6363       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
6364     } CALL_CATCH_EXCEPTION(0);
6365   }
6366
6367   jresult = (void *)result;
6368   return jresult;
6369 }
6370
6371
6372 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
6373   bool jresult ;
6374   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6375   Dali::Uint16Pair *arg2 = 0 ;
6376   bool result;
6377
6378   arg1 = (Dali::Uint16Pair *)jarg1;
6379   arg2 = (Dali::Uint16Pair *)jarg2;
6380   if (!arg2) {
6381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6382     return 0;
6383   }
6384   {
6385     try {
6386       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
6387     } CALL_CATCH_EXCEPTION(0);
6388   }
6389
6390   jresult = result;
6391   return jresult;
6392 }
6393
6394
6395 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
6396   bool jresult ;
6397   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6398   Dali::Uint16Pair *arg2 = 0 ;
6399   bool result;
6400
6401   arg1 = (Dali::Uint16Pair *)jarg1;
6402   arg2 = (Dali::Uint16Pair *)jarg2;
6403   if (!arg2) {
6404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6405     return 0;
6406   }
6407   {
6408     try {
6409       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
6410     } CALL_CATCH_EXCEPTION(0);
6411   }
6412
6413   jresult = result;
6414   return jresult;
6415 }
6416
6417
6418 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
6419   bool jresult ;
6420   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6421   Dali::Uint16Pair *arg2 = 0 ;
6422   bool result;
6423
6424   arg1 = (Dali::Uint16Pair *)jarg1;
6425   arg2 = (Dali::Uint16Pair *)jarg2;
6426   if (!arg2) {
6427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6428     return 0;
6429   }
6430   {
6431     try {
6432       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
6433     } CALL_CATCH_EXCEPTION(0);
6434   }
6435
6436   jresult = result;
6437   return jresult;
6438 }
6439
6440
6441 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
6442   bool jresult ;
6443   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6444   Dali::Uint16Pair *arg2 = 0 ;
6445   bool result;
6446
6447   arg1 = (Dali::Uint16Pair *)jarg1;
6448   arg2 = (Dali::Uint16Pair *)jarg2;
6449   if (!arg2) {
6450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6451     return 0;
6452   }
6453   {
6454     try {
6455       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
6456     } CALL_CATCH_EXCEPTION(0);
6457   }
6458
6459   jresult = result;
6460   return jresult;
6461 }
6462
6463
6464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
6465   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6466
6467   arg1 = (Dali::Uint16Pair *)jarg1;
6468   {
6469     try {
6470       delete arg1;
6471     } CALL_CATCH_EXCEPTION();
6472   }
6473
6474 }
6475
6476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Int32Pair__SWIG_0() {
6477   void * jresult ;
6478   Dali::Int32Pair *result = 0 ;
6479
6480   {
6481     try {
6482       result = (Dali::Int32Pair *)new Dali::Int32Pair();
6483     } CALL_CATCH_EXCEPTION(0);
6484   }
6485
6486   jresult = (void *)result;
6487   return jresult;
6488 }
6489
6490
6491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Int32Pair__SWIG_1(int32_t x, int32_t y) {
6492   void * jresult ;
6493   Dali::Int32Pair *result = 0 ;
6494
6495   {
6496     try {
6497       result = (Dali::Int32Pair *)new Dali::Int32Pair(x,y);
6498     } CALL_CATCH_EXCEPTION(0);
6499   }
6500
6501   jresult = (void *)result;
6502   return jresult;
6503 }
6504
6505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Int32Pair_SetX(void * int32Pair, int32_t x) {
6506   Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ;
6507
6508   {
6509     try {
6510       (pInt32Pair)->SetX(x);
6511     } CALL_CATCH_EXCEPTION();
6512   }
6513 }
6514
6515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Int32Pair_GetX(void * int32Pair) {
6516   int result ;
6517   Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair);
6518
6519   {
6520     try {
6521       result = ((Dali::Int32Pair const *)pInt32Pair)->GetX();
6522     } CALL_CATCH_EXCEPTION(0);
6523   }
6524
6525   return result;
6526 }
6527
6528
6529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Int32Pair_SetY(void * int32Pair, int32_t y) {
6530   Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ;
6531
6532   {
6533     try {
6534       (pInt32Pair)->SetY(y);
6535     } CALL_CATCH_EXCEPTION();
6536   }
6537
6538 }
6539
6540
6541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Int32Pair_GetY(void * int32Pair) {
6542   Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ;
6543   int result;
6544
6545   {
6546     try {
6547       result = ((Dali::Int32Pair const *)pInt32Pair)->GetY();
6548     } CALL_CATCH_EXCEPTION(0);
6549   }
6550
6551   return result;
6552 }
6553
6554
6555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Int32Pair(void * int32Pair) {
6556   Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ;
6557
6558   {
6559     try {
6560       delete pInt32Pair;
6561     } CALL_CATCH_EXCEPTION();
6562   }
6563
6564 }
6565
6566
6567
6568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
6569   void * jresult ;
6570   Dali::Degree *result = 0 ;
6571
6572   {
6573     try {
6574       result = (Dali::Degree *)new Dali::Degree();
6575     } CALL_CATCH_EXCEPTION(0);
6576   }
6577
6578   jresult = (void *)result;
6579   return jresult;
6580 }
6581
6582
6583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
6584   void * jresult ;
6585   float arg1 ;
6586   Dali::Degree *result = 0 ;
6587
6588   arg1 = (float)jarg1;
6589   {
6590     try {
6591       result = (Dali::Degree *)new Dali::Degree(arg1);
6592     } CALL_CATCH_EXCEPTION(0);
6593   }
6594
6595   jresult = (void *)result;
6596   return jresult;
6597 }
6598
6599
6600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
6601   void * jresult ;
6602   Dali::Radian arg1 ;
6603   Dali::Radian *argp1 ;
6604   Dali::Degree *result = 0 ;
6605
6606   argp1 = (Dali::Radian *)jarg1;
6607   if (!argp1) {
6608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
6609     return 0;
6610   }
6611   arg1 = *argp1;
6612   {
6613     try {
6614       result = (Dali::Degree *)new Dali::Degree(arg1);
6615     } CALL_CATCH_EXCEPTION(0);
6616   }
6617
6618   jresult = (void *)result;
6619   return jresult;
6620 }
6621
6622
6623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
6624   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
6625   float arg2 ;
6626
6627   arg1 = (Dali::Degree *)jarg1;
6628   arg2 = (float)jarg2;
6629   if (arg1) (arg1)->degree = arg2;
6630 }
6631
6632
6633 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
6634   float jresult ;
6635   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
6636   float result;
6637
6638   arg1 = (Dali::Degree *)jarg1;
6639   result = (float) ((arg1)->degree);
6640   jresult = result;
6641   return jresult;
6642 }
6643
6644
6645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
6646   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
6647
6648   arg1 = (Dali::Degree *)jarg1;
6649   {
6650     try {
6651       delete arg1;
6652     } CALL_CATCH_EXCEPTION();
6653   }
6654
6655 }
6656
6657
6658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
6659   void * jresult ;
6660   Dali::Radian *result = 0 ;
6661
6662   result = (Dali::Radian *)&Dali::ANGLE_360;
6663   jresult = (void *)result;
6664   return jresult;
6665 }
6666
6667
6668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
6669   void * jresult ;
6670   Dali::Radian *result = 0 ;
6671
6672   result = (Dali::Radian *)&Dali::ANGLE_315;
6673   jresult = (void *)result;
6674   return jresult;
6675 }
6676
6677
6678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
6679   void * jresult ;
6680   Dali::Radian *result = 0 ;
6681
6682   result = (Dali::Radian *)&Dali::ANGLE_270;
6683   jresult = (void *)result;
6684   return jresult;
6685 }
6686
6687
6688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
6689   void * jresult ;
6690   Dali::Radian *result = 0 ;
6691
6692   result = (Dali::Radian *)&Dali::ANGLE_225;
6693   jresult = (void *)result;
6694   return jresult;
6695 }
6696
6697
6698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
6699   void * jresult ;
6700   Dali::Radian *result = 0 ;
6701
6702   result = (Dali::Radian *)&Dali::ANGLE_180;
6703   jresult = (void *)result;
6704   return jresult;
6705 }
6706
6707
6708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
6709   void * jresult ;
6710   Dali::Radian *result = 0 ;
6711
6712   result = (Dali::Radian *)&Dali::ANGLE_135;
6713   jresult = (void *)result;
6714   return jresult;
6715 }
6716
6717
6718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
6719   void * jresult ;
6720   Dali::Radian *result = 0 ;
6721
6722   result = (Dali::Radian *)&Dali::ANGLE_120;
6723   jresult = (void *)result;
6724   return jresult;
6725 }
6726
6727
6728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
6729   void * jresult ;
6730   Dali::Radian *result = 0 ;
6731
6732   result = (Dali::Radian *)&Dali::ANGLE_90;
6733   jresult = (void *)result;
6734   return jresult;
6735 }
6736
6737
6738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
6739   void * jresult ;
6740   Dali::Radian *result = 0 ;
6741
6742   result = (Dali::Radian *)&Dali::ANGLE_60;
6743   jresult = (void *)result;
6744   return jresult;
6745 }
6746
6747
6748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
6749   void * jresult ;
6750   Dali::Radian *result = 0 ;
6751
6752   result = (Dali::Radian *)&Dali::ANGLE_45;
6753   jresult = (void *)result;
6754   return jresult;
6755 }
6756
6757
6758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
6759   void * jresult ;
6760   Dali::Radian *result = 0 ;
6761
6762   result = (Dali::Radian *)&Dali::ANGLE_30;
6763   jresult = (void *)result;
6764   return jresult;
6765 }
6766
6767
6768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
6769   void * jresult ;
6770   Dali::Radian *result = 0 ;
6771
6772   result = (Dali::Radian *)&Dali::ANGLE_0;
6773   jresult = (void *)result;
6774   return jresult;
6775 }
6776
6777
6778 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
6779   bool jresult ;
6780   Dali::Degree *arg1 = 0 ;
6781   Dali::Degree *arg2 = 0 ;
6782   bool result;
6783
6784   arg1 = (Dali::Degree *)jarg1;
6785   if (!arg1) {
6786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6787     return 0;
6788   }
6789   arg2 = (Dali::Degree *)jarg2;
6790   if (!arg2) {
6791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6792     return 0;
6793   }
6794   {
6795     try {
6796       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
6797     } CALL_CATCH_EXCEPTION(0);
6798   }
6799
6800   jresult = result;
6801   return jresult;
6802 }
6803
6804
6805 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
6806   bool jresult ;
6807   Dali::Degree *arg1 = 0 ;
6808   Dali::Degree *arg2 = 0 ;
6809   bool result;
6810
6811   arg1 = (Dali::Degree *)jarg1;
6812   if (!arg1) {
6813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6814     return 0;
6815   }
6816   arg2 = (Dali::Degree *)jarg2;
6817   if (!arg2) {
6818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6819     return 0;
6820   }
6821   {
6822     try {
6823       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
6824     } CALL_CATCH_EXCEPTION(0);
6825   }
6826
6827   jresult = result;
6828   return jresult;
6829 }
6830
6831
6832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
6833   void * jresult ;
6834   Dali::Degree arg1 ;
6835   float arg2 ;
6836   float arg3 ;
6837   Dali::Degree *argp1 ;
6838   Dali::Degree result;
6839
6840   argp1 = (Dali::Degree *)jarg1;
6841   if (!argp1) {
6842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
6843     return 0;
6844   }
6845   arg1 = *argp1;
6846   arg2 = (float)jarg2;
6847   arg3 = (float)jarg3;
6848   {
6849     try {
6850       result = Dali::Clamp(arg1,arg2,arg3);
6851     } CALL_CATCH_EXCEPTION(0);
6852   }
6853
6854   jresult = new Dali::Degree((const Dali::Degree &)result);
6855   return jresult;
6856 }
6857
6858
6859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
6860   void * jresult ;
6861   Dali::Radian *result = 0 ;
6862
6863   {
6864     try {
6865       result = (Dali::Radian *)new Dali::Radian();
6866     } CALL_CATCH_EXCEPTION(0);
6867   }
6868
6869   jresult = (void *)result;
6870   return jresult;
6871 }
6872
6873
6874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
6875   void * jresult ;
6876   float arg1 ;
6877   Dali::Radian *result = 0 ;
6878
6879   arg1 = (float)jarg1;
6880   {
6881     try {
6882       result = (Dali::Radian *)new Dali::Radian(arg1);
6883     } CALL_CATCH_EXCEPTION(0);
6884   }
6885
6886   jresult = (void *)result;
6887   return jresult;
6888 }
6889
6890
6891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
6892   void * jresult ;
6893   Dali::Degree arg1 ;
6894   Dali::Degree *argp1 ;
6895   Dali::Radian *result = 0 ;
6896
6897   argp1 = (Dali::Degree *)jarg1;
6898   if (!argp1) {
6899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
6900     return 0;
6901   }
6902   arg1 = *argp1;
6903   {
6904     try {
6905       result = (Dali::Radian *)new Dali::Radian(arg1);
6906     } CALL_CATCH_EXCEPTION(0);
6907   }
6908
6909   jresult = (void *)result;
6910   return jresult;
6911 }
6912
6913
6914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
6915   void * jresult ;
6916   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
6917   float arg2 ;
6918   Dali::Radian *result = 0 ;
6919
6920   arg1 = (Dali::Radian *)jarg1;
6921   arg2 = (float)jarg2;
6922   {
6923     try {
6924       result = (Dali::Radian *) &(arg1)->operator =(arg2);
6925     } CALL_CATCH_EXCEPTION(0);
6926   }
6927
6928   jresult = (void *)result;
6929   return jresult;
6930 }
6931
6932
6933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
6934   void * jresult ;
6935   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
6936   Dali::Degree arg2 ;
6937   Dali::Degree *argp2 ;
6938   Dali::Radian *result = 0 ;
6939
6940   arg1 = (Dali::Radian *)jarg1;
6941   argp2 = (Dali::Degree *)jarg2;
6942   if (!argp2) {
6943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
6944     return 0;
6945   }
6946   arg2 = *argp2;
6947   {
6948     try {
6949       result = (Dali::Radian *) &(arg1)->operator =(arg2);
6950     } CALL_CATCH_EXCEPTION(0);
6951   }
6952
6953   jresult = (void *)result;
6954   return jresult;
6955 }
6956
6957
6958 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
6959   float jresult ;
6960   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
6961   float result;
6962
6963   arg1 = (Dali::Radian *)jarg1;
6964   {
6965     try {
6966       result = (float)((Dali::Radian const *)arg1)->operator float();
6967     } CALL_CATCH_EXCEPTION(0);
6968   }
6969
6970   jresult = result;
6971   return jresult;
6972 }
6973
6974
6975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
6976   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
6977   float arg2 ;
6978
6979   arg1 = (Dali::Radian *)jarg1;
6980   arg2 = (float)jarg2;
6981   if (arg1) (arg1)->radian = arg2;
6982 }
6983
6984
6985 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
6986   float jresult ;
6987   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
6988   float result;
6989
6990   arg1 = (Dali::Radian *)jarg1;
6991   result = (float) ((arg1)->radian);
6992   jresult = result;
6993   return jresult;
6994 }
6995
6996
6997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
6998   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
6999
7000   arg1 = (Dali::Radian *)jarg1;
7001   {
7002     try {
7003       delete arg1;
7004     } CALL_CATCH_EXCEPTION();
7005   }
7006
7007 }
7008
7009
7010 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
7011   bool jresult ;
7012   Dali::Radian arg1 ;
7013   Dali::Radian arg2 ;
7014   Dali::Radian *argp1 ;
7015   Dali::Radian *argp2 ;
7016   bool result;
7017
7018   argp1 = (Dali::Radian *)jarg1;
7019   if (!argp1) {
7020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7021     return 0;
7022   }
7023   arg1 = *argp1;
7024   argp2 = (Dali::Radian *)jarg2;
7025   if (!argp2) {
7026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7027     return 0;
7028   }
7029   arg2 = *argp2;
7030   {
7031     try {
7032       result = (bool)Dali::operator ==(arg1,arg2);
7033     } CALL_CATCH_EXCEPTION(0);
7034   }
7035
7036   jresult = result;
7037   return jresult;
7038 }
7039
7040
7041 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
7042   bool jresult ;
7043   Dali::Radian arg1 ;
7044   Dali::Radian arg2 ;
7045   Dali::Radian *argp1 ;
7046   Dali::Radian *argp2 ;
7047   bool result;
7048
7049   argp1 = (Dali::Radian *)jarg1;
7050   if (!argp1) {
7051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7052     return 0;
7053   }
7054   arg1 = *argp1;
7055   argp2 = (Dali::Radian *)jarg2;
7056   if (!argp2) {
7057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7058     return 0;
7059   }
7060   arg2 = *argp2;
7061   {
7062     try {
7063       result = (bool)Dali::operator !=(arg1,arg2);
7064     } CALL_CATCH_EXCEPTION(0);
7065   }
7066
7067   jresult = result;
7068   return jresult;
7069 }
7070
7071
7072 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
7073   bool jresult ;
7074   Dali::Radian arg1 ;
7075   Dali::Degree arg2 ;
7076   Dali::Radian *argp1 ;
7077   Dali::Degree *argp2 ;
7078   bool result;
7079
7080   argp1 = (Dali::Radian *)jarg1;
7081   if (!argp1) {
7082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7083     return 0;
7084   }
7085   arg1 = *argp1;
7086   argp2 = (Dali::Degree *)jarg2;
7087   if (!argp2) {
7088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7089     return 0;
7090   }
7091   arg2 = *argp2;
7092   {
7093     try {
7094       result = (bool)Dali::operator ==(arg1,arg2);
7095     } CALL_CATCH_EXCEPTION(0);
7096   }
7097
7098   jresult = result;
7099   return jresult;
7100 }
7101
7102
7103 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
7104   bool jresult ;
7105   Dali::Radian arg1 ;
7106   Dali::Degree arg2 ;
7107   Dali::Radian *argp1 ;
7108   Dali::Degree *argp2 ;
7109   bool result;
7110
7111   argp1 = (Dali::Radian *)jarg1;
7112   if (!argp1) {
7113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7114     return 0;
7115   }
7116   arg1 = *argp1;
7117   argp2 = (Dali::Degree *)jarg2;
7118   if (!argp2) {
7119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7120     return 0;
7121   }
7122   arg2 = *argp2;
7123   {
7124     try {
7125       result = (bool)Dali::operator !=(arg1,arg2);
7126     } CALL_CATCH_EXCEPTION(0);
7127   }
7128
7129   jresult = result;
7130   return jresult;
7131 }
7132
7133
7134 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
7135   bool jresult ;
7136   Dali::Degree arg1 ;
7137   Dali::Radian arg2 ;
7138   Dali::Degree *argp1 ;
7139   Dali::Radian *argp2 ;
7140   bool result;
7141
7142   argp1 = (Dali::Degree *)jarg1;
7143   if (!argp1) {
7144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7145     return 0;
7146   }
7147   arg1 = *argp1;
7148   argp2 = (Dali::Radian *)jarg2;
7149   if (!argp2) {
7150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7151     return 0;
7152   }
7153   arg2 = *argp2;
7154   {
7155     try {
7156       result = (bool)Dali::operator ==(arg1,arg2);
7157     } CALL_CATCH_EXCEPTION(0);
7158   }
7159
7160   jresult = result;
7161   return jresult;
7162 }
7163
7164
7165 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
7166   bool jresult ;
7167   Dali::Degree arg1 ;
7168   Dali::Radian arg2 ;
7169   Dali::Degree *argp1 ;
7170   Dali::Radian *argp2 ;
7171   bool result;
7172
7173   argp1 = (Dali::Degree *)jarg1;
7174   if (!argp1) {
7175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7176     return 0;
7177   }
7178   arg1 = *argp1;
7179   argp2 = (Dali::Radian *)jarg2;
7180   if (!argp2) {
7181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7182     return 0;
7183   }
7184   arg2 = *argp2;
7185   {
7186     try {
7187       result = (bool)Dali::operator !=(arg1,arg2);
7188     } CALL_CATCH_EXCEPTION(0);
7189   }
7190
7191   jresult = result;
7192   return jresult;
7193 }
7194
7195
7196 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
7197   bool jresult ;
7198   Dali::Radian arg1 ;
7199   Dali::Radian arg2 ;
7200   Dali::Radian *argp1 ;
7201   Dali::Radian *argp2 ;
7202   bool result;
7203
7204   argp1 = (Dali::Radian *)jarg1;
7205   if (!argp1) {
7206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7207     return 0;
7208   }
7209   arg1 = *argp1;
7210   argp2 = (Dali::Radian *)jarg2;
7211   if (!argp2) {
7212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7213     return 0;
7214   }
7215   arg2 = *argp2;
7216   {
7217     try {
7218       result = (bool)Dali::operator >(arg1,arg2);
7219     } CALL_CATCH_EXCEPTION(0);
7220   }
7221
7222   jresult = result;
7223   return jresult;
7224 }
7225
7226
7227 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
7228   bool jresult ;
7229   Dali::Radian arg1 ;
7230   Dali::Degree arg2 ;
7231   Dali::Radian *argp1 ;
7232   Dali::Degree *argp2 ;
7233   bool result;
7234
7235   argp1 = (Dali::Radian *)jarg1;
7236   if (!argp1) {
7237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7238     return 0;
7239   }
7240   arg1 = *argp1;
7241   argp2 = (Dali::Degree *)jarg2;
7242   if (!argp2) {
7243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7244     return 0;
7245   }
7246   arg2 = *argp2;
7247   {
7248     try {
7249       result = (bool)Dali::operator >(arg1,arg2);
7250     } CALL_CATCH_EXCEPTION(0);
7251   }
7252
7253   jresult = result;
7254   return jresult;
7255 }
7256
7257
7258 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
7259   bool jresult ;
7260   Dali::Degree arg1 ;
7261   Dali::Radian arg2 ;
7262   Dali::Degree *argp1 ;
7263   Dali::Radian *argp2 ;
7264   bool result;
7265
7266   argp1 = (Dali::Degree *)jarg1;
7267   if (!argp1) {
7268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7269     return 0;
7270   }
7271   arg1 = *argp1;
7272   argp2 = (Dali::Radian *)jarg2;
7273   if (!argp2) {
7274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7275     return 0;
7276   }
7277   arg2 = *argp2;
7278   {
7279     try {
7280       result = (bool)Dali::operator >(arg1,arg2);
7281     } CALL_CATCH_EXCEPTION(0);
7282   }
7283
7284   jresult = result;
7285   return jresult;
7286 }
7287
7288
7289 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
7290   bool jresult ;
7291   Dali::Radian arg1 ;
7292   Dali::Radian arg2 ;
7293   Dali::Radian *argp1 ;
7294   Dali::Radian *argp2 ;
7295   bool result;
7296
7297   argp1 = (Dali::Radian *)jarg1;
7298   if (!argp1) {
7299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7300     return 0;
7301   }
7302   arg1 = *argp1;
7303   argp2 = (Dali::Radian *)jarg2;
7304   if (!argp2) {
7305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7306     return 0;
7307   }
7308   arg2 = *argp2;
7309   {
7310     try {
7311       result = (bool)Dali::operator <(arg1,arg2);
7312     } CALL_CATCH_EXCEPTION(0);
7313   }
7314
7315   jresult = result;
7316   return jresult;
7317 }
7318
7319
7320 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
7321   bool jresult ;
7322   Dali::Radian arg1 ;
7323   Dali::Degree arg2 ;
7324   Dali::Radian *argp1 ;
7325   Dali::Degree *argp2 ;
7326   bool result;
7327
7328   argp1 = (Dali::Radian *)jarg1;
7329   if (!argp1) {
7330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7331     return 0;
7332   }
7333   arg1 = *argp1;
7334   argp2 = (Dali::Degree *)jarg2;
7335   if (!argp2) {
7336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7337     return 0;
7338   }
7339   arg2 = *argp2;
7340   {
7341     try {
7342       result = (bool)Dali::operator <(arg1,arg2);
7343     } CALL_CATCH_EXCEPTION(0);
7344   }
7345
7346   jresult = result;
7347   return jresult;
7348 }
7349
7350
7351 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
7352   bool jresult ;
7353   Dali::Degree arg1 ;
7354   Dali::Radian arg2 ;
7355   Dali::Degree *argp1 ;
7356   Dali::Radian *argp2 ;
7357   bool result;
7358
7359   argp1 = (Dali::Degree *)jarg1;
7360   if (!argp1) {
7361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7362     return 0;
7363   }
7364   arg1 = *argp1;
7365   argp2 = (Dali::Radian *)jarg2;
7366   if (!argp2) {
7367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7368     return 0;
7369   }
7370   arg2 = *argp2;
7371   {
7372     try {
7373       result = (bool)Dali::operator <(arg1,arg2);
7374     } CALL_CATCH_EXCEPTION(0);
7375   }
7376
7377   jresult = result;
7378   return jresult;
7379 }
7380
7381
7382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
7383   void * jresult ;
7384   Dali::Radian arg1 ;
7385   float arg2 ;
7386   Dali::Radian *argp1 ;
7387   Dali::Radian result;
7388
7389   argp1 = (Dali::Radian *)jarg1;
7390   if (!argp1) {
7391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7392     return 0;
7393   }
7394   arg1 = *argp1;
7395   arg2 = (float)jarg2;
7396   {
7397     try {
7398       result = Dali::operator *(arg1,arg2);
7399     } CALL_CATCH_EXCEPTION(0);
7400   }
7401
7402   jresult = new Dali::Radian((const Dali::Radian &)result);
7403   return jresult;
7404 }
7405
7406
7407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
7408   void * jresult ;
7409   Dali::Radian arg1 ;
7410   Dali::Radian *argp1 ;
7411   Dali::Radian result;
7412
7413   argp1 = (Dali::Radian *)jarg1;
7414   if (!argp1) {
7415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7416     return 0;
7417   }
7418   arg1 = *argp1;
7419   {
7420     try {
7421       result = Dali::operator -(arg1);
7422     } CALL_CATCH_EXCEPTION(0);
7423   }
7424
7425   jresult = new Dali::Radian((const Dali::Radian &)result);
7426   return jresult;
7427 }
7428
7429
7430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
7431   void * jresult ;
7432   Dali::Radian arg1 ;
7433   float arg2 ;
7434   float arg3 ;
7435   Dali::Radian *argp1 ;
7436   Dali::Radian result;
7437
7438   argp1 = (Dali::Radian *)jarg1;
7439   if (!argp1) {
7440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7441     return 0;
7442   }
7443   arg1 = *argp1;
7444   arg2 = (float)jarg2;
7445   arg3 = (float)jarg3;
7446   {
7447     try {
7448       result = Dali::Clamp(arg1,arg2,arg3);
7449     } CALL_CATCH_EXCEPTION(0);
7450   }
7451
7452   jresult = new Dali::Radian((const Dali::Radian &)result);
7453   return jresult;
7454 }
7455
7456
7457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
7458   void * jresult ;
7459   Dali::Matrix *result = 0 ;
7460
7461   {
7462     try {
7463       result = (Dali::Matrix *)new Dali::Matrix();
7464     } CALL_CATCH_EXCEPTION(0);
7465   }
7466
7467   jresult = (void *)result;
7468   return jresult;
7469 }
7470
7471
7472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(bool jarg1) {
7473   void * jresult ;
7474   bool arg1 ;
7475   Dali::Matrix *result = 0 ;
7476
7477   arg1 = jarg1 ? true : false;
7478   {
7479     try {
7480       result = (Dali::Matrix *)new Dali::Matrix(arg1);
7481     } CALL_CATCH_EXCEPTION(0);
7482   }
7483
7484   jresult = (void *)result;
7485   return jresult;
7486 }
7487
7488
7489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
7490   void * jresult ;
7491   float *arg1 = (float *) 0 ;
7492   Dali::Matrix *result = 0 ;
7493
7494   arg1 = jarg1;
7495   {
7496     try {
7497       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
7498     } CALL_CATCH_EXCEPTION(0);
7499   }
7500
7501   jresult = (void *)result;
7502
7503
7504   return jresult;
7505 }
7506
7507
7508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
7509   void * jresult ;
7510   Dali::Quaternion *arg1 = 0 ;
7511   Dali::Matrix *result = 0 ;
7512
7513   arg1 = (Dali::Quaternion *)jarg1;
7514   if (!arg1) {
7515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7516     return 0;
7517   }
7518   {
7519     try {
7520       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
7521     } CALL_CATCH_EXCEPTION(0);
7522   }
7523
7524   jresult = (void *)result;
7525   return jresult;
7526 }
7527
7528
7529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
7530   void * jresult ;
7531   Dali::Matrix *arg1 = 0 ;
7532   Dali::Matrix *result = 0 ;
7533
7534   arg1 = (Dali::Matrix *)jarg1;
7535   if (!arg1) {
7536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7537     return 0;
7538   }
7539   {
7540     try {
7541       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
7542     } CALL_CATCH_EXCEPTION(0);
7543   }
7544
7545   jresult = (void *)result;
7546   return jresult;
7547 }
7548
7549
7550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
7551   void * jresult ;
7552   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7553   Dali::Matrix *arg2 = 0 ;
7554   Dali::Matrix *result = 0 ;
7555
7556   arg1 = (Dali::Matrix *)jarg1;
7557   arg2 = (Dali::Matrix *)jarg2;
7558   if (!arg2) {
7559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7560     return 0;
7561   }
7562   {
7563     try {
7564       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
7565     } CALL_CATCH_EXCEPTION(0);
7566   }
7567
7568   jresult = (void *)result;
7569   return jresult;
7570 }
7571
7572
7573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
7574   void * jresult ;
7575   Dali::Matrix *result = 0 ;
7576
7577   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
7578   jresult = (void *)result;
7579   return jresult;
7580 }
7581
7582
7583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
7584   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7585
7586   arg1 = (Dali::Matrix *)jarg1;
7587   {
7588     try {
7589       (arg1)->SetIdentity();
7590     } CALL_CATCH_EXCEPTION();
7591   }
7592
7593 }
7594
7595
7596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
7597   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7598   Dali::Vector3 *arg2 = 0 ;
7599
7600   arg1 = (Dali::Matrix *)jarg1;
7601   arg2 = (Dali::Vector3 *)jarg2;
7602   if (!arg2) {
7603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7604     return ;
7605   }
7606   {
7607     try {
7608       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
7609     } CALL_CATCH_EXCEPTION();
7610   }
7611
7612 }
7613
7614
7615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
7616   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7617   Dali::Matrix *arg2 = 0 ;
7618
7619   arg1 = (Dali::Matrix *)jarg1;
7620   arg2 = (Dali::Matrix *)jarg2;
7621   if (!arg2) {
7622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
7623     return ;
7624   }
7625   {
7626     try {
7627       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
7628     } CALL_CATCH_EXCEPTION();
7629   }
7630
7631 }
7632
7633
7634 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
7635   bool jresult ;
7636   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7637   bool result;
7638
7639   arg1 = (Dali::Matrix *)jarg1;
7640   {
7641     try {
7642       result = (bool)(arg1)->Invert();
7643     } CALL_CATCH_EXCEPTION(0);
7644   }
7645
7646   jresult = result;
7647   return jresult;
7648 }
7649
7650
7651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
7652   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7653
7654   arg1 = (Dali::Matrix *)jarg1;
7655   {
7656     try {
7657       (arg1)->Transpose();
7658     } CALL_CATCH_EXCEPTION();
7659   }
7660
7661 }
7662
7663
7664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
7665   void * jresult ;
7666   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7667   Dali::Vector3 result;
7668
7669   arg1 = (Dali::Matrix *)jarg1;
7670   {
7671     try {
7672       result = ((Dali::Matrix const *)arg1)->GetXAxis();
7673     } CALL_CATCH_EXCEPTION(0);
7674   }
7675
7676   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7677   return jresult;
7678 }
7679
7680
7681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
7682   void * jresult ;
7683   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7684   Dali::Vector3 result;
7685
7686   arg1 = (Dali::Matrix *)jarg1;
7687   {
7688     try {
7689       result = ((Dali::Matrix const *)arg1)->GetYAxis();
7690     } CALL_CATCH_EXCEPTION(0);
7691   }
7692
7693   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7694   return jresult;
7695 }
7696
7697
7698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
7699   void * jresult ;
7700   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7701   Dali::Vector3 result;
7702
7703   arg1 = (Dali::Matrix *)jarg1;
7704   {
7705     try {
7706       result = ((Dali::Matrix const *)arg1)->GetZAxis();
7707     } CALL_CATCH_EXCEPTION(0);
7708   }
7709
7710   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7711   return jresult;
7712 }
7713
7714
7715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
7716   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7717   Dali::Vector3 *arg2 = 0 ;
7718
7719   arg1 = (Dali::Matrix *)jarg1;
7720   arg2 = (Dali::Vector3 *)jarg2;
7721   if (!arg2) {
7722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7723     return ;
7724   }
7725   {
7726     try {
7727       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
7728     } CALL_CATCH_EXCEPTION();
7729   }
7730
7731 }
7732
7733
7734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
7735   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7736   Dali::Vector3 *arg2 = 0 ;
7737
7738   arg1 = (Dali::Matrix *)jarg1;
7739   arg2 = (Dali::Vector3 *)jarg2;
7740   if (!arg2) {
7741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7742     return ;
7743   }
7744   {
7745     try {
7746       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
7747     } CALL_CATCH_EXCEPTION();
7748   }
7749
7750 }
7751
7752
7753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
7754   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7755   Dali::Vector3 *arg2 = 0 ;
7756
7757   arg1 = (Dali::Matrix *)jarg1;
7758   arg2 = (Dali::Vector3 *)jarg2;
7759   if (!arg2) {
7760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7761     return ;
7762   }
7763   {
7764     try {
7765       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
7766     } CALL_CATCH_EXCEPTION();
7767   }
7768
7769 }
7770
7771
7772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
7773   void * jresult ;
7774   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7775   Dali::Vector4 *result = 0 ;
7776
7777   arg1 = (Dali::Matrix *)jarg1;
7778   {
7779     try {
7780       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
7781     } CALL_CATCH_EXCEPTION(0);
7782   }
7783
7784   jresult = (void *)result;
7785   return jresult;
7786 }
7787
7788
7789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
7790   void * jresult ;
7791   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7792   Dali::Vector3 *result = 0 ;
7793
7794   arg1 = (Dali::Matrix *)jarg1;
7795   {
7796     try {
7797       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
7798     } CALL_CATCH_EXCEPTION(0);
7799   }
7800
7801   jresult = (void *)result;
7802   return jresult;
7803 }
7804
7805
7806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
7807   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7808   Dali::Vector4 *arg2 = 0 ;
7809
7810   arg1 = (Dali::Matrix *)jarg1;
7811   arg2 = (Dali::Vector4 *)jarg2;
7812   if (!arg2) {
7813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7814     return ;
7815   }
7816   {
7817     try {
7818       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
7819     } CALL_CATCH_EXCEPTION();
7820   }
7821
7822 }
7823
7824
7825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
7826   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7827   Dali::Vector3 *arg2 = 0 ;
7828
7829   arg1 = (Dali::Matrix *)jarg1;
7830   arg2 = (Dali::Vector3 *)jarg2;
7831   if (!arg2) {
7832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7833     return ;
7834   }
7835   {
7836     try {
7837       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
7838     } CALL_CATCH_EXCEPTION();
7839   }
7840
7841 }
7842
7843
7844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
7845   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7846
7847   arg1 = (Dali::Matrix *)jarg1;
7848   {
7849     try {
7850       (arg1)->OrthoNormalize();
7851     } CALL_CATCH_EXCEPTION();
7852   }
7853
7854 }
7855
7856
7857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
7858   void * jresult ;
7859   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7860   float *result = 0 ;
7861
7862   arg1 = (Dali::Matrix *)jarg1;
7863   {
7864     try {
7865       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
7866     } CALL_CATCH_EXCEPTION(0);
7867   }
7868
7869   jresult = (void *)result;
7870   return jresult;
7871 }
7872
7873
7874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
7875   Dali::Matrix *arg1 = 0 ;
7876   Dali::Matrix *arg2 = 0 ;
7877   Dali::Matrix *arg3 = 0 ;
7878
7879   arg1 = (Dali::Matrix *)jarg1;
7880   if (!arg1) {
7881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
7882     return ;
7883   }
7884   arg2 = (Dali::Matrix *)jarg2;
7885   if (!arg2) {
7886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7887     return ;
7888   }
7889   arg3 = (Dali::Matrix *)jarg3;
7890   if (!arg3) {
7891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7892     return ;
7893   }
7894   {
7895     try {
7896       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
7897     } CALL_CATCH_EXCEPTION();
7898   }
7899
7900 }
7901
7902
7903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
7904   Dali::Matrix *arg1 = 0 ;
7905   Dali::Matrix *arg2 = 0 ;
7906   Dali::Quaternion *arg3 = 0 ;
7907
7908   arg1 = (Dali::Matrix *)jarg1;
7909   if (!arg1) {
7910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
7911     return ;
7912   }
7913   arg2 = (Dali::Matrix *)jarg2;
7914   if (!arg2) {
7915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7916     return ;
7917   }
7918   arg3 = (Dali::Quaternion *)jarg3;
7919   if (!arg3) {
7920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7921     return ;
7922   }
7923   {
7924     try {
7925       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
7926     } CALL_CATCH_EXCEPTION();
7927   }
7928
7929 }
7930
7931
7932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
7933   void * jresult ;
7934   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7935   Dali::Vector4 *arg2 = 0 ;
7936   Dali::Vector4 result;
7937
7938   arg1 = (Dali::Matrix *)jarg1;
7939   if (!arg1) {
7940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7941     return 0;
7942   }
7943   arg2 = (Dali::Vector4 *)jarg2;
7944   if (!arg2) {
7945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7946     return 0;
7947   }
7948   {
7949     try {
7950       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7951     } CALL_CATCH_EXCEPTION(0);
7952   }
7953
7954   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7955   return jresult;
7956 }
7957
7958
7959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_3(void * nuiMatrixLhs, void * nuiMatrixRhs) {
7960   void * jresult ;
7961   Dali::Matrix *lhsPtr = (Dali::Matrix *) 0 ;
7962   Dali::Matrix *rhsPtr = (Dali::Matrix *) 0 ;
7963   Dali::Matrix result(false);
7964
7965   lhsPtr = (Dali::Matrix *)nuiMatrixLhs;
7966   if (!lhsPtr) {
7967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix const & type is null", 0);
7968     return 0;
7969   }
7970   rhsPtr = (Dali::Matrix *)nuiMatrixRhs;
7971   if (!rhsPtr) {
7972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix const & type is null", 0);
7973     return 0;
7974   }
7975   {
7976     try {
7977       result = ((Dali::Matrix const *)lhsPtr)->operator *((Dali::Matrix const &)*rhsPtr);
7978     } CALL_CATCH_EXCEPTION(0);
7979   }
7980
7981   jresult = new Dali::Matrix((const Dali::Matrix &)result);
7982   return jresult;
7983 }
7984
7985
7986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_4(void * nuiMatrixLhs, void * nuiMatrixRhs) {
7987   // Faster mulitply operation without memcpy
7988
7989   Dali::Matrix *jresult = (Dali::Matrix *)0;
7990   Dali::Matrix *lhsPtr  = (Dali::Matrix *)0;
7991   Dali::Matrix *rhsPtr  = (Dali::Matrix *)0;
7992
7993   lhsPtr = (Dali::Matrix *)nuiMatrixLhs;
7994   if (!lhsPtr) {
7995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix const & type is null", 0);
7996     return 0;
7997   }
7998   rhsPtr = (Dali::Matrix *)nuiMatrixRhs;
7999   if (!rhsPtr) {
8000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix const & type is null", 0);
8001     return 0;
8002   }
8003   {
8004     try {
8005       jresult = new Dali::Matrix(false);
8006       Dali::Matrix::Multiply((Dali::Matrix &)*jresult,(Dali::Matrix const &)*rhsPtr,(Dali::Matrix const &)*lhsPtr);
8007     } CALL_CATCH_EXCEPTION(0);
8008   }
8009
8010   return jresult;
8011 }
8012
8013
8014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_MultiplyAssign(void * nuiMatrix, void * nuiMatrixRhs) {
8015   void * jresult = 0;
8016   Dali::Matrix *lhsPtr = (Dali::Matrix *) 0 ;
8017   Dali::Matrix *rhsPtr = (Dali::Matrix *) 0 ;
8018   Dali::Matrix *retPtr = (Dali::Matrix *) 0 ;
8019
8020   lhsPtr = (Dali::Matrix *)nuiMatrix;
8021   if (!lhsPtr) {
8022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix const & type is null", 0);
8023     return 0;
8024   }
8025   rhsPtr = (Dali::Matrix *)nuiMatrixRhs;
8026   if (!rhsPtr) {
8027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix const & type is null", 0);
8028     return 0;
8029   }
8030   {
8031     try {
8032       retPtr = (Dali::Matrix *) &(lhsPtr)->operator *=((Dali::Matrix const &)*rhsPtr);
8033     } CALL_CATCH_EXCEPTION(0);
8034   }
8035
8036   jresult = (void *)retPtr;
8037   return jresult;
8038 }
8039
8040
8041 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
8042   bool jresult ;
8043   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8044   Dali::Matrix *arg2 = 0 ;
8045   bool result;
8046
8047   arg1 = (Dali::Matrix *)jarg1;
8048   arg2 = (Dali::Matrix *)jarg2;
8049   if (!arg2) {
8050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8051     return 0;
8052   }
8053   {
8054     try {
8055       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
8056     } CALL_CATCH_EXCEPTION(0);
8057   }
8058
8059   jresult = result;
8060   return jresult;
8061 }
8062
8063
8064 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
8065   bool jresult ;
8066   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8067   Dali::Matrix *arg2 = 0 ;
8068   bool result;
8069
8070   arg1 = (Dali::Matrix *)jarg1;
8071   arg2 = (Dali::Matrix *)jarg2;
8072   if (!arg2) {
8073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8074     return 0;
8075   }
8076   {
8077     try {
8078       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
8079     } CALL_CATCH_EXCEPTION(0);
8080   }
8081
8082   jresult = result;
8083   return jresult;
8084 }
8085
8086 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix_ValueOfIndex__SWIG_0(void * nuiMatrix, unsigned int index) {
8087   float jresult ;
8088   Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ;
8089
8090   pMatrix = (Dali::Matrix *)nuiMatrix;
8091   if (!pMatrix) {
8092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8093     return 0;
8094   }
8095   if (index >= 16) {
8096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 16.)", 0);
8097     return 0;
8098   }
8099   {
8100     try {
8101       const float* temp = ((Dali::Matrix const *)pMatrix)->AsFloat();
8102       jresult = temp[index];
8103     } CALL_CATCH_EXCEPTION(0);
8104   }
8105   return jresult;
8106 }
8107
8108 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix_ValueOfIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn) {
8109   float jresult ;
8110   Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ;
8111
8112   pMatrix = (Dali::Matrix *)nuiMatrix;
8113   if (!pMatrix) {
8114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8115     return 0;
8116   }
8117   if (indexRow >= 4) {
8118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 4.)", 0);
8119     return 0;
8120   }
8121   if (indexColumn >= 4) {
8122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 4.)", 0);
8123     return 0;
8124   }
8125   {
8126     try {
8127       const float* temp = ((Dali::Matrix const *)pMatrix)->AsFloat();
8128       jresult = temp[(indexColumn << 2) | indexRow];
8129     } CALL_CATCH_EXCEPTION(0);
8130   }
8131   return jresult;
8132 }
8133
8134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetValueAtIndex__SWIG_0(void * nuiMatrix, unsigned int index, float value) {
8135   Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ;
8136
8137   pMatrix = (Dali::Matrix *)nuiMatrix;
8138   if (!pMatrix) {
8139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8140     return;
8141   }
8142   if (index >= 16) {
8143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 16.)", 0);
8144     return;
8145   }
8146   {
8147     try {
8148       float* temp = ((Dali::Matrix *)pMatrix)->AsFloat();
8149       temp[index] = value;
8150     } CALL_CATCH_EXCEPTION();
8151   }
8152 }
8153
8154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetValueAtIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn, float value) {
8155   Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ;
8156
8157   pMatrix = (Dali::Matrix *)nuiMatrix;
8158   if (!pMatrix) {
8159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8160     return;
8161   }
8162   if (indexRow >= 4) {
8163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 4.)", 0);
8164     return;
8165   }
8166   if (indexColumn >= 4) {
8167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 4.)", 0);
8168     return;
8169   }
8170   {
8171     try {
8172       float* temp = ((Dali::Matrix *)pMatrix)->AsFloat();
8173       temp[(indexColumn << 2) | indexRow] = value;
8174     } CALL_CATCH_EXCEPTION();
8175   }
8176 }
8177
8178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
8179   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8180   Dali::Vector3 *arg2 = 0 ;
8181   Dali::Quaternion *arg3 = 0 ;
8182   Dali::Vector3 *arg4 = 0 ;
8183
8184   arg1 = (Dali::Matrix *)jarg1;
8185   arg2 = (Dali::Vector3 *)jarg2;
8186   if (!arg2) {
8187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8188     return ;
8189   }
8190   arg3 = (Dali::Quaternion *)jarg3;
8191   if (!arg3) {
8192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8193     return ;
8194   }
8195   arg4 = (Dali::Vector3 *)jarg4;
8196   if (!arg4) {
8197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8198     return ;
8199   }
8200   {
8201     try {
8202       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
8203     } CALL_CATCH_EXCEPTION();
8204   }
8205
8206 }
8207
8208
8209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
8210   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8211   Dali::Vector3 *arg2 = 0 ;
8212   Dali::Quaternion *arg3 = 0 ;
8213   Dali::Vector3 *arg4 = 0 ;
8214
8215   arg1 = (Dali::Matrix *)jarg1;
8216   arg2 = (Dali::Vector3 *)jarg2;
8217   if (!arg2) {
8218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8219     return ;
8220   }
8221   arg3 = (Dali::Quaternion *)jarg3;
8222   if (!arg3) {
8223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8224     return ;
8225   }
8226   arg4 = (Dali::Vector3 *)jarg4;
8227   if (!arg4) {
8228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8229     return ;
8230   }
8231   {
8232     try {
8233       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
8234     } CALL_CATCH_EXCEPTION();
8235   }
8236
8237 }
8238
8239
8240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
8241   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8242   Dali::Vector3 *arg2 = 0 ;
8243   Dali::Vector3 *arg3 = 0 ;
8244   Dali::Vector3 *arg4 = 0 ;
8245   Dali::Vector3 *arg5 = 0 ;
8246
8247   arg1 = (Dali::Matrix *)jarg1;
8248   arg2 = (Dali::Vector3 *)jarg2;
8249   if (!arg2) {
8250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8251     return ;
8252   }
8253   arg3 = (Dali::Vector3 *)jarg3;
8254   if (!arg3) {
8255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8256     return ;
8257   }
8258   arg4 = (Dali::Vector3 *)jarg4;
8259   if (!arg4) {
8260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8261     return ;
8262   }
8263   arg5 = (Dali::Vector3 *)jarg5;
8264   if (!arg5) {
8265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8266     return ;
8267   }
8268   {
8269     try {
8270       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
8271     } CALL_CATCH_EXCEPTION();
8272   }
8273
8274 }
8275
8276
8277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
8278   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8279   Dali::Vector3 *arg2 = 0 ;
8280   Dali::Quaternion *arg3 = 0 ;
8281   Dali::Vector3 *arg4 = 0 ;
8282
8283   arg1 = (Dali::Matrix *)jarg1;
8284   arg2 = (Dali::Vector3 *)jarg2;
8285   if (!arg2) {
8286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
8287     return ;
8288   }
8289   arg3 = (Dali::Quaternion *)jarg3;
8290   if (!arg3) {
8291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
8292     return ;
8293   }
8294   arg4 = (Dali::Vector3 *)jarg4;
8295   if (!arg4) {
8296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
8297     return ;
8298   }
8299   {
8300     try {
8301       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
8302     } CALL_CATCH_EXCEPTION();
8303   }
8304
8305 }
8306
8307
8308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
8309   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8310
8311   arg1 = (Dali::Matrix *)jarg1;
8312   {
8313     try {
8314       delete arg1;
8315     } CALL_CATCH_EXCEPTION();
8316   }
8317
8318 }
8319
8320
8321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
8322   void * jresult ;
8323   Dali::Matrix3 *result = 0 ;
8324
8325   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
8326   jresult = (void *)result;
8327   return jresult;
8328 }
8329
8330
8331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
8332   void * jresult ;
8333   Dali::Matrix3 *result = 0 ;
8334
8335   {
8336     try {
8337       result = (Dali::Matrix3 *)new Dali::Matrix3();
8338     } CALL_CATCH_EXCEPTION(0);
8339   }
8340
8341   jresult = (void *)result;
8342   return jresult;
8343 }
8344
8345
8346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
8347   void * jresult ;
8348   Dali::Matrix3 *arg1 = 0 ;
8349   Dali::Matrix3 *result = 0 ;
8350
8351   arg1 = (Dali::Matrix3 *)jarg1;
8352   if (!arg1) {
8353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8354     return 0;
8355   }
8356   {
8357     try {
8358       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
8359     } CALL_CATCH_EXCEPTION(0);
8360   }
8361
8362   jresult = (void *)result;
8363   return jresult;
8364 }
8365
8366
8367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
8368   void * jresult ;
8369   Dali::Matrix *arg1 = 0 ;
8370   Dali::Matrix3 *result = 0 ;
8371
8372   arg1 = (Dali::Matrix *)jarg1;
8373   if (!arg1) {
8374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8375     return 0;
8376   }
8377   {
8378     try {
8379       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
8380     } CALL_CATCH_EXCEPTION(0);
8381   }
8382
8383   jresult = (void *)result;
8384   return jresult;
8385 }
8386
8387
8388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_3(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9) {
8389   void * jresult ;
8390   float arg1 ;
8391   float arg2 ;
8392   float arg3 ;
8393   float arg4 ;
8394   float arg5 ;
8395   float arg6 ;
8396   float arg7 ;
8397   float arg8 ;
8398   float arg9 ;
8399   Dali::Matrix3 *result = 0 ;
8400
8401   arg1 = (float)jarg1;
8402   arg2 = (float)jarg2;
8403   arg3 = (float)jarg3;
8404   arg4 = (float)jarg4;
8405   arg5 = (float)jarg5;
8406   arg6 = (float)jarg6;
8407   arg7 = (float)jarg7;
8408   arg8 = (float)jarg8;
8409   arg9 = (float)jarg9;
8410   {
8411     try {
8412       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
8413     } CALL_CATCH_EXCEPTION(0);
8414   }
8415
8416   jresult = (void *)result;
8417   return jresult;
8418 }
8419
8420
8421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
8422   void * jresult ;
8423   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8424   Dali::Matrix3 *arg2 = 0 ;
8425   Dali::Matrix3 *result = 0 ;
8426
8427   arg1 = (Dali::Matrix3 *)jarg1;
8428   arg2 = (Dali::Matrix3 *)jarg2;
8429   if (!arg2) {
8430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8431     return 0;
8432   }
8433   {
8434     try {
8435       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
8436     } CALL_CATCH_EXCEPTION(0);
8437   }
8438
8439   jresult = (void *)result;
8440   return jresult;
8441 }
8442
8443
8444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
8445   void * jresult ;
8446   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8447   Dali::Matrix *arg2 = 0 ;
8448   Dali::Matrix3 *result = 0 ;
8449
8450   arg1 = (Dali::Matrix3 *)jarg1;
8451   arg2 = (Dali::Matrix *)jarg2;
8452   if (!arg2) {
8453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8454     return 0;
8455   }
8456   {
8457     try {
8458       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
8459     } CALL_CATCH_EXCEPTION(0);
8460   }
8461
8462   jresult = (void *)result;
8463   return jresult;
8464 }
8465
8466
8467 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
8468   bool jresult ;
8469   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8470   Dali::Matrix3 *arg2 = 0 ;
8471   bool result;
8472
8473   arg1 = (Dali::Matrix3 *)jarg1;
8474   arg2 = (Dali::Matrix3 *)jarg2;
8475   if (!arg2) {
8476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8477     return 0;
8478   }
8479   {
8480     try {
8481       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
8482     } CALL_CATCH_EXCEPTION(0);
8483   }
8484
8485   jresult = result;
8486   return jresult;
8487 }
8488
8489
8490 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
8491   bool jresult ;
8492   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8493   Dali::Matrix3 *arg2 = 0 ;
8494   bool result;
8495
8496   arg1 = (Dali::Matrix3 *)jarg1;
8497   arg2 = (Dali::Matrix3 *)jarg2;
8498   if (!arg2) {
8499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8500     return 0;
8501   }
8502   {
8503     try {
8504       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
8505     } CALL_CATCH_EXCEPTION(0);
8506   }
8507
8508   jresult = result;
8509   return jresult;
8510 }
8511
8512
8513 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_ValueOfIndex__SWIG_0(void * nuiMatrix, unsigned int index) {
8514   float jresult ;
8515   Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ;
8516
8517   pMatrix = (Dali::Matrix3 *)nuiMatrix;
8518   if (!pMatrix) {
8519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8520     return 0;
8521   }
8522   if (index >= 9) {
8523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 9.)", 0);
8524     return 0;
8525   }
8526   {
8527     try {
8528       const float* temp = ((Dali::Matrix3 const *)pMatrix)->AsFloat();
8529       jresult = temp[index];
8530     } CALL_CATCH_EXCEPTION(0);
8531   }
8532   return jresult;
8533 }
8534
8535 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_ValueOfIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn) {
8536   float jresult ;
8537   Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ;
8538
8539   pMatrix = (Dali::Matrix3 *)nuiMatrix;
8540   if (!pMatrix) {
8541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8542     return 0;
8543   }
8544   if (indexRow >= 3) {
8545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 3.)", 0);
8546     return 0;
8547   }
8548   if (indexColumn >= 3) {
8549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 3.)", 0);
8550     return 0;
8551   }
8552   {
8553     try {
8554       const float* temp = ((Dali::Matrix3 const *)pMatrix)->AsFloat();
8555       jresult = temp[indexColumn * 3 + indexRow];
8556     } CALL_CATCH_EXCEPTION(0);
8557   }
8558   return jresult;
8559 }
8560
8561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetValueAtIndex__SWIG_0(void * nuiMatrix, unsigned int index, float value) {
8562   Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ;
8563
8564   pMatrix = (Dali::Matrix3 *)nuiMatrix;
8565   if (!pMatrix) {
8566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8567     return;
8568   }
8569   if (index >= 9) {
8570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 9.)", 0);
8571     return;
8572   }
8573   {
8574     try {
8575       float* temp = ((Dali::Matrix3 *)pMatrix)->AsFloat();
8576       temp[index] = value;
8577     } CALL_CATCH_EXCEPTION();
8578   }
8579 }
8580
8581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetValueAtIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn, float value) {
8582   Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ;
8583
8584   pMatrix = (Dali::Matrix3 *)nuiMatrix;
8585   if (!pMatrix) {
8586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8587     return;
8588   }
8589   if (indexRow >= 3) {
8590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 3.)", 0);
8591     return;
8592   }
8593   if (indexColumn >= 3) {
8594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 3.)", 0);
8595     return;
8596   }
8597   {
8598     try {
8599       float* temp = ((Dali::Matrix3 *)pMatrix)->AsFloat();
8600       temp[indexColumn * 3 + indexRow] = value;
8601     } CALL_CATCH_EXCEPTION();
8602   }
8603 }
8604
8605
8606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
8607   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8608
8609   arg1 = (Dali::Matrix3 *)jarg1;
8610   {
8611     try {
8612       delete arg1;
8613     } CALL_CATCH_EXCEPTION();
8614   }
8615
8616 }
8617
8618
8619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
8620   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8621
8622   arg1 = (Dali::Matrix3 *)jarg1;
8623   {
8624     try {
8625       (arg1)->SetIdentity();
8626     } CALL_CATCH_EXCEPTION();
8627   }
8628
8629 }
8630
8631
8632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
8633   void * jresult ;
8634   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8635   float *result = 0 ;
8636
8637   arg1 = (Dali::Matrix3 *)jarg1;
8638   {
8639     try {
8640       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
8641     } CALL_CATCH_EXCEPTION(0);
8642   }
8643
8644   jresult = (void *)result;
8645   return jresult;
8646 }
8647
8648
8649 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
8650   bool jresult ;
8651   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8652   bool result;
8653
8654   arg1 = (Dali::Matrix3 *)jarg1;
8655   {
8656     try {
8657       result = (bool)(arg1)->Invert();
8658     } CALL_CATCH_EXCEPTION(0);
8659   }
8660
8661   jresult = result;
8662   return jresult;
8663 }
8664
8665
8666 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
8667   bool jresult ;
8668   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8669   bool result;
8670
8671   arg1 = (Dali::Matrix3 *)jarg1;
8672   {
8673     try {
8674       result = (bool)(arg1)->Transpose();
8675     } CALL_CATCH_EXCEPTION(0);
8676   }
8677
8678   jresult = result;
8679   return jresult;
8680 }
8681
8682
8683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
8684   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8685   float arg2 ;
8686
8687   arg1 = (Dali::Matrix3 *)jarg1;
8688   arg2 = (float)jarg2;
8689   {
8690     try {
8691       (arg1)->Scale(arg2);
8692     } CALL_CATCH_EXCEPTION();
8693   }
8694
8695 }
8696
8697
8698 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
8699   float jresult ;
8700   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8701   float result;
8702
8703   arg1 = (Dali::Matrix3 *)jarg1;
8704   {
8705     try {
8706       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
8707     } CALL_CATCH_EXCEPTION(0);
8708   }
8709
8710   jresult = result;
8711   return jresult;
8712 }
8713
8714
8715 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
8716   bool jresult ;
8717   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8718   bool result;
8719
8720   arg1 = (Dali::Matrix3 *)jarg1;
8721   {
8722     try {
8723       result = (bool)(arg1)->ScaledInverseTranspose();
8724     } CALL_CATCH_EXCEPTION(0);
8725   }
8726
8727   jresult = result;
8728   return jresult;
8729 }
8730
8731
8732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
8733   Dali::Matrix3 *arg1 = 0 ;
8734   Dali::Matrix3 *arg2 = 0 ;
8735   Dali::Matrix3 *arg3 = 0 ;
8736
8737   arg1 = (Dali::Matrix3 *)jarg1;
8738   if (!arg1) {
8739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
8740     return ;
8741   }
8742   arg2 = (Dali::Matrix3 *)jarg2;
8743   if (!arg2) {
8744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8745     return ;
8746   }
8747   arg3 = (Dali::Matrix3 *)jarg3;
8748   if (!arg3) {
8749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8750     return ;
8751   }
8752   {
8753     try {
8754       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
8755     } CALL_CATCH_EXCEPTION();
8756   }
8757
8758 }
8759
8760
8761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Multiply__SWIG_1(void * jarg1, void * jarg2) {
8762   void * jresult ;
8763   Dali::Matrix3 *arg1 = 0 ;
8764   Dali::Vector3 *arg2 = 0 ;
8765   Dali::Vector3 result;
8766
8767   arg1 = (Dali::Matrix3 *)jarg1;
8768   if (!arg1) {
8769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8770     return 0;
8771   }
8772   arg2 = (Dali::Vector3 *)jarg2;
8773   if (!arg2) {
8774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8775     return 0;
8776   }
8777   {
8778     try {
8779       result = ((Dali::Matrix3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
8780     } CALL_CATCH_EXCEPTION(0);
8781   }
8782
8783   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
8784   return jresult;
8785 }
8786
8787
8788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Multiply__SWIG_2(void * nuiMatrix3Lhs, void * nuiMatrix3Rhs) {
8789   void * jresult ;
8790   Dali::Matrix3 *lhsPtr = 0 ;
8791   Dali::Matrix3 *rhsPtr = 0 ;
8792   Dali::Matrix3 result;
8793
8794   lhsPtr = (Dali::Matrix3 *)nuiMatrix3Lhs;
8795   if (!lhsPtr) {
8796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix3 const & type is null", 0);
8797     return 0;
8798   }
8799   rhsPtr = (Dali::Matrix3 *)nuiMatrix3Rhs;
8800   if (!rhsPtr) {
8801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix3 const & type is null", 0);
8802     return 0;
8803   }
8804   {
8805     try {
8806       result = ((Dali::Matrix3 const *)lhsPtr)->operator *((Dali::Matrix3 const &)*rhsPtr);
8807     } CALL_CATCH_EXCEPTION(0);
8808   }
8809
8810   jresult = new Dali::Matrix3((const Dali::Matrix3 &)result);
8811   return jresult;
8812 }
8813
8814
8815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Multiply__SWIG_3(void * nuiMatrix3Lhs, void * nuiMatrix3Rhs) {
8816   // Faster mulitply operation without memcpy
8817
8818   Dali::Matrix3 *jresult = 0;
8819   Dali::Matrix3 *lhsPtr  = 0;
8820   Dali::Matrix3 *rhsPtr  = 0;
8821
8822   lhsPtr = (Dali::Matrix3 *)nuiMatrix3Lhs;
8823   if (!lhsPtr) {
8824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix3 const & type is null", 0);
8825     return 0;
8826   }
8827   rhsPtr = (Dali::Matrix3 *)nuiMatrix3Rhs;
8828   if (!rhsPtr) {
8829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix3 const & type is null", 0);
8830     return 0;
8831   }
8832   {
8833     try {
8834       jresult = new Dali::Matrix3();
8835       Dali::Matrix3::Multiply((Dali::Matrix3 &)*jresult,(Dali::Matrix3 const &)*rhsPtr,(Dali::Matrix3 const &)*lhsPtr);
8836     } CALL_CATCH_EXCEPTION(0);
8837   }
8838
8839   return jresult;
8840 }
8841
8842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_MultiplyAssign(void * nuiMatrix, void * nuiMatrixRhs) {
8843   void * jresult = 0;
8844   Dali::Matrix3 *lhsPtr = (Dali::Matrix3 *) 0 ;
8845   Dali::Matrix3 *rhsPtr = (Dali::Matrix3 *) 0 ;
8846   Dali::Matrix3 *retPtr = (Dali::Matrix3 *) 0 ;
8847
8848   lhsPtr = (Dali::Matrix3 *)nuiMatrix;
8849   if (!lhsPtr) {
8850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix3 const & type is null", 0);
8851     return 0;
8852   }
8853   rhsPtr = (Dali::Matrix3 *)nuiMatrixRhs;
8854   if (!rhsPtr) {
8855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix3 const & type is null", 0);
8856     return 0;
8857   }
8858   {
8859     try {
8860       retPtr = (Dali::Matrix3 *) &(lhsPtr)->operator *=((Dali::Matrix3 const &)*rhsPtr);
8861     } CALL_CATCH_EXCEPTION(0);
8862   }
8863
8864   jresult = (void *)retPtr;
8865   return jresult;
8866 }
8867
8868
8869 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
8870   float jresult ;
8871   float arg1 ;
8872   float arg2 ;
8873   float result;
8874
8875   arg1 = (float)jarg1;
8876   arg2 = (float)jarg2;
8877   {
8878     try {
8879       result = (float)Dali::Random::Range(arg1,arg2);
8880     } CALL_CATCH_EXCEPTION(0);
8881   }
8882
8883   jresult = result;
8884   return jresult;
8885 }
8886
8887
8888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
8889   void * jresult ;
8890   Dali::Vector4 result;
8891
8892   {
8893     try {
8894       result = Dali::Random::Axis();
8895     } CALL_CATCH_EXCEPTION(0);
8896   }
8897
8898   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8899   return jresult;
8900 }
8901
8902
8903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
8904   void * jresult ;
8905   Dali::AngleAxis *result = 0 ;
8906
8907   {
8908     try {
8909       result = (Dali::AngleAxis *)new Dali::AngleAxis();
8910     } CALL_CATCH_EXCEPTION(0);
8911   }
8912
8913   jresult = (void *)result;
8914   return jresult;
8915 }
8916
8917
8918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
8919   void * jresult ;
8920   Dali::Radian arg1 ;
8921   Dali::Vector3 *arg2 = 0 ;
8922   Dali::Radian *argp1 ;
8923   Dali::AngleAxis *result = 0 ;
8924
8925   argp1 = (Dali::Radian *)jarg1;
8926   if (!argp1) {
8927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8928     return 0;
8929   }
8930   arg1 = *argp1;
8931   arg2 = (Dali::Vector3 *)jarg2;
8932   if (!arg2) {
8933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8934     return 0;
8935   }
8936   {
8937     try {
8938       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
8939     } CALL_CATCH_EXCEPTION(0);
8940   }
8941
8942   jresult = (void *)result;
8943   return jresult;
8944 }
8945
8946
8947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
8948   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
8949   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
8950
8951   arg1 = (Dali::AngleAxis *)jarg1;
8952   arg2 = (Dali::Radian *)jarg2;
8953   if (arg1) (arg1)->angle = *arg2;
8954 }
8955
8956
8957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
8958   void * jresult ;
8959   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
8960   Dali::Radian *result = 0 ;
8961
8962   arg1 = (Dali::AngleAxis *)jarg1;
8963   result = (Dali::Radian *)& ((arg1)->angle);
8964   jresult = (void *)result;
8965   return jresult;
8966 }
8967
8968
8969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
8970   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
8971   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
8972
8973   arg1 = (Dali::AngleAxis *)jarg1;
8974   arg2 = (Dali::Vector3 *)jarg2;
8975   if (arg1) (arg1)->axis = *arg2;
8976 }
8977
8978
8979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
8980   void * jresult ;
8981   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
8982   Dali::Vector3 *result = 0 ;
8983
8984   arg1 = (Dali::AngleAxis *)jarg1;
8985   result = (Dali::Vector3 *)& ((arg1)->axis);
8986   jresult = (void *)result;
8987   return jresult;
8988 }
8989
8990
8991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
8992   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
8993
8994   arg1 = (Dali::AngleAxis *)jarg1;
8995   {
8996     try {
8997       delete arg1;
8998     } CALL_CATCH_EXCEPTION();
8999   }
9000
9001 }
9002
9003
9004 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
9005   bool jresult ;
9006   Dali::AngleAxis *arg1 = 0 ;
9007   Dali::AngleAxis *arg2 = 0 ;
9008   bool result;
9009
9010   arg1 = (Dali::AngleAxis *)jarg1;
9011   if (!arg1) {
9012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
9013     return 0;
9014   }
9015   arg2 = (Dali::AngleAxis *)jarg2;
9016   if (!arg2) {
9017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
9018     return 0;
9019   }
9020   {
9021     try {
9022       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
9023     } CALL_CATCH_EXCEPTION(0);
9024   }
9025
9026   jresult = result;
9027   return jresult;
9028 }
9029
9030
9031 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
9032   unsigned int jresult ;
9033   unsigned int arg1 ;
9034   unsigned int result;
9035
9036   arg1 = (unsigned int)jarg1;
9037   {
9038     try {
9039       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
9040     } CALL_CATCH_EXCEPTION(0);
9041   }
9042
9043   jresult = result;
9044   return jresult;
9045 }
9046
9047
9048 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
9049   bool jresult ;
9050   unsigned int arg1 ;
9051   bool result;
9052
9053   arg1 = (unsigned int)jarg1;
9054   {
9055     try {
9056       result = (bool)Dali::IsPowerOfTwo(arg1);
9057     } CALL_CATCH_EXCEPTION(0);
9058   }
9059
9060   jresult = result;
9061   return jresult;
9062 }
9063
9064
9065 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
9066   float jresult ;
9067   float arg1 ;
9068   float arg2 ;
9069   float result;
9070
9071   arg1 = (float)jarg1;
9072   arg2 = (float)jarg2;
9073   {
9074     try {
9075       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
9076     } CALL_CATCH_EXCEPTION(0);
9077   }
9078
9079   jresult = result;
9080   return jresult;
9081 }
9082
9083
9084 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
9085   bool jresult ;
9086   float arg1 ;
9087   bool result;
9088
9089   arg1 = (float)jarg1;
9090   {
9091     try {
9092       result = (bool)Dali::EqualsZero(arg1);
9093     } CALL_CATCH_EXCEPTION(0);
9094   }
9095
9096   jresult = result;
9097   return jresult;
9098 }
9099
9100
9101 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
9102   bool jresult ;
9103   float arg1 ;
9104   float arg2 ;
9105   bool result;
9106
9107   arg1 = (float)jarg1;
9108   arg2 = (float)jarg2;
9109   {
9110     try {
9111       result = (bool)Dali::Equals(arg1,arg2);
9112     } CALL_CATCH_EXCEPTION(0);
9113   }
9114
9115   jresult = result;
9116   return jresult;
9117 }
9118
9119
9120 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
9121   bool jresult ;
9122   float arg1 ;
9123   float arg2 ;
9124   float arg3 ;
9125   bool result;
9126
9127   arg1 = (float)jarg1;
9128   arg2 = (float)jarg2;
9129   arg3 = (float)jarg3;
9130   {
9131     try {
9132       result = (bool)Dali::Equals(arg1,arg2,arg3);
9133     } CALL_CATCH_EXCEPTION(0);
9134   }
9135
9136   jresult = result;
9137   return jresult;
9138 }
9139
9140
9141 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
9142   float jresult ;
9143   float arg1 ;
9144   int arg2 ;
9145   float result;
9146
9147   arg1 = (float)jarg1;
9148   arg2 = (int)jarg2;
9149   {
9150     try {
9151       result = (float)Dali::Round(arg1,arg2);
9152     } CALL_CATCH_EXCEPTION(0);
9153   }
9154
9155   jresult = result;
9156   return jresult;
9157 }
9158
9159
9160 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
9161   float jresult ;
9162   float arg1 ;
9163   float arg2 ;
9164   float arg3 ;
9165   float result;
9166
9167   arg1 = (float)jarg1;
9168   arg2 = (float)jarg2;
9169   arg3 = (float)jarg3;
9170   {
9171     try {
9172       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
9173     } CALL_CATCH_EXCEPTION(0);
9174   }
9175
9176   jresult = result;
9177   return jresult;
9178 }
9179
9180
9181 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
9182   float jresult ;
9183   float arg1 ;
9184   float arg2 ;
9185   float arg3 ;
9186   float arg4 ;
9187   float result;
9188
9189   arg1 = (float)jarg1;
9190   arg2 = (float)jarg2;
9191   arg3 = (float)jarg3;
9192   arg4 = (float)jarg4;
9193   {
9194     try {
9195       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
9196     } CALL_CATCH_EXCEPTION(0);
9197   }
9198
9199   jresult = result;
9200   return jresult;
9201 }
9202
9203
9204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
9205   int jresult ;
9206   int result;
9207
9208   result = (int)(int)Dali::Property::INVALID_INDEX;
9209   jresult = result;
9210   return jresult;
9211 }
9212
9213
9214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
9215   int jresult ;
9216   int result;
9217
9218   result = (int)(int)Dali::Property::INVALID_KEY;
9219   jresult = result;
9220   return jresult;
9221 }
9222
9223
9224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
9225   int jresult ;
9226   int result;
9227
9228   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
9229   jresult = result;
9230   return jresult;
9231 }
9232
9233
9234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
9235   void * jresult ;
9236   Dali::Handle *arg1 = 0 ;
9237   Dali::Property::Index arg2 ;
9238   Dali::Property *result = 0 ;
9239
9240   arg1 = (Dali::Handle *)jarg1;
9241   if (!arg1) {
9242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9243     return 0;
9244   }
9245   arg2 = (Dali::Property::Index)jarg2;
9246   {
9247     try {
9248       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
9249     } CALL_CATCH_EXCEPTION(0);
9250   }
9251
9252   jresult = (void *)result;
9253   return jresult;
9254 }
9255
9256
9257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
9258   void * jresult ;
9259   Dali::Handle *arg1 = 0 ;
9260   Dali::Property::Index arg2 ;
9261   int arg3 ;
9262   Dali::Property *result = 0 ;
9263
9264   arg1 = (Dali::Handle *)jarg1;
9265   if (!arg1) {
9266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9267     return 0;
9268   }
9269   arg2 = (Dali::Property::Index)jarg2;
9270   arg3 = (int)jarg3;
9271   {
9272     try {
9273       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
9274     } CALL_CATCH_EXCEPTION(0);
9275   }
9276
9277   jresult = (void *)result;
9278   return jresult;
9279 }
9280
9281
9282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
9283   void * jresult ;
9284   Dali::Handle *arg1 = 0 ;
9285   std::string *arg2 = 0 ;
9286   Dali::Property *result = 0 ;
9287
9288   arg1 = (Dali::Handle *)jarg1;
9289   if (!arg1) {
9290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9291     return 0;
9292   }
9293   if (!jarg2) {
9294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9295     return 0;
9296   }
9297   std::string arg2_str(jarg2);
9298   arg2 = &arg2_str;
9299   {
9300     try {
9301       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
9302     } CALL_CATCH_EXCEPTION(0);
9303   }
9304
9305   jresult = (void *)result;
9306
9307   //argout typemap for const std::string&
9308
9309   return jresult;
9310 }
9311
9312
9313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
9314   void * jresult ;
9315   Dali::Handle *arg1 = 0 ;
9316   std::string *arg2 = 0 ;
9317   int arg3 ;
9318   Dali::Property *result = 0 ;
9319
9320   arg1 = (Dali::Handle *)jarg1;
9321   if (!arg1) {
9322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9323     return 0;
9324   }
9325   if (!jarg2) {
9326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9327     return 0;
9328   }
9329   std::string arg2_str(jarg2);
9330   arg2 = &arg2_str;
9331   arg3 = (int)jarg3;
9332   {
9333     try {
9334       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
9335     } CALL_CATCH_EXCEPTION(0);
9336   }
9337
9338   jresult = (void *)result;
9339
9340   //argout typemap for const std::string&
9341
9342   return jresult;
9343 }
9344
9345
9346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
9347   Dali::Property *arg1 = (Dali::Property *) 0 ;
9348
9349   arg1 = (Dali::Property *)jarg1;
9350   {
9351     try {
9352       delete arg1;
9353     } CALL_CATCH_EXCEPTION();
9354   }
9355
9356 }
9357
9358
9359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
9360   Dali::Property *arg1 = (Dali::Property *) 0 ;
9361   Dali::Handle *arg2 = 0 ;
9362
9363   arg1 = (Dali::Property *)jarg1;
9364   arg2 = (Dali::Handle *)jarg2;
9365   if (!arg2) {
9366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9367     return ;
9368   }
9369   if (arg1) (arg1)->object = *arg2;
9370 }
9371
9372
9373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
9374   void * jresult ;
9375   Dali::Property *arg1 = (Dali::Property *) 0 ;
9376   Dali::Handle *result = 0 ;
9377
9378   arg1 = (Dali::Property *)jarg1;
9379   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
9380   jresult = (void *)result;
9381   return jresult;
9382 }
9383
9384
9385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
9386   Dali::Property *arg1 = (Dali::Property *) 0 ;
9387   Dali::Property::Index arg2 ;
9388
9389   arg1 = (Dali::Property *)jarg1;
9390   arg2 = (Dali::Property::Index)jarg2;
9391   if (arg1) (arg1)->propertyIndex = arg2;
9392 }
9393
9394
9395 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
9396   int jresult ;
9397   Dali::Property *arg1 = (Dali::Property *) 0 ;
9398   Dali::Property::Index result;
9399
9400   arg1 = (Dali::Property *)jarg1;
9401   result = (Dali::Property::Index) ((arg1)->propertyIndex);
9402   jresult = result;
9403   return jresult;
9404 }
9405
9406
9407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
9408   Dali::Property *arg1 = (Dali::Property *) 0 ;
9409   int arg2 ;
9410
9411   arg1 = (Dali::Property *)jarg1;
9412   arg2 = (int)jarg2;
9413   if (arg1) (arg1)->componentIndex = arg2;
9414 }
9415
9416
9417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
9418   int jresult ;
9419   Dali::Property *arg1 = (Dali::Property *) 0 ;
9420   int result;
9421
9422   arg1 = (Dali::Property *)jarg1;
9423   result = (int) ((arg1)->componentIndex);
9424   jresult = result;
9425   return jresult;
9426 }
9427
9428
9429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
9430   void * jresult ;
9431   Dali::Property::Array *result = 0 ;
9432
9433   {
9434     try {
9435       result = (Dali::Property::Array *)new Dali::Property::Array();
9436     } CALL_CATCH_EXCEPTION(0);
9437   }
9438
9439   jresult = (void *)result;
9440   return jresult;
9441 }
9442
9443
9444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
9445   void * jresult ;
9446   Dali::Property::Array *arg1 = 0 ;
9447   Dali::Property::Array *result = 0 ;
9448
9449   arg1 = (Dali::Property::Array *)jarg1;
9450   if (!arg1) {
9451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
9452     return 0;
9453   }
9454   {
9455     try {
9456       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
9457     } CALL_CATCH_EXCEPTION(0);
9458   }
9459
9460   jresult = (void *)result;
9461   return jresult;
9462 }
9463
9464
9465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
9466   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9467
9468   arg1 = (Dali::Property::Array *)jarg1;
9469   {
9470     try {
9471       delete arg1;
9472     } CALL_CATCH_EXCEPTION();
9473   }
9474
9475 }
9476
9477
9478 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
9479   unsigned long jresult ;
9480   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9481   Dali::Property::Array::SizeType result;
9482
9483   arg1 = (Dali::Property::Array *)jarg1;
9484   {
9485     try {
9486       result = ((Dali::Property::Array const *)arg1)->Size();
9487     } CALL_CATCH_EXCEPTION(0);
9488   }
9489
9490   jresult = (unsigned long)result;
9491   return jresult;
9492 }
9493
9494
9495 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
9496   unsigned long jresult ;
9497   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9498   Dali::Property::Array::SizeType result;
9499
9500   arg1 = (Dali::Property::Array *)jarg1;
9501   {
9502     try {
9503       result = ((Dali::Property::Array const *)arg1)->Count();
9504     } CALL_CATCH_EXCEPTION(0);
9505   }
9506
9507   jresult = (unsigned long)result;
9508   return jresult;
9509 }
9510
9511
9512 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
9513   bool jresult ;
9514   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9515   bool result;
9516
9517   arg1 = (Dali::Property::Array *)jarg1;
9518   {
9519     try {
9520       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
9521     } CALL_CATCH_EXCEPTION(0);
9522   }
9523
9524   jresult = result;
9525   return jresult;
9526 }
9527
9528
9529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
9530   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9531
9532   arg1 = (Dali::Property::Array *)jarg1;
9533   {
9534     try {
9535       (arg1)->Clear();
9536     } CALL_CATCH_EXCEPTION();
9537   }
9538
9539 }
9540
9541
9542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
9543   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9544   Dali::Property::Array::SizeType arg2 ;
9545
9546   arg1 = (Dali::Property::Array *)jarg1;
9547   arg2 = (Dali::Property::Array::SizeType)jarg2;
9548   {
9549     try {
9550       (arg1)->Reserve(arg2);
9551     } CALL_CATCH_EXCEPTION();
9552   }
9553
9554 }
9555
9556
9557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
9558   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9559   Dali::Property::Array::SizeType arg2 ;
9560
9561   arg1 = (Dali::Property::Array *)jarg1;
9562   arg2 = (Dali::Property::Array::SizeType)jarg2;
9563   {
9564     try {
9565       (arg1)->Resize(arg2);
9566     } CALL_CATCH_EXCEPTION();
9567   }
9568
9569 }
9570
9571
9572 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
9573   unsigned long jresult ;
9574   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9575   Dali::Property::Array::SizeType result;
9576
9577   arg1 = (Dali::Property::Array *)jarg1;
9578   {
9579     try {
9580       result = (arg1)->Capacity();
9581     } CALL_CATCH_EXCEPTION(0);
9582   }
9583
9584   jresult = (unsigned long)result;
9585   return jresult;
9586 }
9587
9588
9589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
9590   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9591   Dali::Property::Value *arg2 = 0 ;
9592
9593   arg1 = (Dali::Property::Array *)jarg1;
9594   arg2 = (Dali::Property::Value *)jarg2;
9595   if (!arg2) {
9596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
9597     return ;
9598   }
9599   {
9600     try {
9601       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
9602     } CALL_CATCH_EXCEPTION();
9603   }
9604
9605 }
9606
9607
9608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
9609   void * jresult ;
9610   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9611   Dali::Property::Value *arg2 = 0 ;
9612   Dali::Property::Array *result = 0 ;
9613
9614   arg1 = (Dali::Property::Array *)jarg1;
9615   arg2 = (Dali::Property::Value *)jarg2;
9616   if (!arg2) {
9617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
9618     return 0;
9619   }
9620   {
9621     try {
9622       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
9623     } CALL_CATCH_EXCEPTION(0);
9624   }
9625
9626   jresult = (void *)result;
9627   return jresult;
9628 }
9629
9630
9631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
9632   void * jresult ;
9633   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9634   Dali::Property::Array::SizeType arg2 ;
9635   Dali::Property::Value *result = 0 ;
9636
9637   arg1 = (Dali::Property::Array *)jarg1;
9638   arg2 = (Dali::Property::Array::SizeType)jarg2;
9639   {
9640     try {
9641       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
9642     } CALL_CATCH_EXCEPTION(0);
9643   }
9644
9645   jresult = (void *)result;
9646   return jresult;
9647 }
9648
9649
9650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
9651   void * jresult ;
9652   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9653   Dali::Property::Array::SizeType arg2 ;
9654   Dali::Property::Value *result = 0 ;
9655
9656   arg1 = (Dali::Property::Array *)jarg1;
9657   arg2 = (Dali::Property::Array::SizeType)jarg2;
9658   {
9659     try {
9660       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
9661     } CALL_CATCH_EXCEPTION(0);
9662   }
9663
9664   jresult = (void *)result;
9665   return jresult;
9666 }
9667
9668
9669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
9670   void * jresult ;
9671   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9672   Dali::Property::Array *arg2 = 0 ;
9673   Dali::Property::Array *result = 0 ;
9674
9675   arg1 = (Dali::Property::Array *)jarg1;
9676   arg2 = (Dali::Property::Array *)jarg2;
9677   if (!arg2) {
9678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
9679     return 0;
9680   }
9681   {
9682     try {
9683       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
9684     } CALL_CATCH_EXCEPTION(0);
9685   }
9686
9687   jresult = (void *)result;
9688   return jresult;
9689 }
9690
9691
9692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
9693   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9694   enum Dali::Property::Key::Type arg2 ;
9695
9696   arg1 = (Dali::Property::Key *)jarg1;
9697   arg2 = (enum Dali::Property::Key::Type)jarg2;
9698   if (arg1) (arg1)->type = arg2;
9699 }
9700
9701
9702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
9703   int jresult ;
9704   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9705   enum Dali::Property::Key::Type result;
9706
9707   arg1 = (Dali::Property::Key *)jarg1;
9708   result = (enum Dali::Property::Key::Type) ((arg1)->type);
9709   jresult = (int)result;
9710   return jresult;
9711 }
9712
9713
9714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
9715   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9716   Dali::Property::Index arg2 ;
9717
9718   arg1 = (Dali::Property::Key *)jarg1;
9719   arg2 = (Dali::Property::Index)jarg2;
9720   if (arg1) (arg1)->indexKey = arg2;
9721 }
9722
9723
9724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
9725   int jresult ;
9726   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9727   Dali::Property::Index result;
9728
9729   arg1 = (Dali::Property::Key *)jarg1;
9730   result = (Dali::Property::Index) ((arg1)->indexKey);
9731   jresult = result;
9732   return jresult;
9733 }
9734
9735
9736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
9737   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9738   std::string *arg2 = 0 ;
9739
9740   arg1 = (Dali::Property::Key *)jarg1;
9741   if (!jarg2) {
9742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9743     return ;
9744   }
9745   std::string arg2_str(jarg2);
9746   arg2 = &arg2_str;
9747   if (arg1) (arg1)->stringKey = *arg2;
9748
9749   //argout typemap for const std::string&
9750
9751 }
9752
9753
9754 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
9755   char * jresult ;
9756   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9757   std::string *result = 0 ;
9758
9759   arg1 = (Dali::Property::Key *)jarg1;
9760   result = (std::string *) & ((arg1)->stringKey);
9761   jresult = SWIG_csharp_string_callback(result->c_str());
9762   return jresult;
9763 }
9764
9765
9766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
9767   void * jresult ;
9768   std::string *arg1 = 0 ;
9769   Dali::Property::Key *result = 0 ;
9770
9771   if (!jarg1) {
9772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9773     return 0;
9774   }
9775   std::string arg1_str(jarg1);
9776   arg1 = &arg1_str;
9777   {
9778     try {
9779       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
9780     } CALL_CATCH_EXCEPTION(0);
9781   }
9782
9783   jresult = (void *)result;
9784
9785   //argout typemap for const std::string&
9786
9787   return jresult;
9788 }
9789
9790
9791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
9792   void * jresult ;
9793   Dali::Property::Index arg1 ;
9794   Dali::Property::Key *result = 0 ;
9795
9796   arg1 = (Dali::Property::Index)jarg1;
9797   {
9798     try {
9799       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
9800     } CALL_CATCH_EXCEPTION(0);
9801   }
9802
9803   jresult = (void *)result;
9804   return jresult;
9805 }
9806
9807
9808 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
9809   bool jresult ;
9810   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9811   std::string *arg2 = 0 ;
9812   bool result;
9813
9814   arg1 = (Dali::Property::Key *)jarg1;
9815   if (!jarg2) {
9816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9817     return 0;
9818   }
9819   std::string arg2_str(jarg2);
9820   arg2 = &arg2_str;
9821   {
9822     try {
9823       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
9824     } CALL_CATCH_EXCEPTION(0);
9825   }
9826
9827   jresult = result;
9828
9829   //argout typemap for const std::string&
9830
9831   return jresult;
9832 }
9833
9834
9835 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
9836   bool jresult ;
9837   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9838   Dali::Property::Index arg2 ;
9839   bool result;
9840
9841   arg1 = (Dali::Property::Key *)jarg1;
9842   arg2 = (Dali::Property::Index)jarg2;
9843   {
9844     try {
9845       result = (bool)(arg1)->operator ==(arg2);
9846     } CALL_CATCH_EXCEPTION(0);
9847   }
9848
9849   jresult = result;
9850   return jresult;
9851 }
9852
9853
9854 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
9855   bool jresult ;
9856   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9857   Dali::Property::Key *arg2 = 0 ;
9858   bool result;
9859
9860   arg1 = (Dali::Property::Key *)jarg1;
9861   arg2 = (Dali::Property::Key *)jarg2;
9862   if (!arg2) {
9863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
9864     return 0;
9865   }
9866   {
9867     try {
9868       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
9869     } CALL_CATCH_EXCEPTION(0);
9870   }
9871
9872   jresult = result;
9873   return jresult;
9874 }
9875
9876
9877 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
9878   bool jresult ;
9879   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9880   std::string *arg2 = 0 ;
9881   bool result;
9882
9883   arg1 = (Dali::Property::Key *)jarg1;
9884   if (!jarg2) {
9885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9886     return 0;
9887   }
9888   std::string arg2_str(jarg2);
9889   arg2 = &arg2_str;
9890   {
9891     try {
9892       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
9893     } CALL_CATCH_EXCEPTION(0);
9894   }
9895
9896   jresult = result;
9897
9898   //argout typemap for const std::string&
9899
9900   return jresult;
9901 }
9902
9903
9904 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
9905   bool jresult ;
9906   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9907   Dali::Property::Index arg2 ;
9908   bool result;
9909
9910   arg1 = (Dali::Property::Key *)jarg1;
9911   arg2 = (Dali::Property::Index)jarg2;
9912   {
9913     try {
9914       result = (bool)(arg1)->operator !=(arg2);
9915     } CALL_CATCH_EXCEPTION(0);
9916   }
9917
9918   jresult = result;
9919   return jresult;
9920 }
9921
9922
9923 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
9924   bool jresult ;
9925   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9926   Dali::Property::Key *arg2 = 0 ;
9927   bool result;
9928
9929   arg1 = (Dali::Property::Key *)jarg1;
9930   arg2 = (Dali::Property::Key *)jarg2;
9931   if (!arg2) {
9932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
9933     return 0;
9934   }
9935   {
9936     try {
9937       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
9938     } CALL_CATCH_EXCEPTION(0);
9939   }
9940
9941   jresult = result;
9942   return jresult;
9943 }
9944
9945
9946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
9947   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9948
9949   arg1 = (Dali::Property::Key *)jarg1;
9950   {
9951     try {
9952       delete arg1;
9953     } CALL_CATCH_EXCEPTION();
9954   }
9955
9956 }
9957
9958
9959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
9960   void * jresult ;
9961   Dali::Property::Map *result = 0 ;
9962
9963   {
9964     try {
9965       result = (Dali::Property::Map *)new Dali::Property::Map();
9966     } CALL_CATCH_EXCEPTION(0);
9967   }
9968
9969   jresult = (void *)result;
9970   return jresult;
9971 }
9972
9973
9974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
9975   void * jresult ;
9976   Dali::Property::Map *arg1 = 0 ;
9977   Dali::Property::Map *result = 0 ;
9978
9979   arg1 = (Dali::Property::Map *)jarg1;
9980   if (!arg1) {
9981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
9982     return 0;
9983   }
9984   {
9985     try {
9986       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
9987     } CALL_CATCH_EXCEPTION(0);
9988   }
9989
9990   jresult = (void *)result;
9991   return jresult;
9992 }
9993
9994
9995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
9996   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
9997
9998   arg1 = (Dali::Property::Map *)jarg1;
9999   {
10000     try {
10001       delete arg1;
10002     } CALL_CATCH_EXCEPTION();
10003   }
10004
10005 }
10006
10007
10008 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
10009   unsigned long jresult ;
10010   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10011   Dali::Property::Map::SizeType result;
10012
10013   arg1 = (Dali::Property::Map *)jarg1;
10014   {
10015     try {
10016       result = ((Dali::Property::Map const *)arg1)->Count();
10017     } CALL_CATCH_EXCEPTION(0);
10018   }
10019
10020   jresult = (unsigned long)result;
10021   return jresult;
10022 }
10023
10024
10025 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
10026   bool jresult ;
10027   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10028   bool result;
10029
10030   arg1 = (Dali::Property::Map *)jarg1;
10031   {
10032     try {
10033       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
10034     } CALL_CATCH_EXCEPTION(0);
10035   }
10036
10037   jresult = result;
10038   return jresult;
10039 }
10040
10041
10042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
10043   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10044   char *arg2 = (char *) 0 ;
10045   Dali::Property::Value *arg3 = 0 ;
10046
10047   arg1 = (Dali::Property::Map *)jarg1;
10048   arg2 = (char *)jarg2;
10049   arg3 = (Dali::Property::Value *)jarg3;
10050   if (!arg3) {
10051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10052     return ;
10053   }
10054   {
10055     try {
10056       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
10057     } CALL_CATCH_EXCEPTION();
10058   }
10059
10060 }
10061
10062
10063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Bool__SWIG_0(void * jarg1, const char * jarg2, bool jarg3) {
10064   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10065
10066   arg1 = (Dali::Property::Map *)jarg1;
10067   {
10068     try {
10069       (arg1)->Insert(jarg2,(Dali::Property::Value const &)(jarg3));
10070     } CALL_CATCH_EXCEPTION();
10071   }
10072
10073 }
10074
10075
10076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Float__SWIG_0(void * jarg1, const char * jarg2, float jarg3) {
10077   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10078
10079   arg1 = (Dali::Property::Map *)jarg1;
10080   {
10081     try {
10082       (arg1)->Insert(jarg2,(Dali::Property::Value const &)(jarg3));
10083     } CALL_CATCH_EXCEPTION();
10084   }
10085
10086 }
10087
10088
10089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_String__SWIG_0(void * jarg1, const char * jarg2, const char * jarg3) {
10090   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10091
10092   arg1 = (Dali::Property::Map *)jarg1;
10093   {
10094     try {
10095       (arg1)->Insert(jarg2,(Dali::Property::Value const &)(jarg3));
10096     } CALL_CATCH_EXCEPTION();
10097   }
10098
10099 }
10100
10101
10102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Vector2__SWIG_0(void * jarg1, const char * jarg2, float jarg3, float jarg4) {
10103   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10104
10105   arg1 = (Dali::Property::Map *)jarg1;
10106   {
10107     try {
10108       (arg1)->Insert(jarg2,(Dali::Property::Value const &)(Dali::Vector2(jarg3, jarg4)));
10109     } CALL_CATCH_EXCEPTION();
10110   }
10111
10112 }
10113
10114
10115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Vector3__SWIG_0(void * jarg1, const char * jarg2, float jarg3, float jarg4, float jarg5) {
10116   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10117
10118   arg1 = (Dali::Property::Map *)jarg1;
10119   {
10120     try {
10121       (arg1)->Insert(jarg2,(Dali::Property::Value const &)(Dali::Vector3(jarg3, jarg4, jarg5)));
10122     } CALL_CATCH_EXCEPTION();
10123   }
10124
10125 }
10126
10127
10128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Vector4__SWIG_0(void * jarg1, const char * jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
10129   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10130
10131   arg1 = (Dali::Property::Map *)jarg1;
10132   {
10133     try {
10134       (arg1)->Insert(jarg2,(Dali::Property::Value const &)(Dali::Vector4(jarg3, jarg4, jarg5, jarg6)));
10135     } CALL_CATCH_EXCEPTION();
10136   }
10137
10138 }
10139
10140
10141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
10142   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10143   Dali::Property::Index arg2 ;
10144   Dali::Property::Value *arg3 = 0 ;
10145
10146   arg1 = (Dali::Property::Map *)jarg1;
10147   arg2 = (Dali::Property::Index)jarg2;
10148   arg3 = (Dali::Property::Value *)jarg3;
10149   if (!arg3) {
10150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10151     return ;
10152   }
10153   {
10154     try {
10155       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
10156     } CALL_CATCH_EXCEPTION();
10157   }
10158
10159 }
10160
10161
10162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Int__SWIG_2(void * jarg1, int jarg2, int jarg3) {
10163   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10164   Dali::Property::Index arg2 ;
10165
10166   arg1 = (Dali::Property::Map *)jarg1;
10167   arg2 = (Dali::Property::Index)jarg2;
10168   {
10169     try {
10170       (arg1)->Insert(arg2,(Dali::Property::Value const &)(jarg3));
10171     } CALL_CATCH_EXCEPTION();
10172   }
10173
10174 }
10175
10176
10177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Bool__SWIG_2(void * jarg1, int jarg2, bool jarg3) {
10178   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10179   Dali::Property::Index arg2 ;
10180
10181   arg1 = (Dali::Property::Map *)jarg1;
10182   arg2 = (Dali::Property::Index)jarg2;
10183   {
10184     try {
10185       (arg1)->Insert(arg2,(Dali::Property::Value const &)(jarg3));
10186     } CALL_CATCH_EXCEPTION();
10187   }
10188
10189 }
10190
10191
10192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Float__SWIG_2(void * jarg1, int jarg2, float jarg3) {
10193   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10194   Dali::Property::Index arg2 ;
10195
10196   arg1 = (Dali::Property::Map *)jarg1;
10197   arg2 = (Dali::Property::Index)jarg2;
10198   {
10199     try {
10200       (arg1)->Insert(arg2,(Dali::Property::Value const &)(jarg3));
10201     } CALL_CATCH_EXCEPTION();
10202   }
10203
10204 }
10205
10206
10207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_String__SWIG_2(void * jarg1, int jarg2, char * jarg3) {
10208   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10209   Dali::Property::Index arg2 ;
10210
10211   arg1 = (Dali::Property::Map *)jarg1;
10212   arg2 = (Dali::Property::Index)jarg2;
10213   {
10214     try {
10215       (arg1)->Insert(arg2,(Dali::Property::Value const &)(jarg3));
10216     } CALL_CATCH_EXCEPTION();
10217   }
10218
10219 }
10220
10221
10222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Vector2__SWIG_2(void * jarg1, int jarg2, float jarg3, float jarg4) {
10223   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10224   Dali::Property::Index arg2 ;
10225
10226   arg1 = (Dali::Property::Map *)jarg1;
10227   arg2 = (Dali::Property::Index)jarg2;
10228   {
10229     try {
10230       (arg1)->Insert(arg2,(Dali::Property::Value const &)(Dali::Vector2(jarg3, jarg4)));
10231     } CALL_CATCH_EXCEPTION();
10232   }
10233
10234 }
10235
10236
10237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Vector3__SWIG_2(void * jarg1, int jarg2, float jarg3, float jarg4, float jarg5) {
10238   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10239   Dali::Property::Index arg2 ;
10240
10241   arg1 = (Dali::Property::Map *)jarg1;
10242   arg2 = (Dali::Property::Index)jarg2;
10243   {
10244     try {
10245       (arg1)->Insert(arg2,(Dali::Property::Value const &)(Dali::Vector3(jarg3, jarg4, jarg5)));
10246     } CALL_CATCH_EXCEPTION();
10247   }
10248
10249 }
10250
10251
10252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Vector4__SWIG_2(void * jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
10253   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10254   Dali::Property::Index arg2 ;
10255
10256   arg1 = (Dali::Property::Map *)jarg1;
10257   arg2 = (Dali::Property::Index)jarg2;
10258   {
10259     try {
10260       (arg1)->Insert(arg2,(Dali::Property::Value const &)(Dali::Vector4(jarg3, jarg4, jarg5, jarg6)));
10261     } CALL_CATCH_EXCEPTION();
10262   }
10263
10264 }
10265
10266
10267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
10268   void * jresult ;
10269   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10270   char *arg2 = (char *) 0 ;
10271   Dali::Property::Value *arg3 = 0 ;
10272   Dali::Property::Map *result = 0 ;
10273
10274   arg1 = (Dali::Property::Map *)jarg1;
10275   arg2 = (char *)jarg2;
10276   arg3 = (Dali::Property::Value *)jarg3;
10277   if (!arg3) {
10278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10279     return 0;
10280   }
10281   {
10282     try {
10283       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
10284     } CALL_CATCH_EXCEPTION(0);
10285   }
10286
10287   jresult = (void *)result;
10288   return jresult;
10289 }
10290
10291
10292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
10293   void * jresult ;
10294   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10295   Dali::Property::Index arg2 ;
10296   Dali::Property::Value *arg3 = 0 ;
10297   Dali::Property::Map *result = 0 ;
10298
10299   arg1 = (Dali::Property::Map *)jarg1;
10300   arg2 = (Dali::Property::Index)jarg2;
10301   arg3 = (Dali::Property::Value *)jarg3;
10302   if (!arg3) {
10303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10304     return 0;
10305   }
10306   {
10307     try {
10308       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
10309     } CALL_CATCH_EXCEPTION(0);
10310   }
10311
10312   jresult = (void *)result;
10313   return jresult;
10314 }
10315
10316
10317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
10318   void * jresult ;
10319   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10320   Dali::Property::Map::SizeType arg2 ;
10321   Dali::Property::Value *result = 0 ;
10322
10323   arg1 = (Dali::Property::Map *)jarg1;
10324   arg2 = (Dali::Property::Map::SizeType)jarg2;
10325   {
10326     try {
10327       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
10328     } CALL_CATCH_EXCEPTION(0);
10329   }
10330
10331   jresult = (void *)result;
10332   return jresult;
10333 }
10334
10335
10336 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
10337   char * jresult ;
10338   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10339   Dali::Property::Map::SizeType arg2 ;
10340   std::string *result = 0 ;
10341
10342   arg1 = (Dali::Property::Map *)jarg1;
10343   arg2 = (Dali::Property::Map::SizeType)jarg2;
10344   {
10345     try {
10346       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
10347     } CALL_CATCH_EXCEPTION(0);
10348   }
10349
10350   jresult = SWIG_csharp_string_callback(result->c_str());
10351   return jresult;
10352 }
10353
10354
10355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
10356   void * jresult ;
10357   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10358   Dali::Property::Map::SizeType arg2 ;
10359   SwigValueWrapper< Dali::Property::Key > result;
10360
10361   arg1 = (Dali::Property::Map *)jarg1;
10362   arg2 = (Dali::Property::Map::SizeType)jarg2;
10363   {
10364     try {
10365       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
10366     } CALL_CATCH_EXCEPTION(0);
10367   }
10368
10369   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
10370   return jresult;
10371 }
10372
10373
10374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
10375   void * jresult ;
10376   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10377   Dali::Property::Map::SizeType arg2 ;
10378   StringValuePair *result = 0 ;
10379
10380   arg1 = (Dali::Property::Map *)jarg1;
10381   arg2 = (Dali::Property::Map::SizeType)jarg2;
10382   {
10383     try {
10384       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
10385     } CALL_CATCH_EXCEPTION(0);
10386   }
10387
10388   jresult = (void *)result;
10389   return jresult;
10390 }
10391
10392
10393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
10394   void * jresult ;
10395   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10396   char *arg2 = (char *) 0 ;
10397   Dali::Property::Value *result = 0 ;
10398
10399   arg1 = (Dali::Property::Map *)jarg1;
10400   arg2 = (char *)jarg2;
10401   {
10402     try {
10403       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
10404     } CALL_CATCH_EXCEPTION(0);
10405   }
10406
10407   jresult = (void *)result;
10408   return jresult;
10409 }
10410
10411
10412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
10413   void * jresult ;
10414   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10415   Dali::Property::Index arg2 ;
10416   Dali::Property::Value *result = 0 ;
10417
10418   arg1 = (Dali::Property::Map *)jarg1;
10419   arg2 = (Dali::Property::Index)jarg2;
10420   {
10421     try {
10422       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
10423     } CALL_CATCH_EXCEPTION(0);
10424   }
10425
10426   jresult = (void *)result;
10427   return jresult;
10428 }
10429
10430
10431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
10432   void * jresult ;
10433   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10434   Dali::Property::Index arg2 ;
10435   std::string *arg3 = 0 ;
10436   Dali::Property::Value *result = 0 ;
10437
10438   arg1 = (Dali::Property::Map *)jarg1;
10439   arg2 = (Dali::Property::Index)jarg2;
10440   if (!jarg3) {
10441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10442     return 0;
10443   }
10444   std::string arg3_str(jarg3);
10445   arg3 = &arg3_str;
10446   {
10447     try {
10448       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
10449     } CALL_CATCH_EXCEPTION(0);
10450   }
10451
10452   jresult = (void *)result;
10453
10454   //argout typemap for const std::string&
10455
10456   return jresult;
10457 }
10458
10459
10460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
10461   void * jresult ;
10462   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10463   std::string *arg2 = 0 ;
10464   Dali::Property::Type arg3 ;
10465   Dali::Property::Value *result = 0 ;
10466
10467   arg1 = (Dali::Property::Map *)jarg1;
10468   if (!jarg2) {
10469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10470     return 0;
10471   }
10472   std::string arg2_str(jarg2);
10473   arg2 = &arg2_str;
10474   arg3 = (Dali::Property::Type)jarg3;
10475   {
10476     try {
10477       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
10478     } CALL_CATCH_EXCEPTION(0);
10479   }
10480
10481   jresult = (void *)result;
10482
10483   //argout typemap for const std::string&
10484
10485   return jresult;
10486 }
10487
10488
10489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
10490   void * jresult ;
10491   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10492   Dali::Property::Index arg2 ;
10493   Dali::Property::Type arg3 ;
10494   Dali::Property::Value *result = 0 ;
10495
10496   arg1 = (Dali::Property::Map *)jarg1;
10497   arg2 = (Dali::Property::Index)jarg2;
10498   arg3 = (Dali::Property::Type)jarg3;
10499   {
10500     try {
10501       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
10502     } CALL_CATCH_EXCEPTION(0);
10503   }
10504
10505   jresult = (void *)result;
10506   return jresult;
10507 }
10508
10509
10510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
10511   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10512
10513   arg1 = (Dali::Property::Map *)jarg1;
10514   {
10515     try {
10516       (arg1)->Clear();
10517     } CALL_CATCH_EXCEPTION();
10518   }
10519
10520 }
10521
10522
10523 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Map_Remove__SWIG_0(void * map, int key) {
10524   Dali::Property::Map *propertyMap = (Dali::Property::Map *)map;
10525   Dali::Property::Index intKey = (Dali::Property::Index)key;
10526   bool isRemoved = false;
10527   {
10528     try {
10529       isRemoved = propertyMap->Remove(intKey);
10530     } CALL_CATCH_EXCEPTION(0);
10531   }
10532   return isRemoved;
10533 }
10534
10535
10536 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Map_Remove__SWIG_1(void * map, char * key) {
10537   Dali::Property::Map *propertyMap = (Dali::Property::Map *)map;
10538   std::string strKey(key);
10539   bool isRemoved = false;
10540   {
10541     try {
10542       isRemoved = propertyMap->Remove(strKey);
10543     } CALL_CATCH_EXCEPTION(0);
10544   }
10545   return isRemoved;
10546 }
10547
10548
10549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
10550   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10551   Dali::Property::Map *arg2 = 0 ;
10552
10553   arg1 = (Dali::Property::Map *)jarg1;
10554   arg2 = (Dali::Property::Map *)jarg2;
10555   if (!arg2) {
10556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
10557     return ;
10558   }
10559   {
10560     try {
10561       (arg1)->Merge((Dali::Property::Map const &)*arg2);
10562     } CALL_CATCH_EXCEPTION();
10563   }
10564
10565 }
10566
10567
10568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
10569   void * jresult ;
10570   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10571   std::string *arg2 = 0 ;
10572   Dali::Property::Value *result = 0 ;
10573
10574   arg1 = (Dali::Property::Map *)jarg1;
10575   if (!jarg2) {
10576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10577     return 0;
10578   }
10579   std::string arg2_str(jarg2);
10580   arg2 = &arg2_str;
10581   {
10582     try {
10583       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
10584     } CALL_CATCH_EXCEPTION(0);
10585   }
10586
10587   jresult = (void *)result;
10588
10589   //argout typemap for const std::string&
10590
10591   return jresult;
10592 }
10593
10594
10595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
10596   void * jresult ;
10597   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10598   Dali::Property::Index arg2 ;
10599   Dali::Property::Value *result = 0 ;
10600
10601   arg1 = (Dali::Property::Map *)jarg1;
10602   arg2 = (Dali::Property::Index)jarg2;
10603   {
10604     try {
10605       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
10606     } CALL_CATCH_EXCEPTION(0);
10607   }
10608
10609   jresult = (void *)result;
10610   return jresult;
10611 }
10612
10613
10614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
10615   void * jresult ;
10616   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10617   Dali::Property::Map *arg2 = 0 ;
10618   Dali::Property::Map *result = 0 ;
10619
10620   arg1 = (Dali::Property::Map *)jarg1;
10621   arg2 = (Dali::Property::Map *)jarg2;
10622   if (!arg2) {
10623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
10624     return 0;
10625   }
10626   {
10627     try {
10628       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
10629     } CALL_CATCH_EXCEPTION(0);
10630   }
10631
10632   jresult = (void *)result;
10633   return jresult;
10634 }
10635
10636
10637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) {
10638
10639   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10640
10641   if (!jarg2) {
10642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10643     return;
10644   }
10645   std::string arg2_str(jarg2);
10646   std::string* arg2 = &arg2_str;
10647
10648   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
10649
10650   {
10651     try {
10652       arg1->operator[]((std::string const &)*arg2) = *arg3;
10653     } CALL_CATCH_EXCEPTION();
10654   }
10655 }
10656
10657
10658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey_IntValue(void* jarg1, const char* jarg2, int jarg3) {
10659
10660   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10661
10662   if (!jarg2) {
10663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10664     return;
10665   }
10666   Dali::Property::Index arg3 = (Dali::Property::Index)jarg3;
10667
10668   {
10669     try {
10670       arg1->operator[](std::string_view(jarg2)) = (Dali::Property::Value const &)(arg3);
10671     } CALL_CATCH_EXCEPTION();
10672   }
10673 }
10674
10675
10676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey_BoolValue(void* jarg1, const char* jarg2, bool jarg3) {
10677
10678   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10679
10680   if (!jarg2) {
10681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10682     return;
10683   }
10684
10685   {
10686     try {
10687       arg1->operator[](std::string_view(jarg2)) = (Dali::Property::Value const &)(jarg3);
10688     } CALL_CATCH_EXCEPTION();
10689   }
10690 }
10691
10692
10693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey_FloatValue(void* jarg1, const char* jarg2, float jarg3) {
10694
10695   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10696
10697   if (!jarg2) {
10698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10699     return;
10700   }
10701
10702   {
10703     try {
10704       arg1->operator[](std::string_view(jarg2)) = (Dali::Property::Value const &)(jarg3);
10705     } CALL_CATCH_EXCEPTION();
10706   }
10707 }
10708
10709
10710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey_StringValue(void* jarg1, const char* jarg2, const char* jarg3) {
10711
10712   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10713
10714   if (!jarg2) {
10715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10716     return;
10717   }
10718
10719   {
10720     try {
10721       arg1->operator[](std::string_view(jarg2)) = (Dali::Property::Value const &)(jarg3);
10722     } CALL_CATCH_EXCEPTION();
10723   }
10724 }
10725
10726
10727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey_Vector2(void* jarg1, const char* jarg2, float jarg3, float jarg4) {
10728
10729   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10730
10731   if (!jarg2) {
10732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10733     return;
10734   }
10735
10736   {
10737     try {
10738       arg1->operator[](std::string_view(jarg2)) = (Dali::Property::Value const &)(Dali::Vector2(jarg3, jarg4));
10739     } CALL_CATCH_EXCEPTION();
10740   }
10741 }
10742
10743
10744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey_Vector4(void* jarg1, const char* jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
10745
10746   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10747
10748   if (!jarg2) {
10749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10750     return;
10751   }
10752
10753   {
10754     try {
10755       arg1->operator[](std::string_view(jarg2)) = (Dali::Property::Value const &)(Dali::Vector4(jarg3, jarg4, jarg5, jarg6));
10756     } CALL_CATCH_EXCEPTION();
10757   }
10758 }
10759
10760
10761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey_Rect(void* jarg1, char* jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
10762
10763   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10764
10765   if (!jarg2) {
10766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10767     return;
10768   }
10769
10770   {
10771     try {
10772       arg1->operator[](std::string(jarg2)) = (Dali::Property::Value const &)(Dali::Rect< int >(jarg3, jarg4, jarg5, jarg6));
10773     } CALL_CATCH_EXCEPTION();
10774   }
10775 }
10776
10777
10778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
10779
10780   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10781   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
10782   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
10783
10784   {
10785     try {
10786       arg1->operator[](arg2) = *arg3;
10787     } CALL_CATCH_EXCEPTION();
10788   }
10789 }
10790
10791
10792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey_IntValue(void* jarg1, int jarg2, int jarg3) {
10793
10794   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10795   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
10796   Dali::Property::Index arg3 = (Dali::Property::Index)jarg3;
10797
10798   {
10799     try {
10800       arg1->operator[](arg2) = (Dali::Property::Value const &)(arg3);
10801     } CALL_CATCH_EXCEPTION();
10802   }
10803 }
10804
10805
10806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey_BoolValue(void* jarg1, int jarg2, bool jarg3) {
10807
10808   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10809   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
10810   bool arg3 = (bool)jarg3;
10811
10812   {
10813     try {
10814       arg1->operator[](arg2) = (Dali::Property::Value const &)(arg3);
10815     } CALL_CATCH_EXCEPTION();
10816   }
10817 }
10818
10819
10820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey_FloatValue(void* jarg1, int jarg2, float jarg3) {
10821
10822   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10823   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
10824   float arg3 = (float)jarg3;
10825
10826   {
10827     try {
10828       arg1->operator[](arg2) = (Dali::Property::Value const &)(arg3);
10829     } CALL_CATCH_EXCEPTION();
10830   }
10831 }
10832
10833
10834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey_StringValue(void* jarg1, int jarg2, char* jarg3) {
10835
10836   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10837   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
10838   char *arg3 = (char *)jarg3;
10839
10840   {
10841     try {
10842       arg1->operator[](arg2) = (Dali::Property::Value const &)(arg3);
10843     } CALL_CATCH_EXCEPTION();
10844   }
10845 }
10846
10847
10848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey_Vector2(void* jarg1, int jarg2, float jarg3, float jarg4) {
10849
10850   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10851   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
10852
10853   {
10854     try {
10855       arg1->operator[](arg2) = (Dali::Property::Value const &)(Dali::Vector2(jarg3, jarg4));
10856     } CALL_CATCH_EXCEPTION();
10857   }
10858 }
10859
10860
10861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey_Vector4(void* jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
10862
10863   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10864   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
10865
10866   {
10867     try {
10868       arg1->operator[](arg2) = (Dali::Property::Value const &)(Dali::Vector4(jarg3, jarg4, jarg5, jarg6));
10869     } CALL_CATCH_EXCEPTION();
10870   }
10871 }
10872
10873
10874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey_Rect(void* jarg1, int jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
10875
10876   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10877   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
10878   Dali::Rect< int > *arg3 = 0 ;
10879
10880   arg3 = (Dali::Rect< int > *)new Dali::Rect< int >(jarg3, jarg4, jarg5, jarg6);
10881
10882   {
10883     try {
10884       arg1->operator[](arg2) = (Dali::Property::Value const &)(*arg3);
10885     } CALL_CATCH_EXCEPTION();
10886   }
10887 }
10888
10889
10890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
10891   void * jresult ;
10892   Dali::Property::Value *result = 0 ;
10893
10894   {
10895     try {
10896       result = (Dali::Property::Value *)new Dali::Property::Value();
10897     } CALL_CATCH_EXCEPTION(0);
10898   }
10899
10900   jresult = (void *)result;
10901   return jresult;
10902 }
10903
10904
10905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(bool jarg1) {
10906   void * jresult ;
10907   bool arg1 ;
10908   Dali::Property::Value *result = 0 ;
10909
10910   arg1 = jarg1 ? true : false;
10911   {
10912     try {
10913       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
10914     } CALL_CATCH_EXCEPTION(0);
10915   }
10916
10917   jresult = (void *)result;
10918   return jresult;
10919 }
10920
10921
10922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
10923   void * jresult ;
10924   int arg1 ;
10925   Dali::Property::Value *result = 0 ;
10926
10927   arg1 = (int)jarg1;
10928   {
10929     try {
10930       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
10931     } CALL_CATCH_EXCEPTION(0);
10932   }
10933
10934   jresult = (void *)result;
10935   return jresult;
10936 }
10937
10938
10939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
10940   void * jresult ;
10941   float arg1 ;
10942   Dali::Property::Value *result = 0 ;
10943
10944   arg1 = (float)jarg1;
10945   {
10946     try {
10947       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
10948     } CALL_CATCH_EXCEPTION(0);
10949   }
10950
10951   jresult = (void *)result;
10952   return jresult;
10953 }
10954
10955
10956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
10957   void * jresult ;
10958   Dali::Vector2 *arg1 = 0 ;
10959   Dali::Property::Value *result = 0 ;
10960
10961   arg1 = (Dali::Vector2 *)jarg1;
10962   if (!arg1) {
10963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
10964     return 0;
10965   }
10966   {
10967     try {
10968       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
10969     } CALL_CATCH_EXCEPTION(0);
10970   }
10971
10972   jresult = (void *)result;
10973   return jresult;
10974 }
10975
10976
10977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
10978   void * jresult ;
10979   Dali::Vector3 *arg1 = 0 ;
10980   Dali::Property::Value *result = 0 ;
10981
10982   arg1 = (Dali::Vector3 *)jarg1;
10983   if (!arg1) {
10984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10985     return 0;
10986   }
10987   {
10988     try {
10989       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
10990     } CALL_CATCH_EXCEPTION(0);
10991   }
10992
10993   jresult = (void *)result;
10994   return jresult;
10995 }
10996
10997
10998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
10999   void * jresult ;
11000   Dali::Vector4 *arg1 = 0 ;
11001   Dali::Property::Value *result = 0 ;
11002
11003   arg1 = (Dali::Vector4 *)jarg1;
11004   if (!arg1) {
11005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11006     return 0;
11007   }
11008   {
11009     try {
11010       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
11011     } CALL_CATCH_EXCEPTION(0);
11012   }
11013
11014   jresult = (void *)result;
11015   return jresult;
11016 }
11017
11018
11019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
11020   void * jresult ;
11021   Dali::Matrix3 *arg1 = 0 ;
11022   Dali::Property::Value *result = 0 ;
11023
11024   arg1 = (Dali::Matrix3 *)jarg1;
11025   if (!arg1) {
11026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11027     return 0;
11028   }
11029   {
11030     try {
11031       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
11032     } CALL_CATCH_EXCEPTION(0);
11033   }
11034
11035   jresult = (void *)result;
11036   return jresult;
11037 }
11038
11039
11040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
11041   void * jresult ;
11042   Dali::Matrix *arg1 = 0 ;
11043   Dali::Property::Value *result = 0 ;
11044
11045   arg1 = (Dali::Matrix *)jarg1;
11046   if (!arg1) {
11047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11048     return 0;
11049   }
11050   {
11051     try {
11052       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
11053     } CALL_CATCH_EXCEPTION(0);
11054   }
11055
11056   jresult = (void *)result;
11057   return jresult;
11058 }
11059
11060
11061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
11062   void * jresult ;
11063   Dali::Rect< int > *arg1 = 0 ;
11064   Dali::Property::Value *result = 0 ;
11065
11066   arg1 = (Dali::Rect< int > *)jarg1;
11067   if (!arg1) {
11068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
11069     return 0;
11070   }
11071   {
11072     try {
11073       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
11074     } CALL_CATCH_EXCEPTION(0);
11075   }
11076
11077   jresult = (void *)result;
11078   return jresult;
11079 }
11080
11081
11082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
11083   void * jresult ;
11084   Dali::AngleAxis *arg1 = 0 ;
11085   Dali::Property::Value *result = 0 ;
11086
11087   arg1 = (Dali::AngleAxis *)jarg1;
11088   if (!arg1) {
11089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
11090     return 0;
11091   }
11092   {
11093     try {
11094       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
11095     } CALL_CATCH_EXCEPTION(0);
11096   }
11097
11098   jresult = (void *)result;
11099   return jresult;
11100 }
11101
11102
11103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
11104   void * jresult ;
11105   Dali::Quaternion *arg1 = 0 ;
11106   Dali::Property::Value *result = 0 ;
11107
11108   arg1 = (Dali::Quaternion *)jarg1;
11109   if (!arg1) {
11110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11111     return 0;
11112   }
11113   {
11114     try {
11115       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
11116     } CALL_CATCH_EXCEPTION(0);
11117   }
11118
11119   jresult = (void *)result;
11120   return jresult;
11121 }
11122
11123
11124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
11125   void * jresult ;
11126   std::string *arg1 = 0 ;
11127   Dali::Property::Value *result = 0 ;
11128
11129   if (!jarg1) {
11130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11131     return 0;
11132   }
11133   std::string arg1_str(jarg1);
11134   arg1 = &arg1_str;
11135   {
11136     try {
11137       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
11138     } CALL_CATCH_EXCEPTION(0);
11139   }
11140
11141   jresult = (void *)result;
11142
11143   //argout typemap for const std::string&
11144
11145   return jresult;
11146 }
11147
11148
11149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
11150   void * jresult ;
11151   Dali::Property::Array *arg1 = 0 ;
11152   Dali::Property::Value *result = 0 ;
11153
11154   arg1 = (Dali::Property::Array *)jarg1;
11155   if (!arg1) {
11156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
11157     return 0;
11158   }
11159   {
11160     try {
11161       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
11162     } CALL_CATCH_EXCEPTION(0);
11163   }
11164
11165   jresult = (void *)result;
11166   return jresult;
11167 }
11168
11169
11170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
11171   void * jresult ;
11172   Dali::Property::Map *arg1 = 0 ;
11173   Dali::Property::Value *result = 0 ;
11174
11175   arg1 = (Dali::Property::Map *)jarg1;
11176   if (!arg1) {
11177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
11178     return 0;
11179   }
11180   {
11181     try {
11182       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
11183     } CALL_CATCH_EXCEPTION(0);
11184   }
11185
11186   jresult = (void *)result;
11187   return jresult;
11188 }
11189
11190
11191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
11192   void * jresult ;
11193   Extents *arg1 = 0 ;
11194   Dali::Property::Value *result = 0 ;
11195
11196   arg1 = (Extents *)jarg1;
11197   if (!arg1) {
11198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
11199     return 0;
11200   }
11201   {
11202     try {
11203       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
11204     } CALL_CATCH_EXCEPTION(0);
11205   }
11206
11207   jresult = (void*) result;
11208   return jresult;
11209 }
11210
11211
11212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
11213   void * jresult ;
11214   Dali::Property::Type arg1 ;
11215   Dali::Property::Value *result = 0 ;
11216
11217   arg1 = (Dali::Property::Type)jarg1;
11218   {
11219     try {
11220       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
11221     } CALL_CATCH_EXCEPTION(0);
11222   }
11223
11224   jresult = (void *)result;
11225   return jresult;
11226 }
11227
11228
11229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
11230   void * jresult ;
11231   Dali::Property::Value *arg1 = 0 ;
11232   Dali::Property::Value *result = 0 ;
11233
11234   arg1 = (Dali::Property::Value *)jarg1;
11235   if (!arg1) {
11236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
11237     return 0;
11238   }
11239   {
11240     try {
11241       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
11242     } CALL_CATCH_EXCEPTION(0);
11243   }
11244
11245   jresult = (void *)result;
11246   return jresult;
11247 }
11248
11249
11250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
11251   void * jresult ;
11252   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11253   Dali::Property::Value *arg2 = 0 ;
11254   Dali::Property::Value *result = 0 ;
11255
11256   arg1 = (Dali::Property::Value *)jarg1;
11257   arg2 = (Dali::Property::Value *)jarg2;
11258   if (!arg2) {
11259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
11260     return 0;
11261   }
11262   {
11263     try {
11264       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
11265     } CALL_CATCH_EXCEPTION(0);
11266   }
11267
11268   jresult = (void *)result;
11269   return jresult;
11270 }
11271
11272
11273 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_EqualTo(void * jarg1, void * jarg2) {
11274   bool jresult;
11275   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11276   Dali::Property::Value *arg2 = 0 ;
11277   bool result;
11278
11279   arg1 = (Dali::Property::Value *)jarg1;
11280   arg2 = (Dali::Property::Value *)jarg2;
11281   if (!arg2) {
11282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
11283     return 0;
11284   }
11285   {
11286     try {
11287       result = (bool)((Dali::Property::Value const *)arg1)->operator ==((Dali::Property::Value const &)*arg2);
11288     } CALL_CATCH_EXCEPTION(0);
11289   }
11290
11291   jresult = result;
11292   return jresult;
11293 }
11294
11295 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_NotEqualTo(void * jarg1, void * jarg2) {
11296   bool jresult;
11297   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11298   Dali::Property::Value *arg2 = 0 ;
11299   bool result;
11300
11301   arg1 = (Dali::Property::Value *)jarg1;
11302   arg2 = (Dali::Property::Value *)jarg2;
11303   if (!arg2) {
11304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
11305     return 0;
11306   }
11307   {
11308     try {
11309       result = (bool)((Dali::Property::Value const *)arg1)->operator !=((Dali::Property::Value const &)*arg2);
11310     } CALL_CATCH_EXCEPTION(0);
11311   }
11312
11313   jresult = result;
11314   return jresult;
11315 }
11316
11317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
11318   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11319
11320   arg1 = (Dali::Property::Value *)jarg1;
11321   {
11322     try {
11323       delete arg1;
11324     } CALL_CATCH_EXCEPTION();
11325   }
11326
11327 }
11328
11329
11330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
11331   int jresult ;
11332   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11333   Dali::Property::Type result;
11334
11335   arg1 = (Dali::Property::Value *)jarg1;
11336   {
11337     try {
11338       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
11339     } CALL_CATCH_EXCEPTION(0);
11340   }
11341
11342   jresult = (int)result;
11343   return jresult;
11344 }
11345
11346
11347 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, bool * jarg2) {
11348   bool jresult ;
11349   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11350   bool *arg2 = 0 ;
11351   bool result;
11352
11353   arg1 = (Dali::Property::Value *)jarg1;
11354   arg2 = (bool *)jarg2;
11355   {
11356     try {
11357       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11358     } CALL_CATCH_EXCEPTION(0);
11359   }
11360
11361   jresult = result;
11362   return jresult;
11363 }
11364
11365
11366 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
11367   bool jresult ;
11368   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11369   float *arg2 = 0 ;
11370   bool result;
11371
11372   arg1 = (Dali::Property::Value *)jarg1;
11373   arg2 = (float *)jarg2;
11374   {
11375     try {
11376       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11377     } CALL_CATCH_EXCEPTION(0);
11378   }
11379
11380   jresult = result;
11381   return jresult;
11382 }
11383
11384
11385 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
11386   bool jresult ;
11387   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11388   int *arg2 = 0 ;
11389   bool result;
11390
11391   arg1 = (Dali::Property::Value *)jarg1;
11392   arg2 = (int *)jarg2;
11393   {
11394     try {
11395       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11396     } CALL_CATCH_EXCEPTION(0);
11397   }
11398
11399   jresult = result;
11400   return jresult;
11401 }
11402
11403
11404 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
11405   bool jresult ;
11406   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11407   Dali::Rect< int > *arg2 = 0 ;
11408   bool result;
11409
11410   arg1 = (Dali::Property::Value *)jarg1;
11411   arg2 = (Dali::Rect< int > *)jarg2;
11412   if (!arg2) {
11413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
11414     return 0;
11415   }
11416   {
11417     try {
11418       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11419     } CALL_CATCH_EXCEPTION(0);
11420   }
11421
11422   jresult = result;
11423   return jresult;
11424 }
11425
11426
11427 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
11428   bool jresult ;
11429   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11430   Dali::Vector2 *arg2 = 0 ;
11431   bool result;
11432
11433   arg1 = (Dali::Property::Value *)jarg1;
11434   arg2 = (Dali::Vector2 *)jarg2;
11435   if (!arg2) {
11436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
11437     return 0;
11438   }
11439   {
11440     try {
11441       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11442     } CALL_CATCH_EXCEPTION(0);
11443   }
11444
11445   jresult = result;
11446   return jresult;
11447 }
11448
11449
11450 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
11451   bool jresult ;
11452   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11453   Dali::Vector3 *arg2 = 0 ;
11454   bool result;
11455
11456   arg1 = (Dali::Property::Value *)jarg1;
11457   arg2 = (Dali::Vector3 *)jarg2;
11458   if (!arg2) {
11459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11460     return 0;
11461   }
11462   {
11463     try {
11464       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11465     } CALL_CATCH_EXCEPTION(0);
11466   }
11467
11468   jresult = result;
11469   return jresult;
11470 }
11471
11472
11473 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
11474   bool jresult ;
11475   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11476   Dali::Vector4 *arg2 = 0 ;
11477   bool result;
11478
11479   arg1 = (Dali::Property::Value *)jarg1;
11480   arg2 = (Dali::Vector4 *)jarg2;
11481   if (!arg2) {
11482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
11483     return 0;
11484   }
11485   {
11486     try {
11487       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11488     } CALL_CATCH_EXCEPTION(0);
11489   }
11490
11491   jresult = result;
11492   return jresult;
11493 }
11494
11495
11496 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
11497   bool jresult ;
11498   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11499   Dali::Matrix3 *arg2 = 0 ;
11500   bool result;
11501
11502   arg1 = (Dali::Property::Value *)jarg1;
11503   arg2 = (Dali::Matrix3 *)jarg2;
11504   if (!arg2) {
11505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
11506     return 0;
11507   }
11508   {
11509     try {
11510       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11511     } CALL_CATCH_EXCEPTION(0);
11512   }
11513
11514   jresult = result;
11515   return jresult;
11516 }
11517
11518
11519 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
11520   bool jresult ;
11521   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11522   Dali::Matrix *arg2 = 0 ;
11523   bool result;
11524
11525   arg1 = (Dali::Property::Value *)jarg1;
11526   arg2 = (Dali::Matrix *)jarg2;
11527   if (!arg2) {
11528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11529     return 0;
11530   }
11531   {
11532     try {
11533       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11534     } CALL_CATCH_EXCEPTION(0);
11535   }
11536
11537   jresult = result;
11538   return jresult;
11539 }
11540
11541
11542 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
11543   bool jresult ;
11544   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11545   Dali::AngleAxis *arg2 = 0 ;
11546   bool result;
11547
11548   arg1 = (Dali::Property::Value *)jarg1;
11549   arg2 = (Dali::AngleAxis *)jarg2;
11550   if (!arg2) {
11551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
11552     return 0;
11553   }
11554   {
11555     try {
11556       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11557     } CALL_CATCH_EXCEPTION(0);
11558   }
11559
11560   jresult = result;
11561   return jresult;
11562 }
11563
11564
11565 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
11566   bool jresult ;
11567   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11568   Dali::Quaternion *arg2 = 0 ;
11569   bool result;
11570
11571   arg1 = (Dali::Property::Value *)jarg1;
11572   arg2 = (Dali::Quaternion *)jarg2;
11573   if (!arg2) {
11574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11575     return 0;
11576   }
11577   {
11578     try {
11579       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11580     } CALL_CATCH_EXCEPTION(0);
11581   }
11582
11583   jresult = result;
11584   return jresult;
11585 }
11586
11587
11588 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
11589   bool jresult ;
11590   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11591   std::string *arg2 = 0 ;
11592   bool result;
11593
11594   arg1 = (Dali::Property::Value *)jarg1;
11595
11596   //typemap in
11597   std::string temp;
11598   arg2 = &temp;
11599
11600   {
11601     try {
11602       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11603     } CALL_CATCH_EXCEPTION(0);
11604   }
11605
11606   jresult = result;
11607
11608   //Typemap argout in c++ file.
11609   //This will convert c++ string to c# string
11610   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
11611
11612   return jresult;
11613 }
11614
11615
11616 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
11617   bool jresult ;
11618   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11619   Dali::Property::Array *arg2 = 0 ;
11620   bool result;
11621
11622   arg1 = (Dali::Property::Value *)jarg1;
11623   arg2 = (Dali::Property::Array *)jarg2;
11624   if (!arg2) {
11625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
11626     return 0;
11627   }
11628   {
11629     try {
11630       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11631     } CALL_CATCH_EXCEPTION(0);
11632   }
11633
11634   jresult = result;
11635   return jresult;
11636 }
11637
11638
11639 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
11640   bool jresult ;
11641   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11642   Dali::Property::Map *arg2 = 0 ;
11643   bool result;
11644
11645   arg1 = (Dali::Property::Value *)jarg1;
11646   arg2 = (Dali::Property::Map *)jarg2;
11647   if (!arg2) {
11648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
11649     return 0;
11650   }
11651   {
11652     try {
11653       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11654     } CALL_CATCH_EXCEPTION(0);
11655   }
11656
11657   jresult = result;
11658   return jresult;
11659 }
11660
11661
11662 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
11663   bool jresult ;
11664   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11665   Extents *arg2 = 0 ;
11666   bool result;
11667
11668   arg1 = (Dali::Property::Value *)jarg1;
11669   arg2 = (Extents *)jarg2;
11670   if (!arg2) {
11671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
11672     return 0;
11673   }
11674   {
11675     try {
11676       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11677     } CALL_CATCH_EXCEPTION(0);
11678   }
11679   jresult = result;
11680   return jresult;
11681 }
11682
11683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
11684   void * jresult ;
11685   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11686   Dali::Property::Array *result = 0 ;
11687
11688   arg1 = (Dali::Property::Value *)jarg1;
11689   {
11690     try {
11691       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
11692     } CALL_CATCH_EXCEPTION(0);
11693   }
11694
11695   jresult = (void *)result;
11696   return jresult;
11697 }
11698
11699
11700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
11701   void * jresult ;
11702   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11703   Dali::Property::Map *result = 0 ;
11704
11705   arg1 = (Dali::Property::Value *)jarg1;
11706   {
11707     try {
11708       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
11709     } CALL_CATCH_EXCEPTION(0);
11710   }
11711
11712   jresult = (void *)result;
11713   return jresult;
11714 }
11715
11716
11717 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
11718   char * jresult ;
11719   Dali::Property::Type arg1 ;
11720   char *result = 0 ;
11721
11722   arg1 = (Dali::Property::Type)jarg1;
11723   {
11724     try {
11725       result = (char *)Dali::PropertyTypes::GetName(arg1);
11726     } CALL_CATCH_EXCEPTION(0);
11727   }
11728
11729   jresult = SWIG_csharp_string_callback((const char *)result);
11730   return jresult;
11731 }
11732
11733
11734 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
11735   bool jresult ;
11736   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11737   std::string *arg2 = 0 ;
11738   Dali::Property::Map *arg3 = 0 ;
11739   bool result;
11740
11741   arg1 = (Dali::BaseObject *)jarg1;
11742   if (!jarg2) {
11743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11744     return 0;
11745   }
11746   std::string arg2_str(jarg2);
11747   arg2 = &arg2_str;
11748   arg3 = (Dali::Property::Map *)jarg3;
11749   if (!arg3) {
11750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
11751     return 0;
11752   }
11753   {
11754     try {
11755       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
11756     } CALL_CATCH_EXCEPTION(0);
11757   }
11758
11759   jresult = result;
11760
11761   //argout typemap for const std::string&
11762
11763   return jresult;
11764 }
11765
11766
11767 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
11768   char * jresult ;
11769   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11770   std::string *result = 0 ;
11771
11772   arg1 = (Dali::BaseObject *)jarg1;
11773   {
11774     try {
11775       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
11776     } CALL_CATCH_EXCEPTION(0);
11777   }
11778
11779   jresult = SWIG_csharp_string_callback(result->c_str());
11780   return jresult;
11781 }
11782
11783
11784 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
11785   bool jresult ;
11786   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11787   Dali::TypeInfo *arg2 = 0 ;
11788   bool result;
11789
11790   arg1 = (Dali::BaseObject *)jarg1;
11791   arg2 = (Dali::TypeInfo *)jarg2;
11792   if (!arg2) {
11793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
11794     return 0;
11795   }
11796   {
11797     try {
11798       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
11799     } CALL_CATCH_EXCEPTION(0);
11800   }
11801
11802   jresult = result;
11803   return jresult;
11804 }
11805
11806
11807 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
11808   bool jresult ;
11809   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11810   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
11811   std::string *arg3 = 0 ;
11812   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
11813   bool result;
11814
11815   arg1 = (Dali::BaseObject *)jarg1;
11816   arg2 = (ConnectionTrackerInterface *)jarg2;
11817   if (!jarg3) {
11818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11819     return 0;
11820   }
11821   std::string arg3_str(jarg3);
11822   arg3 = &arg3_str;
11823   arg4 = (FunctorDelegate *)jarg4;
11824   {
11825     try {
11826       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
11827     } CALL_CATCH_EXCEPTION(0);
11828   }
11829
11830   jresult = result;
11831
11832   //argout typemap for const std::string&
11833
11834   return jresult;
11835 }
11836
11837
11838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
11839   void * jresult ;
11840   Dali::BaseHandle *arg1 = 0 ;
11841   Dali::BaseObject *result = 0 ;
11842
11843   arg1 = (Dali::BaseHandle *)jarg1;
11844   if (!arg1) {
11845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11846     return 0;
11847   }
11848   {
11849     try {
11850       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
11851     } CALL_CATCH_EXCEPTION(0);
11852   }
11853
11854   jresult = (void *)result;
11855   return jresult;
11856 }
11857
11858
11859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
11860   void * jresult ;
11861   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11862   Dali::BaseHandle *result = 0 ;
11863
11864   arg1 = (Dali::BaseObject *)jarg1;
11865   {
11866     try {
11867       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
11868     } CALL_CATCH_EXCEPTION(0);
11869   }
11870
11871   jresult = (void *)result;
11872   return jresult;
11873 }
11874
11875
11876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
11877   void * jresult ;
11878   Dali::BaseHandle *result = 0 ;
11879
11880   {
11881     try {
11882       result = (Dali::BaseHandle *)new Dali::BaseHandle();
11883     } CALL_CATCH_EXCEPTION(0);
11884   }
11885
11886   jresult = (void *)result;
11887   return jresult;
11888 }
11889
11890
11891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
11892   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11893
11894   arg1 = (Dali::BaseHandle *)jarg1;
11895   {
11896     try {
11897       delete arg1;
11898     } CALL_CATCH_EXCEPTION();
11899   }
11900
11901 }
11902
11903
11904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
11905   void * jresult ;
11906   Dali::BaseHandle *arg1 = 0 ;
11907   Dali::BaseHandle *result = 0 ;
11908
11909   arg1 = (Dali::BaseHandle *)jarg1;
11910   if (!arg1) {
11911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11912     return 0;
11913   }
11914   {
11915     try {
11916       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
11917     } CALL_CATCH_EXCEPTION(0);
11918   }
11919
11920   jresult = (void *)result;
11921   return jresult;
11922 }
11923
11924
11925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
11926   void * jresult ;
11927   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11928   Dali::BaseHandle *arg2 = 0 ;
11929   Dali::BaseHandle *result = 0 ;
11930
11931   arg1 = (Dali::BaseHandle *)jarg1;
11932   arg2 = (Dali::BaseHandle *)jarg2;
11933   if (!arg2) {
11934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11935     return 0;
11936   }
11937   {
11938     try {
11939       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
11940     } CALL_CATCH_EXCEPTION(0);
11941   }
11942
11943   jresult = (void *)result;
11944   return jresult;
11945 }
11946
11947
11948 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
11949   bool jresult ;
11950   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11951   std::string *arg2 = 0 ;
11952   Dali::Property::Map *arg3 = 0 ;
11953   bool result;
11954
11955   arg1 = (Dali::BaseHandle *)jarg1;
11956   if (!jarg2) {
11957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11958     return 0;
11959   }
11960   std::string arg2_str(jarg2);
11961   arg2 = &arg2_str;
11962   arg3 = (Dali::Property::Map *)jarg3;
11963   if (!arg3) {
11964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
11965     return 0;
11966   }
11967   {
11968     try {
11969       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
11970     } CALL_CATCH_EXCEPTION(0);
11971   }
11972
11973   jresult = result;
11974
11975   //argout typemap for const std::string&
11976
11977   return jresult;
11978 }
11979
11980
11981 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
11982   char * jresult ;
11983   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11984   std::string *result = 0 ;
11985
11986   arg1 = (Dali::BaseHandle *)jarg1;
11987   {
11988     try {
11989       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
11990     } CALL_CATCH_EXCEPTION(0);
11991   }
11992
11993   jresult = SWIG_csharp_string_callback(result->c_str());
11994   return jresult;
11995 }
11996
11997
11998 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
11999   bool jresult ;
12000   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12001   Dali::TypeInfo *arg2 = 0 ;
12002   bool result;
12003
12004   arg1 = (Dali::BaseHandle *)jarg1;
12005   arg2 = (Dali::TypeInfo *)jarg2;
12006   if (!arg2) {
12007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
12008     return 0;
12009   }
12010   {
12011     try {
12012       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
12013     } CALL_CATCH_EXCEPTION(0);
12014   }
12015
12016   jresult = result;
12017   return jresult;
12018 }
12019
12020
12021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
12022   void * jresult ;
12023   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12024   Dali::BaseObject *result = 0 ;
12025
12026   arg1 = (Dali::BaseHandle *)jarg1;
12027   {
12028     try {
12029       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
12030     } CALL_CATCH_EXCEPTION(0);
12031   }
12032
12033   jresult = (void *)result;
12034   return jresult;
12035 }
12036
12037
12038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
12039   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12040
12041   arg1 = (Dali::BaseHandle *)jarg1;
12042   {
12043     try {
12044       (arg1)->Reset();
12045     } CALL_CATCH_EXCEPTION();
12046   }
12047
12048 }
12049
12050
12051 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
12052   bool jresult ;
12053   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12054   Dali::BaseHandle *arg2 = 0 ;
12055   bool result;
12056
12057   arg1 = (Dali::BaseHandle *)jarg1;
12058   arg2 = (Dali::BaseHandle *)jarg2;
12059   if (!arg2) {
12060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
12061     return 0;
12062   }
12063   {
12064     try {
12065       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
12066     } CALL_CATCH_EXCEPTION(0);
12067   }
12068
12069   jresult = result;
12070   return jresult;
12071 }
12072
12073
12074 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
12075   bool jresult ;
12076   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12077   Dali::BaseHandle *arg2 = 0 ;
12078   bool result;
12079
12080   arg1 = (Dali::BaseHandle *)jarg1;
12081   arg2 = (Dali::BaseHandle *)jarg2;
12082   if (!arg2) {
12083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
12084     return 0;
12085   }
12086   {
12087     try {
12088       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
12089     } CALL_CATCH_EXCEPTION(0);
12090   }
12091
12092   jresult = result;
12093   return jresult;
12094 }
12095
12096
12097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
12098   void * jresult ;
12099   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12100   Dali::RefObject *result = 0 ;
12101
12102   arg1 = (Dali::BaseHandle *)jarg1;
12103   {
12104     try {
12105       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
12106     } CALL_CATCH_EXCEPTION(0);
12107   }
12108
12109   jresult = (void *)result;
12110   return jresult;
12111 }
12112
12113
12114 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
12115   bool jresult ;
12116   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12117   bool result;
12118
12119   arg1 = (Dali::BaseHandle *)jarg1;
12120   {
12121     try {
12122       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
12123     } CALL_CATCH_EXCEPTION(0);
12124   }
12125
12126   jresult = result;
12127   return jresult;
12128 }
12129
12130
12131 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
12132   bool jresult ;
12133   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12134   Dali::BaseHandle *arg2 = 0 ;
12135   bool result;
12136
12137   arg1 = (Dali::BaseHandle *)jarg1;
12138   arg2 = (Dali::BaseHandle *)jarg2;
12139   if (!arg2) {
12140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
12141     return 0;
12142   }
12143   {
12144     try {
12145       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
12146     } CALL_CATCH_EXCEPTION(0);
12147   }
12148
12149   jresult = result;
12150   return jresult;
12151 }
12152
12153
12154 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
12155   bool jresult ;
12156   Dali::BaseHandle *arg1 = 0 ;
12157   Dali::BaseHandle *arg2 = 0 ;
12158   bool result;
12159
12160   arg1 = (Dali::BaseHandle *)jarg1;
12161   if (!arg1) {
12162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
12163     return 0;
12164   }
12165   arg2 = (Dali::BaseHandle *)jarg2;
12166   if (!arg2) {
12167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
12168     return 0;
12169   }
12170   {
12171     try {
12172       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
12173     } CALL_CATCH_EXCEPTION(0);
12174   }
12175
12176   jresult = result;
12177   return jresult;
12178 }
12179
12180
12181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
12182   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
12183
12184   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
12185   {
12186     try {
12187       delete arg1;
12188     } CALL_CATCH_EXCEPTION();
12189   }
12190
12191 }
12192
12193
12194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
12195   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
12196   SlotObserver *arg2 = (SlotObserver *) 0 ;
12197   CallbackBase *arg3 = (CallbackBase *) 0 ;
12198
12199   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
12200   arg2 = (SlotObserver *)jarg2;
12201   arg3 = (CallbackBase *)jarg3;
12202   {
12203     try {
12204       (arg1)->SignalConnected(arg2,arg3);
12205     } CALL_CATCH_EXCEPTION();
12206   }
12207
12208 }
12209
12210
12211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
12212   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
12213
12214   arg1 = (Dali::SignalObserver *)jarg1;
12215   {
12216     try {
12217       delete arg1;
12218     } CALL_CATCH_EXCEPTION();
12219   }
12220
12221 }
12222
12223
12224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
12225   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
12226   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
12227   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
12228
12229   arg1 = (Dali::SignalObserver *)jarg1;
12230   arg2 = (Dali::SlotObserver *)jarg2;
12231   arg3 = (Dali::CallbackBase *)jarg3;
12232   {
12233     try {
12234       (arg1)->SignalDisconnected(arg2,arg3);
12235     } CALL_CATCH_EXCEPTION();
12236   }
12237
12238 }
12239
12240
12241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
12242   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
12243
12244   arg1 = (Dali::SlotObserver *)jarg1;
12245   {
12246     try {
12247       delete arg1;
12248     } CALL_CATCH_EXCEPTION();
12249   }
12250
12251 }
12252
12253
12254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
12255   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
12256   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
12257
12258   arg1 = (Dali::SlotObserver *)jarg1;
12259   arg2 = (Dali::CallbackBase *)jarg2;
12260   {
12261     try {
12262       (arg1)->SlotDisconnected(arg2);
12263     } CALL_CATCH_EXCEPTION();
12264   }
12265
12266 }
12267
12268
12269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
12270   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
12271
12272   arg1 = (Dali::ConnectionTracker *)jarg1;
12273   {
12274     try {
12275       delete arg1;
12276     } CALL_CATCH_EXCEPTION();
12277   }
12278
12279 }
12280
12281
12282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
12283   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
12284
12285   arg1 = (Dali::ConnectionTracker *)jarg1;
12286   {
12287     try {
12288       (arg1)->DisconnectAll();
12289     } CALL_CATCH_EXCEPTION();
12290   }
12291
12292 }
12293
12294
12295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
12296   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
12297   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
12298   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
12299
12300   arg1 = (Dali::ConnectionTracker *)jarg1;
12301   arg2 = (Dali::SlotObserver *)jarg2;
12302   arg3 = (Dali::CallbackBase *)jarg3;
12303   {
12304     try {
12305       (arg1)->SignalConnected(arg2,arg3);
12306     } CALL_CATCH_EXCEPTION();
12307   }
12308
12309 }
12310
12311
12312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
12313   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
12314   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
12315   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
12316
12317   arg1 = (Dali::ConnectionTracker *)jarg1;
12318   arg2 = (Dali::SlotObserver *)jarg2;
12319   arg3 = (Dali::CallbackBase *)jarg3;
12320   {
12321     try {
12322       (arg1)->SignalDisconnected(arg2,arg3);
12323     } CALL_CATCH_EXCEPTION();
12324   }
12325
12326 }
12327
12328
12329 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
12330   unsigned long jresult ;
12331   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
12332   std::size_t result;
12333
12334   arg1 = (Dali::ConnectionTracker *)jarg1;
12335   {
12336     try {
12337       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
12338     } CALL_CATCH_EXCEPTION(0);
12339   }
12340
12341   jresult = (unsigned long)result;
12342   return jresult;
12343 }
12344
12345
12346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
12347   void * jresult ;
12348   Dali::ObjectRegistry *result = 0 ;
12349
12350   {
12351     try {
12352       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
12353     } CALL_CATCH_EXCEPTION(0);
12354   }
12355
12356   jresult = (void *)result;
12357   return jresult;
12358 }
12359
12360
12361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
12362   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
12363
12364   arg1 = (Dali::ObjectRegistry *)jarg1;
12365   {
12366     try {
12367       delete arg1;
12368     } CALL_CATCH_EXCEPTION();
12369   }
12370
12371 }
12372
12373
12374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
12375   void * jresult ;
12376   Dali::ObjectRegistry *arg1 = 0 ;
12377   Dali::ObjectRegistry *result = 0 ;
12378
12379   arg1 = (Dali::ObjectRegistry *)jarg1;
12380   if (!arg1) {
12381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
12382     return 0;
12383   }
12384   {
12385     try {
12386       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
12387     } CALL_CATCH_EXCEPTION(0);
12388   }
12389
12390   jresult = (void *)result;
12391   return jresult;
12392 }
12393
12394
12395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
12396   void * jresult ;
12397   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
12398   Dali::ObjectRegistry *arg2 = 0 ;
12399   Dali::ObjectRegistry *result = 0 ;
12400
12401   arg1 = (Dali::ObjectRegistry *)jarg1;
12402   arg2 = (Dali::ObjectRegistry *)jarg2;
12403   if (!arg2) {
12404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
12405     return 0;
12406   }
12407   {
12408     try {
12409       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
12410     } CALL_CATCH_EXCEPTION(0);
12411   }
12412
12413   jresult = (void *)result;
12414   return jresult;
12415 }
12416
12417
12418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
12419   void * jresult ;
12420   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
12421   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
12422
12423   arg1 = (Dali::ObjectRegistry *)jarg1;
12424   {
12425     try {
12426       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
12427     } CALL_CATCH_EXCEPTION(0);
12428   }
12429
12430   jresult = (void *)result;
12431   return jresult;
12432 }
12433
12434
12435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
12436   void * jresult ;
12437   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
12438   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
12439
12440   arg1 = (Dali::ObjectRegistry *)jarg1;
12441   {
12442     try {
12443       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
12444     } CALL_CATCH_EXCEPTION(0);
12445   }
12446
12447   jresult = (void *)result;
12448   return jresult;
12449 }
12450
12451
12452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
12453   void * jresult ;
12454   Dali::PropertyCondition *result = 0 ;
12455
12456   {
12457     try {
12458       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
12459     } CALL_CATCH_EXCEPTION(0);
12460   }
12461
12462   jresult = (void *)result;
12463   return jresult;
12464 }
12465
12466
12467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
12468   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
12469
12470   arg1 = (Dali::PropertyCondition *)jarg1;
12471   {
12472     try {
12473       delete arg1;
12474     } CALL_CATCH_EXCEPTION();
12475   }
12476
12477 }
12478
12479
12480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
12481   void * jresult ;
12482   Dali::PropertyCondition *arg1 = 0 ;
12483   Dali::PropertyCondition *result = 0 ;
12484
12485   arg1 = (Dali::PropertyCondition *)jarg1;
12486   if (!arg1) {
12487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
12488     return 0;
12489   }
12490   {
12491     try {
12492       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
12493     } CALL_CATCH_EXCEPTION(0);
12494   }
12495
12496   jresult = (void *)result;
12497   return jresult;
12498 }
12499
12500
12501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
12502   void * jresult ;
12503   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
12504   Dali::PropertyCondition *arg2 = 0 ;
12505   Dali::PropertyCondition *result = 0 ;
12506
12507   arg1 = (Dali::PropertyCondition *)jarg1;
12508   arg2 = (Dali::PropertyCondition *)jarg2;
12509   if (!arg2) {
12510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
12511     return 0;
12512   }
12513   {
12514     try {
12515       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
12516     } CALL_CATCH_EXCEPTION(0);
12517   }
12518
12519   jresult = (void *)result;
12520   return jresult;
12521 }
12522
12523
12524 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
12525   unsigned long jresult ;
12526   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
12527   std::size_t result;
12528
12529   arg1 = (Dali::PropertyCondition *)jarg1;
12530   {
12531     try {
12532       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
12533     } CALL_CATCH_EXCEPTION(0);
12534   }
12535   jresult = (unsigned long)result;
12536   return jresult;
12537 }
12538
12539
12540 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
12541   float jresult ;
12542   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
12543   std::size_t arg2 ;
12544   float result;
12545
12546   arg1 = (Dali::PropertyCondition *)jarg1;
12547   arg2 = (std::size_t)jarg2;
12548   {
12549     try {
12550       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
12551     } CALL_CATCH_EXCEPTION(0);
12552   }
12553   jresult = result;
12554   return jresult;
12555 }
12556
12557
12558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
12559   void * jresult ;
12560   float arg1 ;
12561   Dali::PropertyCondition result;
12562
12563   arg1 = (float)jarg1;
12564   {
12565     try {
12566       result = Dali::LessThanCondition(arg1);
12567     } CALL_CATCH_EXCEPTION(0);
12568   }
12569
12570   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12571   return jresult;
12572 }
12573
12574
12575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
12576   void * jresult ;
12577   float arg1 ;
12578   Dali::PropertyCondition result;
12579
12580   arg1 = (float)jarg1;
12581   {
12582     try {
12583       result = Dali::GreaterThanCondition(arg1);
12584     } CALL_CATCH_EXCEPTION(0);
12585   }
12586
12587   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12588   return jresult;
12589 }
12590
12591
12592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
12593   void * jresult ;
12594   float arg1 ;
12595   float arg2 ;
12596   Dali::PropertyCondition result;
12597
12598   arg1 = (float)jarg1;
12599   arg2 = (float)jarg2;
12600   {
12601     try {
12602       result = Dali::InsideCondition(arg1,arg2);
12603     } CALL_CATCH_EXCEPTION(0);
12604   }
12605
12606   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12607   return jresult;
12608 }
12609
12610
12611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
12612   void * jresult ;
12613   float arg1 ;
12614   float arg2 ;
12615   Dali::PropertyCondition result;
12616
12617   arg1 = (float)jarg1;
12618   arg2 = (float)jarg2;
12619   {
12620     try {
12621       result = Dali::OutsideCondition(arg1,arg2);
12622     } CALL_CATCH_EXCEPTION(0);
12623   }
12624
12625   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12626   return jresult;
12627 }
12628
12629
12630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
12631   void * jresult ;
12632   float arg1 ;
12633   float arg2 ;
12634   Dali::PropertyCondition result;
12635
12636   arg1 = (float)jarg1;
12637   arg2 = (float)jarg2;
12638   {
12639     try {
12640       result = Dali::StepCondition(arg1,arg2);
12641     } CALL_CATCH_EXCEPTION(0);
12642   }
12643
12644   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12645   return jresult;
12646 }
12647
12648
12649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
12650   void * jresult ;
12651   float arg1 ;
12652   Dali::PropertyCondition result;
12653
12654   arg1 = (float)jarg1;
12655   {
12656     try {
12657       result = Dali::StepCondition(arg1);
12658     } CALL_CATCH_EXCEPTION(0);
12659   }
12660
12661   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12662   return jresult;
12663 }
12664
12665
12666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
12667   void * jresult ;
12668   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
12669   Dali::PropertyCondition result;
12670
12671   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
12672   if (!arg1) {
12673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
12674     return 0;
12675   }
12676   {
12677     try {
12678       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
12679     } CALL_CATCH_EXCEPTION(0);
12680   }
12681
12682   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12683   return jresult;
12684 }
12685
12686
12687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
12688   void * jresult ;
12689   Dali::PropertyNotification *result = 0 ;
12690
12691   {
12692     try {
12693       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
12694     } CALL_CATCH_EXCEPTION(0);
12695   }
12696
12697   jresult = (void *)result;
12698   return jresult;
12699 }
12700
12701
12702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
12703   void * jresult ;
12704   Dali::BaseHandle arg1 ;
12705   Dali::BaseHandle *argp1 ;
12706   Dali::PropertyNotification result;
12707
12708   argp1 = (Dali::BaseHandle *)jarg1;
12709   if (!argp1) {
12710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
12711     return 0;
12712   }
12713   arg1 = *argp1;
12714   {
12715     try {
12716       result = Dali::PropertyNotification::DownCast(arg1);
12717     } CALL_CATCH_EXCEPTION(0);
12718   }
12719
12720   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
12721   return jresult;
12722 }
12723
12724
12725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
12726   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12727
12728   arg1 = (Dali::PropertyNotification *)jarg1;
12729   {
12730     try {
12731       delete arg1;
12732     } CALL_CATCH_EXCEPTION();
12733   }
12734
12735 }
12736
12737
12738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
12739   void * jresult ;
12740   Dali::PropertyNotification *arg1 = 0 ;
12741   Dali::PropertyNotification *result = 0 ;
12742
12743   arg1 = (Dali::PropertyNotification *)jarg1;
12744   if (!arg1) {
12745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
12746     return 0;
12747   }
12748   {
12749     try {
12750       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
12751     } CALL_CATCH_EXCEPTION(0);
12752   }
12753
12754   jresult = (void *)result;
12755   return jresult;
12756 }
12757
12758
12759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
12760   void * jresult ;
12761   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12762   Dali::PropertyNotification *arg2 = 0 ;
12763   Dali::PropertyNotification *result = 0 ;
12764
12765   arg1 = (Dali::PropertyNotification *)jarg1;
12766   arg2 = (Dali::PropertyNotification *)jarg2;
12767   if (!arg2) {
12768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
12769     return 0;
12770   }
12771   {
12772     try {
12773       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
12774     } CALL_CATCH_EXCEPTION(0);
12775   }
12776
12777   jresult = (void *)result;
12778   return jresult;
12779 }
12780
12781
12782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
12783   void * jresult ;
12784   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12785   Dali::PropertyCondition result;
12786
12787   arg1 = (Dali::PropertyNotification *)jarg1;
12788   {
12789     try {
12790       result = (arg1)->GetCondition();
12791     } CALL_CATCH_EXCEPTION(0);
12792   }
12793
12794   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12795   return jresult;
12796 }
12797
12798
12799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
12800   void * jresult ;
12801   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12802   Dali::Handle result;
12803
12804   arg1 = (Dali::PropertyNotification *)jarg1;
12805   {
12806     try {
12807       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
12808     } CALL_CATCH_EXCEPTION(0);
12809   }
12810
12811   jresult = new Dali::Handle((const Dali::Handle &)result);
12812   return jresult;
12813 }
12814
12815
12816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
12817   int jresult ;
12818   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12819   Dali::Property::Index result;
12820
12821   arg1 = (Dali::PropertyNotification *)jarg1;
12822   {
12823     try {
12824       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
12825     } CALL_CATCH_EXCEPTION(0);
12826   }
12827
12828   jresult = result;
12829   return jresult;
12830 }
12831
12832
12833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
12834   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12835   Dali::PropertyNotification::NotifyMode arg2 ;
12836
12837   arg1 = (Dali::PropertyNotification *)jarg1;
12838   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
12839   {
12840     try {
12841       (arg1)->SetNotifyMode(arg2);
12842     } CALL_CATCH_EXCEPTION();
12843   }
12844
12845 }
12846
12847
12848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
12849   int jresult ;
12850   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12851   Dali::PropertyNotification::NotifyMode result;
12852
12853   arg1 = (Dali::PropertyNotification *)jarg1;
12854   {
12855     try {
12856       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
12857     } CALL_CATCH_EXCEPTION(0);
12858   }
12859
12860   jresult = (int)result;
12861   return jresult;
12862 }
12863
12864
12865 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
12866   bool jresult ;
12867   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12868   bool result;
12869
12870   arg1 = (Dali::PropertyNotification *)jarg1;
12871   {
12872     try {
12873       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
12874     } CALL_CATCH_EXCEPTION(0);
12875   }
12876
12877   jresult = result;
12878   return jresult;
12879 }
12880
12881
12882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
12883   void * jresult ;
12884   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12885   Dali::PropertyNotifySignalType *result = 0 ;
12886
12887   arg1 = (Dali::PropertyNotification *)jarg1;
12888   {
12889     try {
12890       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
12891     } CALL_CATCH_EXCEPTION(0);
12892   }
12893
12894   jresult = (void *)result;
12895   return jresult;
12896 }
12897
12898
12899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
12900   void * jresult ;
12901   Dali::Handle *result = 0 ;
12902
12903   {
12904     try {
12905       result = (Dali::Handle *)new Dali::Handle();
12906     } CALL_CATCH_EXCEPTION(0);
12907   }
12908
12909   jresult = (void *)result;
12910   return jresult;
12911 }
12912
12913
12914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
12915   void * jresult ;
12916   Dali::Handle result;
12917
12918   {
12919     try {
12920       result = Dali::Handle::New();
12921     } CALL_CATCH_EXCEPTION(0);
12922   }
12923
12924   jresult = new Dali::Handle((const Dali::Handle &)result);
12925   return jresult;
12926 }
12927
12928
12929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
12930   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12931
12932   arg1 = (Dali::Handle *)jarg1;
12933   {
12934     try {
12935       delete arg1;
12936     } CALL_CATCH_EXCEPTION();
12937   }
12938
12939 }
12940
12941
12942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
12943   void * jresult ;
12944   Dali::Handle *arg1 = 0 ;
12945   Dali::Handle *result = 0 ;
12946
12947   arg1 = (Dali::Handle *)jarg1;
12948   if (!arg1) {
12949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
12950     return 0;
12951   }
12952   {
12953     try {
12954       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
12955     } CALL_CATCH_EXCEPTION(0);
12956   }
12957
12958   jresult = (void *)result;
12959   return jresult;
12960 }
12961
12962
12963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
12964   void * jresult ;
12965   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12966   Dali::Handle *arg2 = 0 ;
12967   Dali::Handle *result = 0 ;
12968
12969   arg1 = (Dali::Handle *)jarg1;
12970   arg2 = (Dali::Handle *)jarg2;
12971   if (!arg2) {
12972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
12973     return 0;
12974   }
12975   {
12976     try {
12977       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
12978     } CALL_CATCH_EXCEPTION(0);
12979   }
12980
12981   jresult = (void *)result;
12982   return jresult;
12983 }
12984
12985
12986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
12987   void * jresult ;
12988   Dali::BaseHandle arg1 ;
12989   Dali::BaseHandle *argp1 ;
12990   Dali::Handle result;
12991
12992   argp1 = (Dali::BaseHandle *)jarg1;
12993   if (!argp1) {
12994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
12995     return 0;
12996   }
12997   arg1 = *argp1;
12998   {
12999     try {
13000       result = Dali::Handle::DownCast(arg1);
13001     } CALL_CATCH_EXCEPTION(0);
13002   }
13003
13004   jresult = new Dali::Handle((const Dali::Handle &)result);
13005   return jresult;
13006 }
13007
13008
13009 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
13010   bool jresult ;
13011   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13012   Dali::Handle::Capability arg2 ;
13013   bool result;
13014
13015   arg1 = (Dali::Handle *)jarg1;
13016   arg2 = (Dali::Handle::Capability)jarg2;
13017   {
13018     try {
13019       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
13020     } CALL_CATCH_EXCEPTION(0);
13021   }
13022
13023   jresult = result;
13024   return jresult;
13025 }
13026
13027
13028 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
13029   unsigned int jresult ;
13030   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13031   unsigned int result;
13032
13033   arg1 = (Dali::Handle *)jarg1;
13034   {
13035     try {
13036       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
13037     } CALL_CATCH_EXCEPTION(0);
13038   }
13039
13040   jresult = result;
13041   return jresult;
13042 }
13043
13044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_LookAt(void* csActor, void* csTarget, void* csUp, void* csLocalForward, void* csLocalUp)
13045 {
13046   Dali::Actor   actor;
13047   Dali::Vector3 target;
13048   Dali::Vector3 up           = Vector3::YAXIS;
13049   Dali::Vector3 localForward = Vector3::ZAXIS;
13050   Dali::Vector3 localUp      = Vector3::YAXIS;
13051
13052   if(!csActor)
13053   {
13054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
13055     return;
13056   }
13057
13058   if(!csTarget)
13059   {
13060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null target Dali::Vector3", 0);
13061     return;
13062   }
13063
13064   actor  = *(Dali::Actor*)csActor;
13065   target = *(Dali::Vector3*)csTarget;
13066
13067   // Use default value if csUp is null
13068   if(csUp)
13069   {
13070     up = *(Dali::Vector3*)csUp;
13071   }
13072
13073   // Use default value if csLocalForward is null
13074   if(csLocalForward)
13075   {
13076     localForward = *(Dali::Vector3*)csLocalForward;
13077   }
13078
13079   // Use default value if csLocalForward is null
13080   if(csLocalUp)
13081   {
13082     localUp = *(Dali::Vector3*)csLocalUp;
13083   }
13084
13085   {
13086     try
13087     {
13088       Dali::DevelActor::LookAt(actor, target, up, localForward, localUp);
13089     }
13090     CALL_CATCH_EXCEPTION();
13091   }
13092 }
13093
13094 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
13095   char * jresult ;
13096   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13097   Dali::Property::Index arg2 ;
13098   std::string result;
13099
13100   arg1 = (Dali::Handle *)jarg1;
13101   arg2 = (Dali::Property::Index)jarg2;
13102   {
13103     try {
13104       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
13105     } CALL_CATCH_EXCEPTION(0);
13106   }
13107
13108   jresult = SWIG_csharp_string_callback((&result)->c_str());
13109   return jresult;
13110 }
13111
13112
13113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
13114   int jresult ;
13115   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13116   std::string *arg2 = 0 ;
13117   Dali::Property::Index result;
13118
13119   arg1 = (Dali::Handle *)jarg1;
13120   if (!jarg2) {
13121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13122     return 0;
13123   }
13124   std::string arg2_str(jarg2);
13125   arg2 = &arg2_str;
13126   {
13127     try {
13128       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
13129     } CALL_CATCH_EXCEPTION(0);
13130   }
13131
13132   jresult = result;
13133
13134   //argout typemap for const std::string&
13135
13136   return jresult;
13137 }
13138
13139
13140 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
13141   bool jresult ;
13142   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13143   Dali::Property::Index arg2 ;
13144   bool result;
13145
13146   arg1 = (Dali::Handle *)jarg1;
13147   arg2 = (Dali::Property::Index)jarg2;
13148   {
13149     try {
13150       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
13151     } CALL_CATCH_EXCEPTION(0);
13152   }
13153
13154   jresult = result;
13155   return jresult;
13156 }
13157
13158
13159 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
13160   bool jresult ;
13161   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13162   Dali::Property::Index arg2 ;
13163   bool result;
13164
13165   arg1 = (Dali::Handle *)jarg1;
13166   arg2 = (Dali::Property::Index)jarg2;
13167   {
13168     try {
13169       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
13170     } CALL_CATCH_EXCEPTION(0);
13171   }
13172
13173   jresult = result;
13174   return jresult;
13175 }
13176
13177
13178 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
13179   bool jresult ;
13180   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13181   Dali::Property::Index arg2 ;
13182   bool result;
13183
13184   arg1 = (Dali::Handle *)jarg1;
13185   arg2 = (Dali::Property::Index)jarg2;
13186   {
13187     try {
13188       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
13189     } CALL_CATCH_EXCEPTION(0);
13190   }
13191
13192   jresult = result;
13193   return jresult;
13194 }
13195
13196
13197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
13198   int jresult ;
13199   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13200   Dali::Property::Index arg2 ;
13201   Dali::Property::Type result;
13202
13203   arg1 = (Dali::Handle *)jarg1;
13204   arg2 = (Dali::Property::Index)jarg2;
13205   {
13206     try {
13207       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
13208     } CALL_CATCH_EXCEPTION(0);
13209   }
13210
13211   jresult = (int)result;
13212   return jresult;
13213 }
13214
13215
13216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
13217   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13218   Dali::Property::Index arg2 ;
13219   Dali::Property::Value *arg3 = 0 ;
13220
13221   arg1 = (Dali::Handle *)jarg1;
13222   arg2 = (Dali::Property::Index)jarg2;
13223   arg3 = (Dali::Property::Value *)jarg3;
13224   if (!arg3) {
13225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13226     return ;
13227   }
13228   {
13229     try {
13230       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
13231     } CALL_CATCH_EXCEPTION();
13232   }
13233
13234 }
13235
13236
13237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
13238   int jresult ;
13239   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13240   std::string *arg2 = 0 ;
13241   Dali::Property::Value *arg3 = 0 ;
13242   Dali::Property::Index result;
13243
13244   arg1 = (Dali::Handle *)jarg1;
13245   if (!jarg2) {
13246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13247     return 0;
13248   }
13249   std::string arg2_str(jarg2);
13250   arg2 = &arg2_str;
13251   arg3 = (Dali::Property::Value *)jarg3;
13252   if (!arg3) {
13253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13254     return 0;
13255   }
13256   {
13257     try {
13258       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
13259     } CALL_CATCH_EXCEPTION(0);
13260   }
13261
13262   jresult = result;
13263
13264   //argout typemap for const std::string&
13265
13266   return jresult;
13267 }
13268
13269
13270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
13271   int jresult ;
13272   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13273   std::string *arg2 = 0 ;
13274   Dali::Property::Value *arg3 = 0 ;
13275   Dali::Property::AccessMode arg4 ;
13276   Dali::Property::Index result;
13277
13278   arg1 = (Dali::Handle *)jarg1;
13279   if (!jarg2) {
13280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13281     return 0;
13282   }
13283   std::string arg2_str(jarg2);
13284   arg2 = &arg2_str;
13285   arg3 = (Dali::Property::Value *)jarg3;
13286   if (!arg3) {
13287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13288     return 0;
13289   }
13290   arg4 = (Dali::Property::AccessMode)jarg4;
13291   {
13292     try {
13293       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
13294     } CALL_CATCH_EXCEPTION(0);
13295   }
13296
13297   jresult = result;
13298
13299   //argout typemap for const std::string&
13300
13301   return jresult;
13302 }
13303
13304
13305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
13306   void * jresult ;
13307   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13308   Dali::Property::Index arg2 ;
13309   Dali::Property::Value result;
13310
13311   arg1 = (Dali::Handle *)jarg1;
13312   arg2 = (Dali::Property::Index)jarg2;
13313   {
13314     try {
13315       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
13316     } CALL_CATCH_EXCEPTION(0);
13317   }
13318
13319   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
13320   return jresult;
13321 }
13322
13323
13324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetCurrentProperty(void * jarg1, int jarg2) {
13325   void * jresult ;
13326   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13327   Dali::Property::Index arg2 ;
13328   Dali::Property::Value result;
13329
13330   arg1 = (Dali::Handle *)jarg1;
13331   arg2 = (Dali::Property::Index)jarg2;
13332   {
13333     try {
13334       result = ((Dali::Handle const *)arg1)->GetCurrentProperty(arg2);
13335     } CALL_CATCH_EXCEPTION(0);
13336   }
13337
13338   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
13339   return jresult;
13340 }
13341
13342
13343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
13344   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13345   Dali::Property::IndexContainer *arg2 = 0 ;
13346
13347   arg1 = (Dali::Handle *)jarg1;
13348   arg2 = (Dali::Property::IndexContainer *)jarg2;
13349   if (!arg2) {
13350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
13351     return ;
13352   }
13353   {
13354     try {
13355       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
13356     } CALL_CATCH_EXCEPTION();
13357   }
13358
13359 }
13360
13361
13362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
13363   void * jresult ;
13364   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13365   Dali::Property::Index arg2 ;
13366   Dali::PropertyCondition *arg3 = 0 ;
13367   Dali::PropertyNotification result;
13368
13369   arg1 = (Dali::Handle *)jarg1;
13370   arg2 = (Dali::Property::Index)jarg2;
13371   arg3 = (Dali::PropertyCondition *)jarg3;
13372   if (!arg3) {
13373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
13374     return 0;
13375   }
13376   {
13377     try {
13378       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
13379     } CALL_CATCH_EXCEPTION(0);
13380   }
13381
13382   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
13383   return jresult;
13384 }
13385
13386
13387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
13388   void * jresult ;
13389   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13390   Dali::Property::Index arg2 ;
13391   int arg3 ;
13392   Dali::PropertyCondition *arg4 = 0 ;
13393   Dali::PropertyNotification result;
13394
13395   arg1 = (Dali::Handle *)jarg1;
13396   arg2 = (Dali::Property::Index)jarg2;
13397   arg3 = (int)jarg3;
13398   arg4 = (Dali::PropertyCondition *)jarg4;
13399   if (!arg4) {
13400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
13401     return 0;
13402   }
13403   {
13404     try {
13405       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
13406     } CALL_CATCH_EXCEPTION(0);
13407   }
13408
13409   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
13410   return jresult;
13411 }
13412
13413
13414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
13415   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13416   Dali::PropertyNotification arg2 ;
13417   Dali::PropertyNotification *argp2 ;
13418
13419   arg1 = (Dali::Handle *)jarg1;
13420   argp2 = (Dali::PropertyNotification *)jarg2;
13421   if (!argp2) {
13422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
13423     return ;
13424   }
13425   arg2 = *argp2;
13426   {
13427     try {
13428       (arg1)->RemovePropertyNotification(arg2);
13429     } CALL_CATCH_EXCEPTION();
13430   }
13431
13432 }
13433
13434
13435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
13436   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13437
13438   arg1 = (Dali::Handle *)jarg1;
13439   {
13440     try {
13441       (arg1)->RemovePropertyNotifications();
13442     } CALL_CATCH_EXCEPTION();
13443   }
13444
13445 }
13446
13447
13448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
13449   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13450
13451   arg1 = (Dali::Handle *)jarg1;
13452   {
13453     try {
13454       (arg1)->RemoveConstraints();
13455     } CALL_CATCH_EXCEPTION();
13456   }
13457
13458 }
13459
13460
13461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
13462   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13463   unsigned int arg2 ;
13464
13465   arg1 = (Dali::Handle *)jarg1;
13466   arg2 = (unsigned int)jarg2;
13467   {
13468     try {
13469       (arg1)->RemoveConstraints(arg2);
13470     } CALL_CATCH_EXCEPTION();
13471   }
13472
13473 }
13474
13475
13476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
13477   int jresult ;
13478   Dali::Property::Index result;
13479
13480   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
13481   jresult = result;
13482   return jresult;
13483 }
13484
13485
13486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
13487   void * jresult ;
13488   Dali::Handle result;
13489
13490   {
13491     try {
13492       result = Dali::WeightObject::New();
13493     } CALL_CATCH_EXCEPTION(0);
13494   }
13495
13496   jresult = new Dali::Handle((const Dali::Handle &)result);
13497   return jresult;
13498 }
13499
13500
13501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
13502   void * jresult ;
13503   Dali::TypeInfo *result = 0 ;
13504
13505   {
13506     try {
13507       result = (Dali::TypeInfo *)new Dali::TypeInfo();
13508     } CALL_CATCH_EXCEPTION(0);
13509   }
13510
13511   jresult = (void *)result;
13512   return jresult;
13513 }
13514
13515
13516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
13517   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13518
13519   arg1 = (Dali::TypeInfo *)jarg1;
13520   {
13521     try {
13522       delete arg1;
13523     } CALL_CATCH_EXCEPTION();
13524   }
13525
13526 }
13527
13528
13529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
13530   void * jresult ;
13531   Dali::TypeInfo *arg1 = 0 ;
13532   Dali::TypeInfo *result = 0 ;
13533
13534   arg1 = (Dali::TypeInfo *)jarg1;
13535   if (!arg1) {
13536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
13537     return 0;
13538   }
13539   {
13540     try {
13541       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
13542     } CALL_CATCH_EXCEPTION(0);
13543   }
13544
13545   jresult = (void *)result;
13546   return jresult;
13547 }
13548
13549
13550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
13551   void * jresult ;
13552   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13553   Dali::TypeInfo *arg2 = 0 ;
13554   Dali::TypeInfo *result = 0 ;
13555
13556   arg1 = (Dali::TypeInfo *)jarg1;
13557   arg2 = (Dali::TypeInfo *)jarg2;
13558   if (!arg2) {
13559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
13560     return 0;
13561   }
13562   {
13563     try {
13564       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
13565     } CALL_CATCH_EXCEPTION(0);
13566   }
13567
13568   jresult = (void *)result;
13569   return jresult;
13570 }
13571
13572
13573 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
13574   char * jresult ;
13575   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13576   std::string *result = 0 ;
13577
13578   arg1 = (Dali::TypeInfo *)jarg1;
13579   {
13580     try {
13581       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
13582     } CALL_CATCH_EXCEPTION(0);
13583   }
13584
13585   jresult = SWIG_csharp_string_callback(result->c_str());
13586   return jresult;
13587 }
13588
13589
13590 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
13591   char * jresult ;
13592   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13593   std::string *result = 0 ;
13594
13595   arg1 = (Dali::TypeInfo *)jarg1;
13596   {
13597     try {
13598       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
13599     } CALL_CATCH_EXCEPTION(0);
13600   }
13601
13602   jresult = SWIG_csharp_string_callback(result->c_str());
13603   return jresult;
13604 }
13605
13606
13607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
13608   void * jresult ;
13609   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13610   Dali::BaseHandle result;
13611
13612   arg1 = (Dali::TypeInfo *)jarg1;
13613   {
13614     try {
13615       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
13616     } CALL_CATCH_EXCEPTION(0);
13617   }
13618
13619   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
13620   return jresult;
13621 }
13622
13623
13624 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
13625   unsigned long jresult ;
13626   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13627   size_t result;
13628
13629   arg1 = (Dali::TypeInfo *)jarg1;
13630   {
13631     try {
13632       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
13633     } CALL_CATCH_EXCEPTION(0);
13634   }
13635
13636   jresult = (unsigned long)result;
13637   return jresult;
13638 }
13639
13640
13641 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
13642   char * jresult ;
13643   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13644   size_t arg2 ;
13645   std::string result;
13646
13647   arg1 = (Dali::TypeInfo *)jarg1;
13648   arg2 = (size_t)jarg2;
13649   {
13650     try {
13651       result = (arg1)->GetActionName(arg2);
13652     } CALL_CATCH_EXCEPTION(0);
13653   }
13654
13655   jresult = SWIG_csharp_string_callback((&result)->c_str());
13656   return jresult;
13657 }
13658
13659
13660 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
13661   unsigned long jresult ;
13662   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13663   size_t result;
13664
13665   arg1 = (Dali::TypeInfo *)jarg1;
13666   {
13667     try {
13668       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
13669     } CALL_CATCH_EXCEPTION(0);
13670   }
13671
13672   jresult = (unsigned long)result;
13673   return jresult;
13674 }
13675
13676
13677 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
13678   char * jresult ;
13679   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13680   size_t arg2 ;
13681   std::string result;
13682
13683   arg1 = (Dali::TypeInfo *)jarg1;
13684   arg2 = (size_t)jarg2;
13685   {
13686     try {
13687       result = (arg1)->GetSignalName(arg2);
13688     } CALL_CATCH_EXCEPTION(0);
13689   }
13690
13691   jresult = SWIG_csharp_string_callback((&result)->c_str());
13692   return jresult;
13693 }
13694
13695
13696 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
13697   unsigned long jresult ;
13698   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13699   size_t result;
13700
13701   arg1 = (Dali::TypeInfo *)jarg1;
13702   {
13703     try {
13704       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
13705     } CALL_CATCH_EXCEPTION(0);
13706   }
13707
13708   jresult = (unsigned long)result;
13709   return jresult;
13710 }
13711
13712
13713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
13714   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13715   Dali::Property::IndexContainer *arg2 = 0 ;
13716
13717   arg1 = (Dali::TypeInfo *)jarg1;
13718   arg2 = (Dali::Property::IndexContainer *)jarg2;
13719   if (!arg2) {
13720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
13721     return ;
13722   }
13723   {
13724     try {
13725       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
13726     } CALL_CATCH_EXCEPTION();
13727   }
13728
13729 }
13730
13731
13732 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
13733   char * jresult ;
13734   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13735   Dali::Property::Index arg2 ;
13736   std::string_view result;
13737
13738   arg1 = (Dali::TypeInfo *)jarg1;
13739   arg2 = (Dali::Property::Index)jarg2;
13740   {
13741     try {
13742       result = ((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
13743     } CALL_CATCH_EXCEPTION(0);
13744   }
13745
13746   jresult = SWIG_csharp_string_callback(result.data());
13747   return jresult;
13748 }
13749
13750
13751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
13752   void * jresult ;
13753   Dali::TypeRegistry result;
13754
13755   {
13756     try {
13757       result = Dali::TypeRegistry::Get();
13758     } CALL_CATCH_EXCEPTION(0);
13759   }
13760
13761   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
13762   return jresult;
13763 }
13764
13765
13766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
13767   void * jresult ;
13768   Dali::TypeRegistry *result = 0 ;
13769
13770   {
13771     try {
13772       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
13773     } CALL_CATCH_EXCEPTION(0);
13774   }
13775
13776   jresult = (void *)result;
13777   return jresult;
13778 }
13779
13780
13781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
13782   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13783
13784   arg1 = (Dali::TypeRegistry *)jarg1;
13785   {
13786     try {
13787       delete arg1;
13788     } CALL_CATCH_EXCEPTION();
13789   }
13790
13791 }
13792
13793
13794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
13795   void * jresult ;
13796   Dali::TypeRegistry *arg1 = 0 ;
13797   Dali::TypeRegistry *result = 0 ;
13798
13799   arg1 = (Dali::TypeRegistry *)jarg1;
13800   if (!arg1) {
13801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
13802     return 0;
13803   }
13804   {
13805     try {
13806       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
13807     } CALL_CATCH_EXCEPTION(0);
13808   }
13809
13810   jresult = (void *)result;
13811   return jresult;
13812 }
13813
13814
13815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
13816   void * jresult ;
13817   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13818   Dali::TypeRegistry *arg2 = 0 ;
13819   Dali::TypeRegistry *result = 0 ;
13820
13821   arg1 = (Dali::TypeRegistry *)jarg1;
13822   arg2 = (Dali::TypeRegistry *)jarg2;
13823   if (!arg2) {
13824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
13825     return 0;
13826   }
13827   {
13828     try {
13829       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
13830     } CALL_CATCH_EXCEPTION(0);
13831   }
13832
13833   jresult = (void *)result;
13834   return jresult;
13835 }
13836
13837
13838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
13839   void * jresult ;
13840   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13841   std::string *arg2 = 0 ;
13842   Dali::TypeInfo result;
13843
13844   arg1 = (Dali::TypeRegistry *)jarg1;
13845   if (!jarg2) {
13846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13847     return 0;
13848   }
13849   std::string arg2_str(jarg2);
13850   arg2 = &arg2_str;
13851   {
13852     try {
13853       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
13854     } CALL_CATCH_EXCEPTION(0);
13855   }
13856
13857   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
13858
13859   //argout typemap for const std::string&
13860
13861   return jresult;
13862 }
13863
13864
13865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
13866   void * jresult ;
13867   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13868   std::type_info *arg2 = 0 ;
13869   Dali::TypeInfo result;
13870
13871   arg1 = (Dali::TypeRegistry *)jarg1;
13872   arg2 = (std::type_info *)jarg2;
13873   if (!arg2) {
13874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13875     return 0;
13876   }
13877   {
13878     try {
13879       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
13880     } CALL_CATCH_EXCEPTION(0);
13881   }
13882
13883   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
13884   return jresult;
13885 }
13886
13887
13888 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
13889   unsigned long jresult ;
13890   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13891   size_t result;
13892
13893   arg1 = (Dali::TypeRegistry *)jarg1;
13894   {
13895     try {
13896       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
13897     } CALL_CATCH_EXCEPTION(0);
13898   }
13899
13900   jresult = (unsigned long)result;
13901   return jresult;
13902 }
13903
13904
13905 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
13906   char * jresult ;
13907   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13908   size_t arg2 ;
13909   std::string result;
13910
13911   arg1 = (Dali::TypeRegistry *)jarg1;
13912   arg2 = (size_t)jarg2;
13913   {
13914     try {
13915       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
13916     } CALL_CATCH_EXCEPTION(0);
13917   }
13918
13919   jresult = SWIG_csharp_string_callback((&result)->c_str());
13920   return jresult;
13921 }
13922
13923
13924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
13925   void * jresult ;
13926   std::type_info *arg1 = 0 ;
13927   std::type_info *arg2 = 0 ;
13928   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
13929   Dali::TypeRegistration *result = 0 ;
13930
13931   arg1 = (std::type_info *)jarg1;
13932   if (!arg1) {
13933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13934     return 0;
13935   }
13936   arg2 = (std::type_info *)jarg2;
13937   if (!arg2) {
13938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13939     return 0;
13940   }
13941   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
13942   {
13943     try {
13944       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
13945     } CALL_CATCH_EXCEPTION(0);
13946   }
13947
13948   jresult = (void *)result;
13949   return jresult;
13950 }
13951
13952
13953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, bool jarg4) {
13954   void * jresult ;
13955   std::type_info *arg1 = 0 ;
13956   std::type_info *arg2 = 0 ;
13957   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
13958   bool arg4 ;
13959   Dali::TypeRegistration *result = 0 ;
13960
13961   arg1 = (std::type_info *)jarg1;
13962   if (!arg1) {
13963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13964     return 0;
13965   }
13966   arg2 = (std::type_info *)jarg2;
13967   if (!arg2) {
13968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13969     return 0;
13970   }
13971   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
13972   arg4 = jarg4 ? true : false;
13973   {
13974     try {
13975       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
13976     } CALL_CATCH_EXCEPTION(0);
13977   }
13978
13979   jresult = (void *)result;
13980   return jresult;
13981 }
13982
13983
13984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
13985   void * jresult ;
13986   std::string *arg1 = 0 ;
13987   std::type_info *arg2 = 0 ;
13988   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
13989   Dali::TypeRegistration *result = 0 ;
13990
13991   if (!jarg1) {
13992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13993     return 0;
13994   }
13995   std::string arg1_str(jarg1);
13996   arg1 = &arg1_str;
13997   arg2 = (std::type_info *)jarg2;
13998   if (!arg2) {
13999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
14000     return 0;
14001   }
14002   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
14003   {
14004     try {
14005       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
14006     } CALL_CATCH_EXCEPTION(0);
14007   }
14008
14009   jresult = (void *)result;
14010
14011   //argout typemap for const std::string&
14012
14013   return jresult;
14014 }
14015
14016
14017 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
14018   char * jresult ;
14019   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
14020   std::string result;
14021
14022   arg1 = (Dali::TypeRegistration *)jarg1;
14023   {
14024     try {
14025       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
14026     } CALL_CATCH_EXCEPTION(0);
14027   }
14028
14029   jresult = SWIG_csharp_string_callback((&result)->c_str());
14030   return jresult;
14031 }
14032
14033
14034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
14035   std::string *arg1 = 0 ;
14036   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
14037
14038   if (!jarg1) {
14039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14040     return ;
14041   }
14042   std::string arg1_str(jarg1);
14043   arg1 = &arg1_str;
14044   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
14045   {
14046     try {
14047       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
14048     } CALL_CATCH_EXCEPTION();
14049   }
14050
14051
14052   //argout typemap for const std::string&
14053
14054 }
14055
14056
14057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
14058   std::string *arg1 = 0 ;
14059   std::string *arg2 = 0 ;
14060   int arg3 ;
14061   Dali::Property::Type arg4 ;
14062   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
14063   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
14064
14065   if (!jarg1) {
14066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14067     return ;
14068   }
14069   std::string arg1_str(jarg1);
14070   arg1 = &arg1_str;
14071   if (!jarg2) {
14072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14073     return ;
14074   }
14075   std::string arg2_str(jarg2);
14076   arg2 = &arg2_str;
14077   arg3 = (int)jarg3;
14078   arg4 = (Dali::Property::Type)jarg4;
14079   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
14080   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
14081   {
14082     try {
14083       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
14084     } CALL_CATCH_EXCEPTION();
14085   }
14086
14087
14088   //argout typemap for const std::string&
14089
14090
14091   //argout typemap for const std::string&
14092
14093 }
14094
14095
14096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
14097   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
14098
14099   arg1 = (Dali::TypeRegistration *)jarg1;
14100   {
14101     try {
14102       delete arg1;
14103     } CALL_CATCH_EXCEPTION();
14104   }
14105
14106 }
14107
14108
14109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
14110   void * jresult ;
14111   Dali::TypeRegistration *arg1 = 0 ;
14112   std::string *arg2 = 0 ;
14113   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
14114   Dali::SignalConnectorType *result = 0 ;
14115
14116   arg1 = (Dali::TypeRegistration *)jarg1;
14117   if (!arg1) {
14118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14119     return 0;
14120   }
14121   if (!jarg2) {
14122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14123     return 0;
14124   }
14125   std::string arg2_str(jarg2);
14126   arg2 = &arg2_str;
14127   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
14128   {
14129     try {
14130       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
14131     } CALL_CATCH_EXCEPTION(0);
14132   }
14133
14134   jresult = (void *)result;
14135
14136   //argout typemap for const std::string&
14137
14138   return jresult;
14139 }
14140
14141
14142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
14143   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
14144
14145   arg1 = (Dali::SignalConnectorType *)jarg1;
14146   {
14147     try {
14148       delete arg1;
14149     } CALL_CATCH_EXCEPTION();
14150   }
14151
14152 }
14153
14154
14155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
14156   void * jresult ;
14157   Dali::TypeRegistration *arg1 = 0 ;
14158   std::string *arg2 = 0 ;
14159   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
14160   Dali::TypeAction *result = 0 ;
14161
14162   arg1 = (Dali::TypeRegistration *)jarg1;
14163   if (!arg1) {
14164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14165     return 0;
14166   }
14167   if (!jarg2) {
14168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14169     return 0;
14170   }
14171   std::string arg2_str(jarg2);
14172   arg2 = &arg2_str;
14173   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
14174   {
14175     try {
14176       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
14177     } CALL_CATCH_EXCEPTION(0);
14178   }
14179
14180   jresult = (void *)result;
14181
14182   //argout typemap for const std::string&
14183
14184   return jresult;
14185 }
14186
14187
14188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
14189   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
14190
14191   arg1 = (Dali::TypeAction *)jarg1;
14192   {
14193     try {
14194       delete arg1;
14195     } CALL_CATCH_EXCEPTION();
14196   }
14197
14198 }
14199
14200
14201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
14202   void * jresult ;
14203   Dali::TypeRegistration *arg1 = 0 ;
14204   std::string *arg2 = 0 ;
14205   Dali::Property::Index arg3 ;
14206   Dali::Property::Type arg4 ;
14207   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
14208   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
14209   Dali::PropertyRegistration *result = 0 ;
14210
14211   arg1 = (Dali::TypeRegistration *)jarg1;
14212   if (!arg1) {
14213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14214     return 0;
14215   }
14216   if (!jarg2) {
14217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14218     return 0;
14219   }
14220   std::string arg2_str(jarg2);
14221   arg2 = &arg2_str;
14222   arg3 = (Dali::Property::Index)jarg3;
14223   arg4 = (Dali::Property::Type)jarg4;
14224   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
14225   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
14226   {
14227     try {
14228       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
14229     } CALL_CATCH_EXCEPTION(0);
14230   }
14231
14232   jresult = (void *)result;
14233
14234   //argout typemap for const std::string&
14235
14236   return jresult;
14237 }
14238
14239
14240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
14241   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
14242
14243   arg1 = (Dali::PropertyRegistration *)jarg1;
14244   {
14245     try {
14246       delete arg1;
14247     } CALL_CATCH_EXCEPTION();
14248   }
14249
14250 }
14251
14252
14253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
14254   void * jresult ;
14255   Dali::TypeRegistration *arg1 = 0 ;
14256   std::string *arg2 = 0 ;
14257   Dali::Property::Index arg3 ;
14258   Dali::Property::Type arg4 ;
14259   Dali::AnimatablePropertyRegistration *result = 0 ;
14260
14261   arg1 = (Dali::TypeRegistration *)jarg1;
14262   if (!arg1) {
14263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14264     return 0;
14265   }
14266   if (!jarg2) {
14267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14268     return 0;
14269   }
14270   std::string arg2_str(jarg2);
14271   arg2 = &arg2_str;
14272   arg3 = (Dali::Property::Index)jarg3;
14273   arg4 = (Dali::Property::Type)jarg4;
14274   {
14275     try {
14276       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
14277     } CALL_CATCH_EXCEPTION(0);
14278   }
14279
14280   jresult = (void *)result;
14281
14282   //argout typemap for const std::string&
14283
14284   return jresult;
14285 }
14286
14287
14288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
14289   void * jresult ;
14290   Dali::TypeRegistration *arg1 = 0 ;
14291   std::string *arg2 = 0 ;
14292   Dali::Property::Index arg3 ;
14293   Dali::Property::Value *arg4 = 0 ;
14294   Dali::AnimatablePropertyRegistration *result = 0 ;
14295
14296   arg1 = (Dali::TypeRegistration *)jarg1;
14297   if (!arg1) {
14298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14299     return 0;
14300   }
14301   if (!jarg2) {
14302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14303     return 0;
14304   }
14305   std::string arg2_str(jarg2);
14306   arg2 = &arg2_str;
14307   arg3 = (Dali::Property::Index)jarg3;
14308   arg4 = (Dali::Property::Value *)jarg4;
14309   if (!arg4) {
14310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14311     return 0;
14312   }
14313   {
14314     try {
14315       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
14316     } CALL_CATCH_EXCEPTION(0);
14317   }
14318
14319   jresult = (void *)result;
14320
14321   //argout typemap for const std::string&
14322
14323   return jresult;
14324 }
14325
14326
14327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
14328   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
14329
14330   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
14331   {
14332     try {
14333       delete arg1;
14334     } CALL_CATCH_EXCEPTION();
14335   }
14336
14337 }
14338
14339
14340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
14341   void * jresult ;
14342   Dali::TypeRegistration *arg1 = 0 ;
14343   std::string *arg2 = 0 ;
14344   Dali::Property::Index arg3 ;
14345   Dali::Property::Index arg4 ;
14346   unsigned int arg5 ;
14347   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
14348
14349   arg1 = (Dali::TypeRegistration *)jarg1;
14350   if (!arg1) {
14351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14352     return 0;
14353   }
14354   if (!jarg2) {
14355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14356     return 0;
14357   }
14358   std::string arg2_str(jarg2);
14359   arg2 = &arg2_str;
14360   arg3 = (Dali::Property::Index)jarg3;
14361   arg4 = (Dali::Property::Index)jarg4;
14362   arg5 = (unsigned int)jarg5;
14363   {
14364     try {
14365       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
14366     } CALL_CATCH_EXCEPTION(0);
14367   }
14368
14369   jresult = (void *)result;
14370
14371   //argout typemap for const std::string&
14372
14373   return jresult;
14374 }
14375
14376
14377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
14378   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
14379
14380   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
14381   {
14382     try {
14383       delete arg1;
14384     } CALL_CATCH_EXCEPTION();
14385   }
14386
14387 }
14388
14389
14390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
14391   void * jresult ;
14392   Dali::TypeRegistration *arg1 = 0 ;
14393   std::string *arg2 = 0 ;
14394   Dali::Property::Index arg3 ;
14395   Dali::Property::Type arg4 ;
14396   Dali::ChildPropertyRegistration *result = 0 ;
14397
14398   arg1 = (Dali::TypeRegistration *)jarg1;
14399   if (!arg1) {
14400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14401     return 0;
14402   }
14403   if (!jarg2) {
14404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14405     return 0;
14406   }
14407   std::string arg2_str(jarg2);
14408   arg2 = &arg2_str;
14409   arg3 = (Dali::Property::Index)jarg3;
14410   arg4 = (Dali::Property::Type)jarg4;
14411   {
14412     try {
14413       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
14414     } CALL_CATCH_EXCEPTION(0);
14415   }
14416
14417   jresult = (void *)result;
14418
14419   //argout typemap for const std::string&
14420
14421   return jresult;
14422 }
14423
14424
14425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
14426   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
14427
14428   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
14429   {
14430     try {
14431       delete arg1;
14432     } CALL_CATCH_EXCEPTION();
14433   }
14434
14435 }
14436
14437
14438 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
14439   bool jresult ;
14440   std::string *arg1 = 0 ;
14441   std::type_info *arg2 = 0 ;
14442   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
14443   bool result;
14444
14445   if (!jarg1) {
14446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14447     return 0;
14448   }
14449   std::string arg1_str(jarg1);
14450   arg1 = &arg1_str;
14451   arg2 = (std::type_info *)jarg2;
14452   if (!arg2) {
14453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
14454     return 0;
14455   }
14456   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
14457   {
14458     try {
14459       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
14460     } CALL_CATCH_EXCEPTION(0);
14461   }
14462
14463   jresult = result;
14464
14465   //argout typemap for const std::string&
14466
14467   return jresult;
14468 }
14469
14470
14471 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
14472   bool jresult ;
14473   std::string *arg1 = 0 ;
14474   std::string *arg2 = 0 ;
14475   Dali::Property::Index arg3 ;
14476   Dali::Property::Type arg4 ;
14477   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
14478   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
14479   bool result;
14480
14481   if (!jarg1) {
14482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14483     return 0;
14484   }
14485   std::string arg1_str(jarg1);
14486   arg1 = &arg1_str;
14487   if (!jarg2) {
14488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14489     return 0;
14490   }
14491   std::string arg2_str(jarg2);
14492   arg2 = &arg2_str;
14493   arg3 = (Dali::Property::Index)jarg3;
14494   arg4 = (Dali::Property::Type)jarg4;
14495   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
14496   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
14497   {
14498     try {
14499       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
14500     } CALL_CATCH_EXCEPTION(0);
14501   }
14502
14503   jresult = result;
14504
14505   //argout typemap for const std::string&
14506
14507
14508   //argout typemap for const std::string&
14509
14510   return jresult;
14511 }
14512
14513
14514 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
14515   float jresult ;
14516   float result;
14517
14518   result = (float)(float)Dali::ParentOrigin::TOP;
14519   jresult = result;
14520   return jresult;
14521 }
14522
14523
14524 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
14525   float jresult ;
14526   float result;
14527
14528   result = (float)(float)Dali::ParentOrigin::BOTTOM;
14529   jresult = result;
14530   return jresult;
14531 }
14532
14533
14534 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
14535   float jresult ;
14536   float result;
14537
14538   result = (float)(float)Dali::ParentOrigin::LEFT;
14539   jresult = result;
14540   return jresult;
14541 }
14542
14543
14544 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
14545   float jresult ;
14546   float result;
14547
14548   result = (float)(float)Dali::ParentOrigin::RIGHT;
14549   jresult = result;
14550   return jresult;
14551 }
14552
14553
14554 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
14555   float jresult ;
14556   float result;
14557
14558   result = (float)(float)Dali::ParentOrigin::MIDDLE;
14559   jresult = result;
14560   return jresult;
14561 }
14562
14563
14564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
14565   void * jresult ;
14566   Dali::Vector3 *result = 0 ;
14567
14568   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
14569   jresult = (void *)result;
14570   return jresult;
14571 }
14572
14573
14574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
14575   void * jresult ;
14576   Dali::Vector3 *result = 0 ;
14577
14578   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
14579   jresult = (void *)result;
14580   return jresult;
14581 }
14582
14583
14584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
14585   void * jresult ;
14586   Dali::Vector3 *result = 0 ;
14587
14588   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
14589   jresult = (void *)result;
14590   return jresult;
14591 }
14592
14593
14594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
14595   void * jresult ;
14596   Dali::Vector3 *result = 0 ;
14597
14598   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
14599   jresult = (void *)result;
14600   return jresult;
14601 }
14602
14603
14604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
14605   void * jresult ;
14606   Dali::Vector3 *result = 0 ;
14607
14608   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
14609   jresult = (void *)result;
14610   return jresult;
14611 }
14612
14613
14614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
14615   void * jresult ;
14616   Dali::Vector3 *result = 0 ;
14617
14618   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
14619   jresult = (void *)result;
14620   return jresult;
14621 }
14622
14623
14624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
14625   void * jresult ;
14626   Dali::Vector3 *result = 0 ;
14627
14628   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
14629   jresult = (void *)result;
14630   return jresult;
14631 }
14632
14633
14634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
14635   void * jresult ;
14636   Dali::Vector3 *result = 0 ;
14637
14638   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
14639   jresult = (void *)result;
14640   return jresult;
14641 }
14642
14643
14644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
14645   void * jresult ;
14646   Dali::Vector3 *result = 0 ;
14647
14648   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
14649   jresult = (void *)result;
14650   return jresult;
14651 }
14652
14653
14654 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
14655   float jresult ;
14656   float result;
14657
14658   result = (float)(float)Dali::AnchorPoint::TOP;
14659   jresult = result;
14660   return jresult;
14661 }
14662
14663
14664 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
14665   float jresult ;
14666   float result;
14667
14668   result = (float)(float)Dali::AnchorPoint::BOTTOM;
14669   jresult = result;
14670   return jresult;
14671 }
14672
14673
14674 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
14675   float jresult ;
14676   float result;
14677
14678   result = (float)(float)Dali::AnchorPoint::LEFT;
14679   jresult = result;
14680   return jresult;
14681 }
14682
14683
14684 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
14685   float jresult ;
14686   float result;
14687
14688   result = (float)(float)Dali::AnchorPoint::RIGHT;
14689   jresult = result;
14690   return jresult;
14691 }
14692
14693
14694 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
14695   float jresult ;
14696   float result;
14697
14698   result = (float)(float)Dali::AnchorPoint::MIDDLE;
14699   jresult = result;
14700   return jresult;
14701 }
14702
14703
14704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
14705   void * jresult ;
14706   Dali::Vector3 *result = 0 ;
14707
14708   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
14709   jresult = (void *)result;
14710   return jresult;
14711 }
14712
14713
14714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
14715   void * jresult ;
14716   Dali::Vector3 *result = 0 ;
14717
14718   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
14719   jresult = (void *)result;
14720   return jresult;
14721 }
14722
14723
14724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
14725   void * jresult ;
14726   Dali::Vector3 *result = 0 ;
14727
14728   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
14729   jresult = (void *)result;
14730   return jresult;
14731 }
14732
14733
14734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
14735   void * jresult ;
14736   Dali::Vector3 *result = 0 ;
14737
14738   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
14739   jresult = (void *)result;
14740   return jresult;
14741 }
14742
14743
14744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
14745   void * jresult ;
14746   Dali::Vector3 *result = 0 ;
14747
14748   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
14749   jresult = (void *)result;
14750   return jresult;
14751 }
14752
14753
14754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
14755   void * jresult ;
14756   Dali::Vector3 *result = 0 ;
14757
14758   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
14759   jresult = (void *)result;
14760   return jresult;
14761 }
14762
14763
14764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
14765   void * jresult ;
14766   Dali::Vector3 *result = 0 ;
14767
14768   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
14769   jresult = (void *)result;
14770   return jresult;
14771 }
14772
14773
14774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
14775   void * jresult ;
14776   Dali::Vector3 *result = 0 ;
14777
14778   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
14779   jresult = (void *)result;
14780   return jresult;
14781 }
14782
14783
14784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
14785   void * jresult ;
14786   Dali::Vector3 *result = 0 ;
14787
14788   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
14789   jresult = (void *)result;
14790   return jresult;
14791 }
14792
14793
14794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ALICE_BLUE_get() {
14795   void * jresult;
14796   Dali::Vector4 *result = 0 ;
14797
14798   result = (Dali::Vector4 *)&Dali::Color::ALICE_BLUE;
14799   jresult = (void *)result;
14800   return jresult;
14801 }
14802
14803
14804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANTIQUE_WHITE_get() {
14805   void * jresult;
14806   Dali::Vector4 *result = 0 ;
14807
14808   result = (Dali::Vector4 *)&Dali::Color::ANTIQUE_WHITE;
14809   jresult = (void *)result;
14810   return jresult;
14811 }
14812
14813
14814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AQUA_get() {
14815   void * jresult;
14816   Dali::Vector4 *result = 0 ;
14817
14818   result = (Dali::Vector4 *)&Dali::Color::AQUA;
14819   jresult = (void *)result;
14820   return jresult;
14821 }
14822
14823
14824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AQUA_MARINE_get() {
14825   void * jresult;
14826   Dali::Vector4 *result = 0 ;
14827
14828   result = (Dali::Vector4 *)&Dali::Color::AQUA_MARINE;
14829   jresult = (void *)result;
14830   return jresult;
14831 }
14832
14833
14834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AZURE_get() {
14835   void * jresult;
14836   Dali::Vector4 *result = 0 ;
14837
14838   result = (Dali::Vector4 *)&Dali::Color::AZURE;
14839   jresult = (void *)result;
14840   return jresult;
14841 }
14842
14843
14844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BEIGE_get() {
14845   void * jresult;
14846   Dali::Vector4 *result = 0 ;
14847
14848   result = (Dali::Vector4 *)&Dali::Color::BEIGE;
14849   jresult = (void *)result;
14850   return jresult;
14851 }
14852
14853
14854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BISQUE_get() {
14855   void * jresult;
14856   Dali::Vector4 *result = 0 ;
14857
14858   result = (Dali::Vector4 *)&Dali::Color::BISQUE;
14859   jresult = (void *)result;
14860   return jresult;
14861 }
14862
14863
14864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
14865   void * jresult;
14866   Dali::Vector4 *result = 0 ;
14867
14868   result = (Dali::Vector4 *)&Dali::Color::BLACK;
14869   jresult = (void *)result;
14870   return jresult;
14871 }
14872
14873
14874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLANCHE_DALMOND_get() {
14875   void * jresult;
14876   Dali::Vector4 *result = 0 ;
14877
14878   result = (Dali::Vector4 *)&Dali::Color::BLANCHE_DALMOND;
14879   jresult = (void *)result;
14880   return jresult;
14881 }
14882
14883
14884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
14885   void * jresult;
14886   Dali::Vector4 *result = 0 ;
14887
14888   result = (Dali::Vector4 *)&Dali::Color::BLUE;
14889   jresult = (void *)result;
14890   return jresult;
14891 }
14892
14893
14894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_VIOLET_get() {
14895   void * jresult;
14896   Dali::Vector4 *result = 0 ;
14897
14898   result = (Dali::Vector4 *)&Dali::Color::BLUE_VIOLET;
14899   jresult = (void *)result;
14900   return jresult;
14901 }
14902
14903
14904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BROWN_get() {
14905   void * jresult;
14906   Dali::Vector4 *result = 0 ;
14907
14908   result = (Dali::Vector4 *)&Dali::Color::BROWN;
14909   jresult = (void *)result;
14910   return jresult;
14911 }
14912
14913
14914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BURLY_WOOD_get() {
14915   void * jresult;
14916   Dali::Vector4 *result = 0 ;
14917
14918   result = (Dali::Vector4 *)&Dali::Color::BURLY_WOOD;
14919   jresult = (void *)result;
14920   return jresult;
14921 }
14922
14923
14924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CADET_BLUE_get() {
14925   void * jresult;
14926   Dali::Vector4 *result = 0 ;
14927
14928   result = (Dali::Vector4 *)&Dali::Color::CADET_BLUE;
14929   jresult = (void *)result;
14930   return jresult;
14931 }
14932
14933
14934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CHARTREUSE_get() {
14935   void * jresult;
14936   Dali::Vector4 *result = 0 ;
14937
14938   result = (Dali::Vector4 *)&Dali::Color::CHARTREUSE;
14939   jresult = (void *)result;
14940   return jresult;
14941 }
14942
14943
14944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CHOCOLATE_get() {
14945   void * jresult;
14946   Dali::Vector4 *result = 0 ;
14947
14948   result = (Dali::Vector4 *)&Dali::Color::CHOCOLATE;
14949   jresult = (void *)result;
14950   return jresult;
14951 }
14952
14953
14954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CORAL_get() {
14955   void * jresult;
14956   Dali::Vector4 *result = 0 ;
14957
14958   result = (Dali::Vector4 *)&Dali::Color::CORAL;
14959   jresult = (void *)result;
14960   return jresult;
14961 }
14962
14963
14964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CORNFLOWER_BLUE_get() {
14965   void * jresult;
14966   Dali::Vector4 *result = 0 ;
14967
14968   result = (Dali::Vector4 *)&Dali::Color::CORNFLOWER_BLUE;
14969   jresult = (void *)result;
14970   return jresult;
14971 }
14972
14973
14974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CORNSILK_get() {
14975   void * jresult;
14976   Dali::Vector4 *result = 0 ;
14977
14978   result = (Dali::Vector4 *)&Dali::Color::CORNSILK;
14979   jresult = (void *)result;
14980   return jresult;
14981 }
14982
14983
14984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CRIMSON_get() {
14985   void * jresult;
14986   Dali::Vector4 *result = 0 ;
14987
14988   result = (Dali::Vector4 *)&Dali::Color::CRIMSON;
14989   jresult = (void *)result;
14990   return jresult;
14991 }
14992
14993
14994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
14995   void * jresult;
14996   Dali::Vector4 *result = 0 ;
14997
14998   result = (Dali::Vector4 *)&Dali::Color::CYAN;
14999   jresult = (void *)result;
15000   return jresult;
15001 }
15002
15003
15004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_BLUE_get() {
15005   void * jresult;
15006   Dali::Vector4 *result = 0 ;
15007
15008   result = (Dali::Vector4 *)&Dali::Color::DARK_BLUE;
15009   jresult = (void *)result;
15010   return jresult;
15011 }
15012
15013
15014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_CYAN_get() {
15015   void * jresult;
15016   Dali::Vector4 *result = 0 ;
15017
15018   result = (Dali::Vector4 *)&Dali::Color::DARK_CYAN;
15019   jresult = (void *)result;
15020   return jresult;
15021 }
15022
15023
15024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_GOLDENROD_get() {
15025   void * jresult;
15026   Dali::Vector4 *result = 0 ;
15027
15028   result = (Dali::Vector4 *)&Dali::Color::DARK_GOLDENROD;
15029   jresult = (void *)result;
15030   return jresult;
15031 }
15032
15033
15034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_GRAY_get() {
15035   void * jresult;
15036   Dali::Vector4 *result = 0 ;
15037
15038   result = (Dali::Vector4 *)&Dali::Color::DARK_GRAY;
15039   jresult = (void *)result;
15040   return jresult;
15041 }
15042
15043
15044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_GREEN_get() {
15045   void * jresult;
15046   Dali::Vector4 *result = 0 ;
15047
15048   result = (Dali::Vector4 *)&Dali::Color::DARK_GREEN;
15049   jresult = (void *)result;
15050   return jresult;
15051 }
15052
15053
15054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_GREY_get() {
15055   void * jresult;
15056   Dali::Vector4 *result = 0 ;
15057
15058   result = (Dali::Vector4 *)&Dali::Color::DARK_GREY;
15059   jresult = (void *)result;
15060   return jresult;
15061 }
15062
15063
15064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_KHAKI_get() {
15065   void * jresult;
15066   Dali::Vector4 *result = 0 ;
15067
15068   result = (Dali::Vector4 *)&Dali::Color::DARK_KHAKI;
15069   jresult = (void *)result;
15070   return jresult;
15071 }
15072
15073
15074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_MAGENTA_get() {
15075   void * jresult;
15076   Dali::Vector4 *result = 0 ;
15077
15078   result = (Dali::Vector4 *)&Dali::Color::DARK_MAGENTA;
15079   jresult = (void *)result;
15080   return jresult;
15081 }
15082
15083
15084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_OLIVE_GREEN_get() {
15085   void * jresult;
15086   Dali::Vector4 *result = 0 ;
15087
15088   result = (Dali::Vector4 *)&Dali::Color::DARK_OLIVE_GREEN;
15089   jresult = (void *)result;
15090   return jresult;
15091 }
15092
15093
15094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_ORANGE_get() {
15095   void * jresult;
15096   Dali::Vector4 *result = 0 ;
15097
15098   result = (Dali::Vector4 *)&Dali::Color::DARK_ORANGE;
15099   jresult = (void *)result;
15100   return jresult;
15101 }
15102
15103
15104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_ORCHID_get() {
15105   void * jresult;
15106   Dali::Vector4 *result = 0 ;
15107
15108   result = (Dali::Vector4 *)&Dali::Color::DARK_ORCHID;
15109   jresult = (void *)result;
15110   return jresult;
15111 }
15112
15113
15114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_RED_get() {
15115   void * jresult;
15116   Dali::Vector4 *result = 0 ;
15117
15118   result = (Dali::Vector4 *)&Dali::Color::DARK_RED;
15119   jresult = (void *)result;
15120   return jresult;
15121 }
15122
15123
15124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SALMON_get() {
15125   void * jresult;
15126   Dali::Vector4 *result = 0 ;
15127
15128   result = (Dali::Vector4 *)&Dali::Color::DARK_SALMON;
15129   jresult = (void *)result;
15130   return jresult;
15131 }
15132
15133
15134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SEA_GREEN_get() {
15135   void * jresult;
15136   Dali::Vector4 *result = 0 ;
15137
15138   result = (Dali::Vector4 *)&Dali::Color::DARK_SEA_GREEN;
15139   jresult = (void *)result;
15140   return jresult;
15141 }
15142
15143
15144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SLATE_BLUE_get() {
15145   void * jresult;
15146   Dali::Vector4 *result = 0 ;
15147
15148   result = (Dali::Vector4 *)&Dali::Color::DARK_SLATE_BLUE;
15149   jresult = (void *)result;
15150   return jresult;
15151 }
15152
15153
15154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SLATE_GRAY_get() {
15155   void * jresult;
15156   Dali::Vector4 *result = 0 ;
15157
15158   result = (Dali::Vector4 *)&Dali::Color::DARK_SLATE_GRAY;
15159   jresult = (void *)result;
15160   return jresult;
15161 }
15162
15163
15164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SLATE_GREY_get() {
15165   void * jresult;
15166   Dali::Vector4 *result = 0 ;
15167
15168   result = (Dali::Vector4 *)&Dali::Color::DARK_SLATE_GREY;
15169   jresult = (void *)result;
15170   return jresult;
15171 }
15172
15173
15174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_TURQUOISE_get() {
15175   void * jresult;
15176   Dali::Vector4 *result = 0 ;
15177
15178   result = (Dali::Vector4 *)&Dali::Color::DARK_TURQUOISE;
15179   jresult = (void *)result;
15180   return jresult;
15181 }
15182
15183
15184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_VIOLET_get() {
15185   void * jresult;
15186   Dali::Vector4 *result = 0 ;
15187
15188   result = (Dali::Vector4 *)&Dali::Color::DARK_VIOLET;
15189   jresult = (void *)result;
15190   return jresult;
15191 }
15192
15193
15194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DEEP_PINK_get() {
15195   void * jresult;
15196   Dali::Vector4 *result = 0 ;
15197
15198   result = (Dali::Vector4 *)&Dali::Color::DEEP_PINK;
15199   jresult = (void *)result;
15200   return jresult;
15201 }
15202
15203
15204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DEEP_SKY_BLUE_get() {
15205   void * jresult;
15206   Dali::Vector4 *result = 0 ;
15207
15208   result = (Dali::Vector4 *)&Dali::Color::DEEP_SKY_BLUE;
15209   jresult = (void *)result;
15210   return jresult;
15211 }
15212
15213
15214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DIM_GRAY_get() {
15215   void * jresult;
15216   Dali::Vector4 *result = 0 ;
15217
15218   result = (Dali::Vector4 *)&Dali::Color::DIM_GRAY;
15219   jresult = (void *)result;
15220   return jresult;
15221 }
15222
15223
15224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DIM_GREY_get() {
15225   void * jresult;
15226   Dali::Vector4 *result = 0 ;
15227
15228   result = (Dali::Vector4 *)&Dali::Color::DIM_GREY;
15229   jresult = (void *)result;
15230   return jresult;
15231 }
15232
15233
15234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DODGER_BLUE_get() {
15235   void * jresult;
15236   Dali::Vector4 *result = 0 ;
15237
15238   result = (Dali::Vector4 *)&Dali::Color::DODGER_BLUE;
15239   jresult = (void *)result;
15240   return jresult;
15241 }
15242
15243
15244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FIRE_BRICK_get() {
15245   void * jresult;
15246   Dali::Vector4 *result = 0 ;
15247
15248   result = (Dali::Vector4 *)&Dali::Color::FIRE_BRICK;
15249   jresult = (void *)result;
15250   return jresult;
15251 }
15252
15253
15254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FLORAL_WHITE_get() {
15255   void * jresult;
15256   Dali::Vector4 *result = 0 ;
15257
15258   result = (Dali::Vector4 *)&Dali::Color::FLORAL_WHITE;
15259   jresult = (void *)result;
15260   return jresult;
15261 }
15262
15263
15264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FOREST_GREEN_get() {
15265   void * jresult;
15266   Dali::Vector4 *result = 0 ;
15267
15268   result = (Dali::Vector4 *)&Dali::Color::FOREST_GREEN;
15269   jresult = (void *)result;
15270   return jresult;
15271 }
15272
15273
15274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FUCHSIA_get() {
15275   void * jresult;
15276   Dali::Vector4 *result = 0 ;
15277
15278   result = (Dali::Vector4 *)&Dali::Color::FUCHSIA;
15279   jresult = (void *)result;
15280   return jresult;
15281 }
15282
15283
15284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GAINSBORO_get() {
15285   void * jresult;
15286   Dali::Vector4 *result = 0 ;
15287
15288   result = (Dali::Vector4 *)&Dali::Color::GAINSBORO;
15289   jresult = (void *)result;
15290   return jresult;
15291 }
15292
15293
15294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GHOST_WHITE_get() {
15295   void * jresult;
15296   Dali::Vector4 *result = 0 ;
15297
15298   result = (Dali::Vector4 *)&Dali::Color::GHOST_WHITE;
15299   jresult = (void *)result;
15300   return jresult;
15301 }
15302
15303
15304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GOLD_get() {
15305   void * jresult;
15306   Dali::Vector4 *result = 0 ;
15307
15308   result = (Dali::Vector4 *)&Dali::Color::GOLD;
15309   jresult = (void *)result;
15310   return jresult;
15311 }
15312
15313
15314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GOLDEN_ROD_get() {
15315   void * jresult;
15316   Dali::Vector4 *result = 0 ;
15317
15318   result = (Dali::Vector4 *)&Dali::Color::GOLDEN_ROD;
15319   jresult = (void *)result;
15320   return jresult;
15321 }
15322
15323
15324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GRAY_get() {
15325   void * jresult;
15326   Dali::Vector4 *result = 0 ;
15327
15328   result = (Dali::Vector4 *)&Dali::Color::GRAY;
15329   jresult = (void *)result;
15330   return jresult;
15331 }
15332
15333
15334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
15335   void * jresult;
15336   Dali::Vector4 *result = 0 ;
15337
15338   result = (Dali::Vector4 *)&Dali::Color::GREEN;
15339   jresult = (void *)result;
15340   return jresult;
15341 }
15342
15343
15344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_YELLOW_get() {
15345   void * jresult;
15346   Dali::Vector4 *result = 0 ;
15347
15348   result = (Dali::Vector4 *)&Dali::Color::GREEN_YELLOW;
15349   jresult = (void *)result;
15350   return jresult;
15351 }
15352
15353
15354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREY_get() {
15355   void * jresult;
15356   Dali::Vector4 *result = 0 ;
15357
15358   result = (Dali::Vector4 *)&Dali::Color::GREY;
15359   jresult = (void *)result;
15360   return jresult;
15361 }
15362
15363
15364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_HONEYDEW_get() {
15365   void * jresult;
15366   Dali::Vector4 *result = 0 ;
15367
15368   result = (Dali::Vector4 *)&Dali::Color::HONEYDEW;
15369   jresult = (void *)result;
15370   return jresult;
15371 }
15372
15373
15374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_HOT_PINK_get() {
15375   void * jresult;
15376   Dali::Vector4 *result = 0 ;
15377
15378   result = (Dali::Vector4 *)&Dali::Color::HOT_PINK;
15379   jresult = (void *)result;
15380   return jresult;
15381 }
15382
15383
15384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_INDIANRED_get() {
15385   void * jresult;
15386   Dali::Vector4 *result = 0 ;
15387
15388   result = (Dali::Vector4 *)&Dali::Color::INDIANRED;
15389   jresult = (void *)result;
15390   return jresult;
15391 }
15392
15393
15394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_INDIGO_get() {
15395   void * jresult;
15396   Dali::Vector4 *result = 0 ;
15397
15398   result = (Dali::Vector4 *)&Dali::Color::INDIGO;
15399   jresult = (void *)result;
15400   return jresult;
15401 }
15402
15403
15404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_IVORY_get() {
15405   void * jresult;
15406   Dali::Vector4 *result = 0 ;
15407
15408   result = (Dali::Vector4 *)&Dali::Color::IVORY;
15409   jresult = (void *)result;
15410   return jresult;
15411 }
15412
15413
15414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KHAKI_get() {
15415   void * jresult;
15416   Dali::Vector4 *result = 0 ;
15417
15418   result = (Dali::Vector4 *)&Dali::Color::KHAKI;
15419   jresult = (void *)result;
15420   return jresult;
15421 }
15422
15423
15424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LAVENDER_get() {
15425   void * jresult;
15426   Dali::Vector4 *result = 0 ;
15427
15428   result = (Dali::Vector4 *)&Dali::Color::LAVENDER;
15429   jresult = (void *)result;
15430   return jresult;
15431 }
15432
15433
15434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LAVENDER_BLUSH_get() {
15435   void * jresult;
15436   Dali::Vector4 *result = 0 ;
15437
15438   result = (Dali::Vector4 *)&Dali::Color::LAVENDER_BLUSH;
15439   jresult = (void *)result;
15440   return jresult;
15441 }
15442
15443
15444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LAWN_GREEN_get() {
15445   void * jresult;
15446   Dali::Vector4 *result = 0 ;
15447
15448   result = (Dali::Vector4 *)&Dali::Color::LAWN_GREEN;
15449   jresult = (void *)result;
15450   return jresult;
15451 }
15452
15453
15454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LEMON_CHIFFON_get() {
15455   void * jresult;
15456   Dali::Vector4 *result = 0 ;
15457
15458   result = (Dali::Vector4 *)&Dali::Color::LEMON_CHIFFON;
15459   jresult = (void *)result;
15460   return jresult;
15461 }
15462
15463
15464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_BLUE_get() {
15465   void * jresult;
15466   Dali::Vector4 *result = 0 ;
15467
15468   result = (Dali::Vector4 *)&Dali::Color::LIGHT_BLUE;
15469   jresult = (void *)result;
15470   return jresult;
15471 }
15472
15473
15474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_CORAL_get() {
15475   void * jresult;
15476   Dali::Vector4 *result = 0 ;
15477
15478   result = (Dali::Vector4 *)&Dali::Color::LIGHT_CORAL;
15479   jresult = (void *)result;
15480   return jresult;
15481 }
15482
15483
15484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_CYAN_get() {
15485   void * jresult;
15486   Dali::Vector4 *result = 0 ;
15487
15488   result = (Dali::Vector4 *)&Dali::Color::LIGHT_CYAN;
15489   jresult = (void *)result;
15490   return jresult;
15491 }
15492
15493
15494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_GOLDEN_ROD_YELLOW_get() {
15495   void * jresult;
15496   Dali::Vector4 *result = 0 ;
15497
15498   result = (Dali::Vector4 *)&Dali::Color::LIGHT_GOLDEN_ROD_YELLOW;
15499   jresult = (void *)result;
15500   return jresult;
15501 }
15502
15503
15504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_GRAY_get() {
15505   void * jresult;
15506   Dali::Vector4 *result = 0 ;
15507
15508   result = (Dali::Vector4 *)&Dali::Color::LIGHT_GRAY;
15509   jresult = (void *)result;
15510   return jresult;
15511 }
15512
15513
15514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_GREEN_get() {
15515   void * jresult;
15516   Dali::Vector4 *result = 0 ;
15517
15518   result = (Dali::Vector4 *)&Dali::Color::LIGHT_GREEN;
15519   jresult = (void *)result;
15520   return jresult;
15521 }
15522
15523
15524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_GREY_get() {
15525   void * jresult;
15526   Dali::Vector4 *result = 0 ;
15527
15528   result = (Dali::Vector4 *)&Dali::Color::LIGHT_GREY;
15529   jresult = (void *)result;
15530   return jresult;
15531 }
15532
15533
15534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_PINK_get() {
15535   void * jresult;
15536   Dali::Vector4 *result = 0 ;
15537
15538   result = (Dali::Vector4 *)&Dali::Color::LIGHT_PINK;
15539   jresult = (void *)result;
15540   return jresult;
15541 }
15542
15543
15544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SALMON_get() {
15545   void * jresult;
15546   Dali::Vector4 *result = 0 ;
15547
15548   result = (Dali::Vector4 *)&Dali::Color::LIGHT_SALMON;
15549   jresult = (void *)result;
15550   return jresult;
15551 }
15552
15553
15554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SEA_GREEN_get() {
15555   void * jresult;
15556   Dali::Vector4 *result = 0 ;
15557
15558   result = (Dali::Vector4 *)&Dali::Color::LIGHT_SEA_GREEN;
15559   jresult = (void *)result;
15560   return jresult;
15561 }
15562
15563
15564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SKY_BLUE_get() {
15565   void * jresult;
15566   Dali::Vector4 *result = 0 ;
15567
15568   result = (Dali::Vector4 *)&Dali::Color::LIGHT_SKY_BLUE;
15569   jresult = (void *)result;
15570   return jresult;
15571 }
15572
15573
15574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SLATE_GRAY_get() {
15575   void * jresult;
15576   Dali::Vector4 *result = 0 ;
15577
15578   result = (Dali::Vector4 *)&Dali::Color::LIGHT_SLATE_GRAY;
15579   jresult = (void *)result;
15580   return jresult;
15581 }
15582
15583
15584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SLATE_GREY_get() {
15585   void * jresult;
15586   Dali::Vector4 *result = 0 ;
15587
15588   result = (Dali::Vector4 *)&Dali::Color::LIGHT_SLATE_GREY;
15589   jresult = (void *)result;
15590   return jresult;
15591 }
15592
15593
15594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_STEEL_BLUE_get() {
15595   void * jresult;
15596   Dali::Vector4 *result = 0 ;
15597
15598   result = (Dali::Vector4 *)&Dali::Color::LIGHT_STEEL_BLUE;
15599   jresult = (void *)result;
15600   return jresult;
15601 }
15602
15603
15604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_YELLOW_get() {
15605   void * jresult;
15606   Dali::Vector4 *result = 0 ;
15607
15608   result = (Dali::Vector4 *)&Dali::Color::LIGHT_YELLOW;
15609   jresult = (void *)result;
15610   return jresult;
15611 }
15612
15613
15614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIME_get() {
15615   void * jresult;
15616   Dali::Vector4 *result = 0 ;
15617
15618   result = (Dali::Vector4 *)&Dali::Color::LIME;
15619   jresult = (void *)result;
15620   return jresult;
15621 }
15622
15623
15624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIME_GREEN_get() {
15625   void * jresult;
15626   Dali::Vector4 *result = 0 ;
15627
15628   result = (Dali::Vector4 *)&Dali::Color::LIME_GREEN;
15629   jresult = (void *)result;
15630   return jresult;
15631 }
15632
15633
15634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LINEN_get() {
15635   void * jresult;
15636   Dali::Vector4 *result = 0 ;
15637
15638   result = (Dali::Vector4 *)&Dali::Color::LINEN;
15639   jresult = (void *)result;
15640   return jresult;
15641 }
15642
15643
15644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
15645   void * jresult;
15646   Dali::Vector4 *result = 0 ;
15647
15648   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
15649   jresult = (void *)result;
15650   return jresult;
15651 }
15652
15653
15654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAROON_get() {
15655   void * jresult;
15656   Dali::Vector4 *result = 0 ;
15657
15658   result = (Dali::Vector4 *)&Dali::Color::MAROON;
15659   jresult = (void *)result;
15660   return jresult;
15661 }
15662
15663
15664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_AQUA_MARINE_get() {
15665   void * jresult;
15666   Dali::Vector4 *result = 0 ;
15667
15668   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_AQUA_MARINE;
15669   jresult = (void *)result;
15670   return jresult;
15671 }
15672
15673
15674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_BLUE_get() {
15675   void * jresult;
15676   Dali::Vector4 *result = 0 ;
15677
15678   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_BLUE;
15679   jresult = (void *)result;
15680   return jresult;
15681 }
15682
15683
15684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_ORCHID_get() {
15685   void * jresult;
15686   Dali::Vector4 *result = 0 ;
15687
15688   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_ORCHID;
15689   jresult = (void *)result;
15690   return jresult;
15691 }
15692
15693
15694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_PURPLE_get() {
15695   void * jresult;
15696   Dali::Vector4 *result = 0 ;
15697
15698   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_PURPLE;
15699   jresult = (void *)result;
15700   return jresult;
15701 }
15702
15703
15704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_SEA_GREEN_get() {
15705   void * jresult;
15706   Dali::Vector4 *result = 0 ;
15707
15708   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_SEA_GREEN;
15709   jresult = (void *)result;
15710   return jresult;
15711 }
15712
15713
15714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_SLATE_BLUE_get() {
15715   void * jresult;
15716   Dali::Vector4 *result = 0 ;
15717
15718   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_SLATE_BLUE;
15719   jresult = (void *)result;
15720   return jresult;
15721 }
15722
15723
15724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_SPRING_GREEN_get() {
15725   void * jresult;
15726   Dali::Vector4 *result = 0 ;
15727
15728   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_SPRING_GREEN;
15729   jresult = (void *)result;
15730   return jresult;
15731 }
15732
15733
15734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_TURQUOISE_get() {
15735   void * jresult;
15736   Dali::Vector4 *result = 0 ;
15737
15738   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_TURQUOISE;
15739   jresult = (void *)result;
15740   return jresult;
15741 }
15742
15743
15744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_VIOLETRED_get() {
15745   void * jresult;
15746   Dali::Vector4 *result = 0 ;
15747
15748   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_VIOLETRED;
15749   jresult = (void *)result;
15750   return jresult;
15751 }
15752
15753
15754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MIDNIGHT_BLUE_get() {
15755   void * jresult;
15756   Dali::Vector4 *result = 0 ;
15757
15758   result = (Dali::Vector4 *)&Dali::Color::MIDNIGHT_BLUE;
15759   jresult = (void *)result;
15760   return jresult;
15761 }
15762
15763
15764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MINT_CREAM_get() {
15765   void * jresult;
15766   Dali::Vector4 *result = 0 ;
15767
15768   result = (Dali::Vector4 *)&Dali::Color::MINT_CREAM;
15769   jresult = (void *)result;
15770   return jresult;
15771 }
15772
15773
15774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MISTY_ROSE_get() {
15775   void * jresult;
15776   Dali::Vector4 *result = 0 ;
15777
15778   result = (Dali::Vector4 *)&Dali::Color::MISTY_ROSE;
15779   jresult = (void *)result;
15780   return jresult;
15781 }
15782
15783
15784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MOCCASIN_get() {
15785   void * jresult;
15786   Dali::Vector4 *result = 0 ;
15787
15788   result = (Dali::Vector4 *)&Dali::Color::MOCCASIN;
15789   jresult = (void *)result;
15790   return jresult;
15791 }
15792
15793
15794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NAVAJO_WHITE_get() {
15795   void * jresult;
15796   Dali::Vector4 *result = 0 ;
15797
15798   result = (Dali::Vector4 *)&Dali::Color::NAVAJO_WHITE;
15799   jresult = (void *)result;
15800   return jresult;
15801 }
15802
15803
15804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NAVY_get() {
15805   void * jresult;
15806   Dali::Vector4 *result = 0 ;
15807
15808   result = (Dali::Vector4 *)&Dali::Color::NAVY;
15809   jresult = (void *)result;
15810   return jresult;
15811 }
15812
15813
15814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OLD_LACE_get() {
15815   void * jresult;
15816   Dali::Vector4 *result = 0 ;
15817
15818   result = (Dali::Vector4 *)&Dali::Color::OLD_LACE;
15819   jresult = (void *)result;
15820   return jresult;
15821 }
15822
15823
15824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OLIVE_get() {
15825   void * jresult;
15826   Dali::Vector4 *result = 0 ;
15827
15828   result = (Dali::Vector4 *)&Dali::Color::OLIVE;
15829   jresult = (void *)result;
15830   return jresult;
15831 }
15832
15833
15834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OLIVE_DRAB_get() {
15835   void * jresult;
15836   Dali::Vector4 *result = 0 ;
15837
15838   result = (Dali::Vector4 *)&Dali::Color::OLIVE_DRAB;
15839   jresult = (void *)result;
15840   return jresult;
15841 }
15842
15843
15844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ORANGE_get() {
15845   void * jresult;
15846   Dali::Vector4 *result = 0 ;
15847
15848   result = (Dali::Vector4 *)&Dali::Color::ORANGE;
15849   jresult = (void *)result;
15850   return jresult;
15851 }
15852
15853
15854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ORANGE_RED_get() {
15855   void * jresult;
15856   Dali::Vector4 *result = 0 ;
15857
15858   result = (Dali::Vector4 *)&Dali::Color::ORANGE_RED;
15859   jresult = (void *)result;
15860   return jresult;
15861 }
15862
15863
15864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ORCHID_get() {
15865   void * jresult;
15866   Dali::Vector4 *result = 0 ;
15867
15868   result = (Dali::Vector4 *)&Dali::Color::ORCHID;
15869   jresult = (void *)result;
15870   return jresult;
15871 }
15872
15873
15874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PALE_GOLDEN_ROD_get() {
15875   void * jresult;
15876   Dali::Vector4 *result = 0 ;
15877
15878   result = (Dali::Vector4 *)&Dali::Color::PALE_GOLDEN_ROD;
15879   jresult = (void *)result;
15880   return jresult;
15881 }
15882
15883
15884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PALE_GREEN_get() {
15885   void * jresult;
15886   Dali::Vector4 *result = 0 ;
15887
15888   result = (Dali::Vector4 *)&Dali::Color::PALE_GREEN;
15889   jresult = (void *)result;
15890   return jresult;
15891 }
15892
15893
15894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PALE_TURQUOISE_get() {
15895   void * jresult;
15896   Dali::Vector4 *result = 0 ;
15897
15898   result = (Dali::Vector4 *)&Dali::Color::PALE_TURQUOISE;
15899   jresult = (void *)result;
15900   return jresult;
15901 }
15902
15903
15904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PALE_VIOLET_RED_get() {
15905   void * jresult;
15906   Dali::Vector4 *result = 0 ;
15907
15908   result = (Dali::Vector4 *)&Dali::Color::PALE_VIOLET_RED;
15909   jresult = (void *)result;
15910   return jresult;
15911 }
15912
15913
15914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PAPAYA_WHIP_get() {
15915   void * jresult;
15916   Dali::Vector4 *result = 0 ;
15917
15918   result = (Dali::Vector4 *)&Dali::Color::PAPAYA_WHIP;
15919   jresult = (void *)result;
15920   return jresult;
15921 }
15922
15923
15924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PEACH_PUFF_get() {
15925   void * jresult;
15926   Dali::Vector4 *result = 0 ;
15927
15928   result = (Dali::Vector4 *)&Dali::Color::PEACH_PUFF;
15929   jresult = (void *)result;
15930   return jresult;
15931 }
15932
15933
15934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PERU_get() {
15935   void * jresult;
15936   Dali::Vector4 *result = 0 ;
15937
15938   result = (Dali::Vector4 *)&Dali::Color::PERU;
15939   jresult = (void *)result;
15940   return jresult;
15941 }
15942
15943
15944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PINK_get() {
15945   void * jresult;
15946   Dali::Vector4 *result = 0 ;
15947
15948   result = (Dali::Vector4 *)&Dali::Color::PINK;
15949   jresult = (void *)result;
15950   return jresult;
15951 }
15952
15953
15954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PLUM_get() {
15955   void * jresult;
15956   Dali::Vector4 *result = 0 ;
15957
15958   result = (Dali::Vector4 *)&Dali::Color::PLUM;
15959   jresult = (void *)result;
15960   return jresult;
15961 }
15962
15963
15964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_POWDER_BLUE_get() {
15965   void * jresult;
15966   Dali::Vector4 *result = 0 ;
15967
15968   result = (Dali::Vector4 *)&Dali::Color::POWDER_BLUE;
15969   jresult = (void *)result;
15970   return jresult;
15971 }
15972
15973
15974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PURPLE_get() {
15975   void * jresult;
15976   Dali::Vector4 *result = 0 ;
15977
15978   result = (Dali::Vector4 *)&Dali::Color::PURPLE;
15979   jresult = (void *)result;
15980   return jresult;
15981 }
15982
15983
15984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
15985   void * jresult;
15986   Dali::Vector4 *result = 0 ;
15987
15988   result = (Dali::Vector4 *)&Dali::Color::RED;
15989   jresult = (void *)result;
15990   return jresult;
15991 }
15992
15993
15994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ROSY_BROWN_get() {
15995   void * jresult;
15996   Dali::Vector4 *result = 0 ;
15997
15998   result = (Dali::Vector4 *)&Dali::Color::ROSY_BROWN;
15999   jresult = (void *)result;
16000   return jresult;
16001 }
16002
16003
16004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ROYAL_BLUE_get() {
16005   void * jresult;
16006   Dali::Vector4 *result = 0 ;
16007
16008   result = (Dali::Vector4 *)&Dali::Color::ROYAL_BLUE;
16009   jresult = (void *)result;
16010   return jresult;
16011 }
16012
16013
16014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SADDLE_BROWN_get() {
16015   void * jresult;
16016   Dali::Vector4 *result = 0 ;
16017
16018   result = (Dali::Vector4 *)&Dali::Color::SADDLE_BROWN;
16019   jresult = (void *)result;
16020   return jresult;
16021 }
16022
16023
16024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SALMON_get() {
16025   void * jresult;
16026   Dali::Vector4 *result = 0 ;
16027
16028   result = (Dali::Vector4 *)&Dali::Color::SALMON;
16029   jresult = (void *)result;
16030   return jresult;
16031 }
16032
16033
16034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SANDY_BROWN_get() {
16035   void * jresult;
16036   Dali::Vector4 *result = 0 ;
16037
16038   result = (Dali::Vector4 *)&Dali::Color::SANDY_BROWN;
16039   jresult = (void *)result;
16040   return jresult;
16041 }
16042
16043
16044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SEA_GREEN_get() {
16045   void * jresult;
16046   Dali::Vector4 *result = 0 ;
16047
16048   result = (Dali::Vector4 *)&Dali::Color::SEA_GREEN;
16049   jresult = (void *)result;
16050   return jresult;
16051 }
16052
16053
16054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SEA_SHELL_get() {
16055   void * jresult;
16056   Dali::Vector4 *result = 0 ;
16057
16058   result = (Dali::Vector4 *)&Dali::Color::SEA_SHELL;
16059   jresult = (void *)result;
16060   return jresult;
16061 }
16062
16063
16064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SIENNA_get() {
16065   void * jresult;
16066   Dali::Vector4 *result = 0 ;
16067
16068   result = (Dali::Vector4 *)&Dali::Color::SIENNA;
16069   jresult = (void *)result;
16070   return jresult;
16071 }
16072
16073
16074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SILVER_get() {
16075   void * jresult;
16076   Dali::Vector4 *result = 0 ;
16077
16078   result = (Dali::Vector4 *)&Dali::Color::SILVER;
16079   jresult = (void *)result;
16080   return jresult;
16081 }
16082
16083
16084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SKY_BLUE_get() {
16085   void * jresult;
16086   Dali::Vector4 *result = 0 ;
16087
16088   result = (Dali::Vector4 *)&Dali::Color::SKY_BLUE;
16089   jresult = (void *)result;
16090   return jresult;
16091 }
16092
16093
16094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SLATE_BLUE_get() {
16095   void * jresult;
16096   Dali::Vector4 *result = 0 ;
16097
16098   result = (Dali::Vector4 *)&Dali::Color::SLATE_BLUE;
16099   jresult = (void *)result;
16100   return jresult;
16101 }
16102
16103
16104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SLATE_GRAY_get() {
16105   void * jresult;
16106   Dali::Vector4 *result = 0 ;
16107
16108   result = (Dali::Vector4 *)&Dali::Color::SLATE_GRAY;
16109   jresult = (void *)result;
16110   return jresult;
16111 }
16112
16113
16114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SLATE_GREY_get() {
16115   void * jresult;
16116   Dali::Vector4 *result = 0 ;
16117
16118   result = (Dali::Vector4 *)&Dali::Color::SLATE_GREY;
16119   jresult = (void *)result;
16120   return jresult;
16121 }
16122
16123
16124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SNOW_get() {
16125   void * jresult;
16126   Dali::Vector4 *result = 0 ;
16127
16128   result = (Dali::Vector4 *)&Dali::Color::SNOW;
16129   jresult = (void *)result;
16130   return jresult;
16131 }
16132
16133
16134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SPRING_GREEN_get() {
16135   void * jresult;
16136   Dali::Vector4 *result = 0 ;
16137
16138   result = (Dali::Vector4 *)&Dali::Color::SPRING_GREEN;
16139   jresult = (void *)result;
16140   return jresult;
16141 }
16142
16143
16144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_STEEL_BLUE_get() {
16145   void * jresult;
16146   Dali::Vector4 *result = 0 ;
16147
16148   result = (Dali::Vector4 *)&Dali::Color::STEEL_BLUE;
16149   jresult = (void *)result;
16150   return jresult;
16151 }
16152
16153
16154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TAN_get() {
16155   void * jresult;
16156   Dali::Vector4 *result = 0 ;
16157
16158   result = (Dali::Vector4 *)&Dali::Color::TAN;
16159   jresult = (void *)result;
16160   return jresult;
16161 }
16162
16163
16164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TEAL_get() {
16165   void * jresult;
16166   Dali::Vector4 *result = 0 ;
16167
16168   result = (Dali::Vector4 *)&Dali::Color::TEAL;
16169   jresult = (void *)result;
16170   return jresult;
16171 }
16172
16173
16174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_THISTLE_get() {
16175   void * jresult;
16176   Dali::Vector4 *result = 0 ;
16177
16178   result = (Dali::Vector4 *)&Dali::Color::THISTLE;
16179   jresult = (void *)result;
16180   return jresult;
16181 }
16182
16183
16184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TOMATO_get() {
16185   void * jresult;
16186   Dali::Vector4 *result = 0 ;
16187
16188   result = (Dali::Vector4 *)&Dali::Color::TOMATO;
16189   jresult = (void *)result;
16190   return jresult;
16191 }
16192
16193
16194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
16195   void * jresult;
16196   Dali::Vector4 *result = 0 ;
16197
16198   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
16199   jresult = (void *)result;
16200   return jresult;
16201 }
16202
16203
16204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TURQUOISE_get() {
16205   void * jresult;
16206   Dali::Vector4 *result = 0 ;
16207
16208   result = (Dali::Vector4 *)&Dali::Color::TURQUOISE;
16209   jresult = (void *)result;
16210   return jresult;
16211 }
16212
16213
16214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VIOLET_get() {
16215   void * jresult;
16216   Dali::Vector4 *result = 0 ;
16217
16218   result = (Dali::Vector4 *)&Dali::Color::VIOLET;
16219   jresult = (void *)result;
16220   return jresult;
16221 }
16222
16223
16224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHEAT_get() {
16225   void * jresult;
16226   Dali::Vector4 *result = 0 ;
16227
16228   result = (Dali::Vector4 *)&Dali::Color::WHEAT;
16229   jresult = (void *)result;
16230   return jresult;
16231 }
16232
16233
16234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
16235   void * jresult;
16236   Dali::Vector4 *result = 0 ;
16237
16238   result = (Dali::Vector4 *)&Dali::Color::WHITE;
16239   jresult = (void *)result;
16240   return jresult;
16241 }
16242
16243
16244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_SMOKE_get() {
16245   void * jresult;
16246   Dali::Vector4 *result = 0 ;
16247
16248   result = (Dali::Vector4 *)&Dali::Color::WHITE_SMOKE;
16249   jresult = (void *)result;
16250   return jresult;
16251 }
16252
16253
16254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
16255   void * jresult;
16256   Dali::Vector4 *result = 0 ;
16257
16258   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
16259   jresult = (void *)result;
16260   return jresult;
16261 }
16262
16263
16264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_GREEN_get() {
16265   void * jresult;
16266   Dali::Vector4 *result = 0 ;
16267
16268   result = (Dali::Vector4 *)&Dali::Color::YELLOW_GREEN;
16269   jresult = (void *)result;
16270   return jresult;
16271 }
16272
16273
16274 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
16275   float jresult ;
16276   float result;
16277
16278   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
16279   jresult = result;
16280   return jresult;
16281 }
16282
16283
16284 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
16285   float jresult ;
16286   float result;
16287
16288   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
16289   jresult = result;
16290   return jresult;
16291 }
16292
16293
16294 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
16295   float jresult ;
16296   float result;
16297
16298   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
16299   jresult = result;
16300   return jresult;
16301 }
16302
16303
16304 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
16305   float jresult ;
16306   float result;
16307
16308   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
16309   jresult = result;
16310   return jresult;
16311 }
16312
16313
16314 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
16315   float jresult ;
16316   float result;
16317
16318   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
16319   jresult = result;
16320   return jresult;
16321 }
16322
16323
16324 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
16325   float jresult ;
16326   float result;
16327
16328   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
16329   jresult = result;
16330   return jresult;
16331 }
16332
16333
16334 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
16335   float jresult ;
16336   float result;
16337
16338   result = (float)(float)Dali::Math::PI;
16339   jresult = result;
16340   return jresult;
16341 }
16342
16343
16344 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
16345   float jresult ;
16346   float result;
16347
16348   result = (float)(float)Dali::Math::PI_2;
16349   jresult = result;
16350   return jresult;
16351 }
16352
16353
16354 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
16355   float jresult ;
16356   float result;
16357
16358   result = (float)(float)Dali::Math::PI_4;
16359   jresult = result;
16360   return jresult;
16361 }
16362
16363
16364 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
16365   float jresult ;
16366   float result;
16367
16368   result = (float)(float)Dali::Math::PI_OVER_180;
16369   jresult = result;
16370   return jresult;
16371 }
16372
16373
16374 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
16375   float jresult ;
16376   float result;
16377
16378   result = (float)(float)Dali::Math::ONE80_OVER_PI;
16379   jresult = result;
16380   return jresult;
16381 }
16382
16383
16384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
16385   int jresult ;
16386   Dali::ResizePolicy::Type result;
16387
16388   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
16389   jresult = (int)result;
16390   return jresult;
16391 }
16392
16393
16394 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
16395   unsigned long jresult ;
16396   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
16397   Dali::VectorBase::SizeType result;
16398
16399   arg1 = (Dali::VectorBase *)jarg1;
16400   {
16401     try {
16402       result = ((Dali::VectorBase const *)arg1)->Count();
16403     } CALL_CATCH_EXCEPTION(0);
16404   }
16405
16406   jresult = (unsigned long)result;
16407   return jresult;
16408 }
16409
16410
16411 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
16412   unsigned long jresult ;
16413   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
16414   Dali::VectorBase::SizeType result;
16415
16416   arg1 = (Dali::VectorBase *)jarg1;
16417   {
16418     try {
16419       result = ((Dali::VectorBase const *)arg1)->Size();
16420     } CALL_CATCH_EXCEPTION(0);
16421   }
16422
16423   jresult = (unsigned long)result;
16424   return jresult;
16425 }
16426
16427
16428 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
16429   bool jresult ;
16430   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
16431   bool result;
16432
16433   arg1 = (Dali::VectorBase *)jarg1;
16434   {
16435     try {
16436       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
16437     } CALL_CATCH_EXCEPTION(0);
16438   }
16439
16440   jresult = result;
16441   return jresult;
16442 }
16443
16444
16445 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
16446   unsigned long jresult ;
16447   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
16448   Dali::VectorBase::SizeType result;
16449
16450   arg1 = (Dali::VectorBase *)jarg1;
16451   {
16452     try {
16453       result = ((Dali::VectorBase const *)arg1)->Capacity();
16454     } CALL_CATCH_EXCEPTION(0);
16455   }
16456
16457   jresult = (unsigned long)result;
16458   return jresult;
16459 }
16460
16461
16462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
16463   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
16464
16465   arg1 = (Dali::VectorBase *)jarg1;
16466   {
16467     try {
16468       (arg1)->Release();
16469     } CALL_CATCH_EXCEPTION();
16470   }
16471
16472 }
16473
16474
16475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
16476   int jresult ;
16477   Dali::Pixel::Format result;
16478
16479   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
16480   jresult = (int)result;
16481   return jresult;
16482 }
16483
16484
16485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
16486   int jresult ;
16487   Dali::Pixel::Format result;
16488
16489   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
16490   jresult = (int)result;
16491   return jresult;
16492 }
16493
16494
16495 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
16496   bool jresult ;
16497   Dali::Pixel::Format arg1 ;
16498   bool result;
16499
16500   arg1 = (Dali::Pixel::Format)jarg1;
16501   {
16502     try {
16503       result = (bool)Dali::Pixel::HasAlpha(arg1);
16504     } CALL_CATCH_EXCEPTION(0);
16505   }
16506
16507   jresult = result;
16508   return jresult;
16509 }
16510
16511
16512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
16513   unsigned int jresult ;
16514   Dali::Pixel::Format arg1 ;
16515   unsigned int result;
16516
16517   arg1 = (Dali::Pixel::Format)jarg1;
16518   {
16519     try {
16520       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
16521     } CALL_CATCH_EXCEPTION(0);
16522   }
16523
16524   jresult = result;
16525   return jresult;
16526 }
16527
16528
16529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
16530   Dali::Pixel::Format arg1 ;
16531   int *arg2 = 0 ;
16532   int *arg3 = 0 ;
16533
16534   arg1 = (Dali::Pixel::Format)jarg1;
16535   arg2 = (int *)jarg2;
16536   if (!arg2) {
16537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
16538     return ;
16539   }
16540   arg3 = (int *)jarg3;
16541   if (!arg3) {
16542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
16543     return ;
16544   }
16545   {
16546     try {
16547       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
16548     } CALL_CATCH_EXCEPTION();
16549   }
16550
16551 }
16552
16553
16554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* nuiBuffer, unsigned int nuiBufferSize, unsigned int nuiWidth, unsigned int nuiHeight, int nuiPixelFormat) {
16555   void * jresult ;
16556   Dali::PixelData result;
16557
16558   {
16559     unsigned char* copiedBuffer;
16560     try
16561     {
16562       copiedBuffer = new unsigned char[nuiBufferSize];
16563     } CALL_CATCH_EXCEPTION(0);
16564
16565     try
16566     {
16567       // Note : copiedBuffer created by 'new' method. So ReleaseFunction always be DELETE_ARRAY.
16568       memcpy(copiedBuffer, nuiBuffer, nuiBufferSize);
16569       result = Dali::PixelData::New(copiedBuffer, nuiBufferSize, nuiWidth, nuiHeight, (Dali::Pixel::Format)nuiPixelFormat, Dali::PixelData::ReleaseFunction::DELETE_ARRAY);
16570     } CALL_CATCH_EXCEPTION_WITH_FUNCTION(0, [](unsigned char* buffer){delete[] buffer;}, copiedBuffer);
16571   }
16572
16573   jresult = new Dali::PixelData((const Dali::PixelData &)result);
16574
16575   return jresult;
16576 }
16577
16578
16579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
16580   void * jresult ;
16581   Dali::PixelData *result = 0 ;
16582
16583   {
16584     try {
16585       result = (Dali::PixelData *)new Dali::PixelData();
16586     } CALL_CATCH_EXCEPTION(0);
16587   }
16588
16589   jresult = (void *)result;
16590   return jresult;
16591 }
16592
16593
16594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * nuiHandle) {
16595   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
16596
16597   pixelData = (Dali::PixelData *)nuiHandle;
16598   {
16599     try {
16600       delete pixelData;
16601     } CALL_CATCH_EXCEPTION();
16602   }
16603
16604 }
16605
16606
16607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * nuiHandle) {
16608   void * jresult ;
16609   Dali::PixelData *pixelData = 0 ;
16610   Dali::PixelData *result = 0 ;
16611
16612   pixelData = (Dali::PixelData *)nuiHandle;
16613   if (!pixelData) {
16614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
16615     return 0;
16616   }
16617   {
16618     try {
16619       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*pixelData);
16620     } CALL_CATCH_EXCEPTION(0);
16621   }
16622
16623   jresult = (void *)result;
16624   return jresult;
16625 }
16626
16627
16628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * nuiHandle, void * nuiHandleSource) {
16629   void * jresult ;
16630   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
16631   Dali::PixelData *pixelDataSource = 0 ;
16632   Dali::PixelData *result = 0 ;
16633
16634   pixelData = (Dali::PixelData *)nuiHandle;
16635   pixelDataSource = (Dali::PixelData *)nuiHandleSource;
16636   if (!pixelDataSource) {
16637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
16638     return 0;
16639   }
16640   {
16641     try {
16642       result = (Dali::PixelData *) &(pixelData)->operator =((Dali::PixelData const &)*pixelDataSource);
16643     } CALL_CATCH_EXCEPTION(0);
16644   }
16645
16646   jresult = (void *)result;
16647   return jresult;
16648 }
16649
16650
16651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * nuiHandle) {
16652   unsigned int jresult ;
16653   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
16654   unsigned int result;
16655
16656   pixelData = (Dali::PixelData *)nuiHandle;
16657   {
16658     try {
16659       result = (unsigned int)((Dali::PixelData const *)pixelData)->GetWidth();
16660     } CALL_CATCH_EXCEPTION(0);
16661   }
16662
16663   jresult = result;
16664   return jresult;
16665 }
16666
16667
16668 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * nuiHandle) {
16669   unsigned int jresult ;
16670   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
16671   unsigned int result;
16672
16673   pixelData = (Dali::PixelData *)nuiHandle;
16674   {
16675     try {
16676       result = (unsigned int)((Dali::PixelData const *)pixelData)->GetHeight();
16677     } CALL_CATCH_EXCEPTION(0);
16678   }
16679
16680   jresult = result;
16681   return jresult;
16682 }
16683
16684
16685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * nuiHandle) {
16686   int jresult ;
16687   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
16688   Dali::Pixel::Format result;
16689
16690   pixelData = (Dali::PixelData *)nuiHandle;
16691   {
16692     try {
16693       result = (Dali::Pixel::Format)((Dali::PixelData const *)pixelData)->GetPixelFormat();
16694     } CALL_CATCH_EXCEPTION(0);
16695   }
16696
16697   jresult = (int)result;
16698   return jresult;
16699 }
16700
16701 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_PixelData_GenerateUrl(void* nuiHandle)
16702 {
16703   Dali::PixelData *pixelData = (Dali::PixelData*)nuiHandle;
16704   Dali::Toolkit::ImageUrl result;
16705   void *jresult;
16706
16707   if (!pixelData)
16708   {
16709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0);
16710     return 0;
16711   }
16712   {
16713     try
16714     {
16715       result = Dali::Toolkit::Image::GenerateUrl(*pixelData);
16716     } CALL_CATCH_EXCEPTION(0);
16717   }
16718
16719   jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl&)result);
16720   return jresult;
16721 }
16722
16723
16724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
16725   unsigned int jresult ;
16726   unsigned int result;
16727
16728   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
16729   jresult = result;
16730   return jresult;
16731 }
16732
16733
16734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
16735   unsigned int jresult ;
16736   unsigned int result;
16737
16738   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
16739   jresult = result;
16740   return jresult;
16741 }
16742
16743
16744 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
16745   unsigned int jresult ;
16746   unsigned int result;
16747
16748   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
16749   jresult = result;
16750   return jresult;
16751 }
16752
16753
16754 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
16755   unsigned int jresult ;
16756   unsigned int result;
16757
16758   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
16759   jresult = result;
16760   return jresult;
16761 }
16762
16763
16764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
16765   unsigned int jresult ;
16766   unsigned int result;
16767
16768   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
16769   jresult = result;
16770   return jresult;
16771 }
16772
16773
16774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
16775   unsigned int jresult ;
16776   unsigned int result;
16777
16778   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
16779   jresult = result;
16780   return jresult;
16781 }
16782
16783
16784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
16785   void * jresult ;
16786   Dali::TextureType::Type arg1 ;
16787   Dali::Pixel::Format arg2 ;
16788   unsigned int arg3 ;
16789   unsigned int arg4 ;
16790   Dali::Texture result;
16791
16792   arg1 = (Dali::TextureType::Type)jarg1;
16793   arg2 = (Dali::Pixel::Format)jarg2;
16794   arg3 = (unsigned int)jarg3;
16795   arg4 = (unsigned int)jarg4;
16796   {
16797     try {
16798       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
16799     } CALL_CATCH_EXCEPTION(0);
16800   }
16801
16802   jresult = new Dali::Texture((const Dali::Texture &)result);
16803   return jresult;
16804 }
16805
16806
16807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
16808   void * jresult ;
16809   NativeImageInterface *arg1 = 0 ;
16810   Dali::Texture result;
16811
16812   arg1 = (NativeImageInterface *)jarg1;
16813   if (!arg1) {
16814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
16815     return 0;
16816   }
16817   {
16818     try {
16819       result = Dali::Texture::New(*arg1);
16820     } CALL_CATCH_EXCEPTION(0);
16821   }
16822
16823   jresult = new Dali::Texture((const Dali::Texture &)result);
16824   return jresult;
16825 }
16826
16827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
16828   void * jresult ;
16829   Dali::Texture *result = 0 ;
16830
16831   {
16832     try {
16833       result = (Dali::Texture *)new Dali::Texture();
16834     } CALL_CATCH_EXCEPTION(0);
16835   }
16836
16837   jresult = (void *)result;
16838   return jresult;
16839 }
16840
16841
16842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
16843   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16844
16845   arg1 = (Dali::Texture *)jarg1;
16846   {
16847     try {
16848       delete arg1;
16849     } CALL_CATCH_EXCEPTION();
16850   }
16851
16852 }
16853
16854
16855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
16856   void * jresult ;
16857   Dali::Texture *arg1 = 0 ;
16858   Dali::Texture *result = 0 ;
16859
16860   arg1 = (Dali::Texture *)jarg1;
16861   if (!arg1) {
16862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
16863     return 0;
16864   }
16865   {
16866     try {
16867       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
16868     } CALL_CATCH_EXCEPTION(0);
16869   }
16870
16871   jresult = (void *)result;
16872   return jresult;
16873 }
16874
16875
16876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
16877   void * jresult ;
16878   Dali::BaseHandle arg1 ;
16879   Dali::BaseHandle *argp1 ;
16880   Dali::Texture result;
16881
16882   argp1 = (Dali::BaseHandle *)jarg1;
16883   if (!argp1) {
16884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16885     return 0;
16886   }
16887   arg1 = *argp1;
16888   {
16889     try {
16890       result = Dali::Texture::DownCast(arg1);
16891     } CALL_CATCH_EXCEPTION(0);
16892   }
16893
16894   jresult = new Dali::Texture((const Dali::Texture &)result);
16895   return jresult;
16896 }
16897
16898
16899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
16900   void * jresult ;
16901   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16902   Dali::Texture *arg2 = 0 ;
16903   Dali::Texture *result = 0 ;
16904
16905   arg1 = (Dali::Texture *)jarg1;
16906   arg2 = (Dali::Texture *)jarg2;
16907   if (!arg2) {
16908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
16909     return 0;
16910   }
16911   {
16912     try {
16913       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
16914     } CALL_CATCH_EXCEPTION(0);
16915   }
16916
16917   jresult = (void *)result;
16918   return jresult;
16919 }
16920
16921
16922 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
16923   bool jresult ;
16924   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16925   Dali::PixelData arg2 ;
16926   Dali::PixelData *argp2 ;
16927   bool result;
16928
16929   arg1 = (Dali::Texture *)jarg1;
16930   argp2 = (Dali::PixelData *)jarg2;
16931   if (!argp2) {
16932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
16933     return 0;
16934   }
16935   arg2 = *argp2;
16936   {
16937     try {
16938       result = (bool)(arg1)->Upload(arg2);
16939     } CALL_CATCH_EXCEPTION(0);
16940   }
16941
16942   jresult = result;
16943   return jresult;
16944 }
16945
16946
16947 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) {
16948   bool jresult ;
16949   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16950   Dali::PixelData arg2 ;
16951   unsigned int arg3 ;
16952   unsigned int arg4 ;
16953   unsigned int arg5 ;
16954   unsigned int arg6 ;
16955   unsigned int arg7 ;
16956   unsigned int arg8 ;
16957   Dali::PixelData *argp2 ;
16958   bool result;
16959
16960   arg1 = (Dali::Texture *)jarg1;
16961   argp2 = (Dali::PixelData *)jarg2;
16962   if (!argp2) {
16963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
16964     return 0;
16965   }
16966   arg2 = *argp2;
16967   arg3 = (unsigned int)jarg3;
16968   arg4 = (unsigned int)jarg4;
16969   arg5 = (unsigned int)jarg5;
16970   arg6 = (unsigned int)jarg6;
16971   arg7 = (unsigned int)jarg7;
16972   arg8 = (unsigned int)jarg8;
16973   {
16974     try {
16975       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
16976     } CALL_CATCH_EXCEPTION(0);
16977   }
16978
16979   jresult = result;
16980   return jresult;
16981 }
16982
16983
16984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
16985   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16986
16987   arg1 = (Dali::Texture *)jarg1;
16988   {
16989     try {
16990       (arg1)->GenerateMipmaps();
16991     } CALL_CATCH_EXCEPTION();
16992   }
16993
16994 }
16995
16996
16997 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
16998   unsigned int jresult ;
16999   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
17000   unsigned int result;
17001
17002   arg1 = (Dali::Texture *)jarg1;
17003   {
17004     try {
17005       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
17006     } CALL_CATCH_EXCEPTION(0);
17007   }
17008
17009   jresult = result;
17010   return jresult;
17011 }
17012
17013
17014 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
17015   unsigned int jresult ;
17016   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
17017   unsigned int result;
17018
17019   arg1 = (Dali::Texture *)jarg1;
17020   {
17021     try {
17022       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
17023     } CALL_CATCH_EXCEPTION(0);
17024   }
17025
17026   jresult = result;
17027   return jresult;
17028 }
17029
17030
17031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
17032   void * jresult ;
17033   Dali::Sampler result;
17034
17035   {
17036     try {
17037       result = Dali::Sampler::New();
17038     } CALL_CATCH_EXCEPTION(0);
17039   }
17040
17041   jresult = new Dali::Sampler((const Dali::Sampler &)result);
17042   return jresult;
17043 }
17044
17045
17046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
17047   void * jresult ;
17048   Dali::Sampler *result = 0 ;
17049
17050   {
17051     try {
17052       result = (Dali::Sampler *)new Dali::Sampler();
17053     } CALL_CATCH_EXCEPTION(0);
17054   }
17055
17056   jresult = (void *)result;
17057   return jresult;
17058 }
17059
17060
17061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
17062   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
17063
17064   arg1 = (Dali::Sampler *)jarg1;
17065   {
17066     try {
17067       delete arg1;
17068     } CALL_CATCH_EXCEPTION();
17069   }
17070
17071 }
17072
17073
17074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
17075   void * jresult ;
17076   Dali::Sampler *arg1 = 0 ;
17077   Dali::Sampler *result = 0 ;
17078
17079   arg1 = (Dali::Sampler *)jarg1;
17080   if (!arg1) {
17081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
17082     return 0;
17083   }
17084   {
17085     try {
17086       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
17087     } CALL_CATCH_EXCEPTION(0);
17088   }
17089
17090   jresult = (void *)result;
17091   return jresult;
17092 }
17093
17094
17095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
17096   void * jresult ;
17097   Dali::BaseHandle arg1 ;
17098   Dali::BaseHandle *argp1 ;
17099   Dali::Sampler result;
17100
17101   argp1 = (Dali::BaseHandle *)jarg1;
17102   if (!argp1) {
17103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17104     return 0;
17105   }
17106   arg1 = *argp1;
17107   {
17108     try {
17109       result = Dali::Sampler::DownCast(arg1);
17110     } CALL_CATCH_EXCEPTION(0);
17111   }
17112
17113   jresult = new Dali::Sampler((const Dali::Sampler &)result);
17114   return jresult;
17115 }
17116
17117
17118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
17119   void * jresult ;
17120   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
17121   Dali::Sampler *arg2 = 0 ;
17122   Dali::Sampler *result = 0 ;
17123
17124   arg1 = (Dali::Sampler *)jarg1;
17125   arg2 = (Dali::Sampler *)jarg2;
17126   if (!arg2) {
17127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
17128     return 0;
17129   }
17130   {
17131     try {
17132       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
17133     } CALL_CATCH_EXCEPTION(0);
17134   }
17135
17136   jresult = (void *)result;
17137   return jresult;
17138 }
17139
17140
17141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
17142   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
17143   Dali::FilterMode::Type arg2 ;
17144   Dali::FilterMode::Type arg3 ;
17145
17146   arg1 = (Dali::Sampler *)jarg1;
17147   arg2 = (Dali::FilterMode::Type)jarg2;
17148   arg3 = (Dali::FilterMode::Type)jarg3;
17149   {
17150     try {
17151       (arg1)->SetFilterMode(arg2,arg3);
17152     } CALL_CATCH_EXCEPTION();
17153   }
17154
17155 }
17156
17157
17158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
17159   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
17160   Dali::WrapMode::Type arg2 ;
17161   Dali::WrapMode::Type arg3 ;
17162
17163   arg1 = (Dali::Sampler *)jarg1;
17164   arg2 = (Dali::WrapMode::Type)jarg2;
17165   arg3 = (Dali::WrapMode::Type)jarg3;
17166   {
17167     try {
17168       (arg1)->SetWrapMode(arg2,arg3);
17169     } CALL_CATCH_EXCEPTION();
17170   }
17171
17172 }
17173
17174
17175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
17176   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
17177   Dali::WrapMode::Type arg2 ;
17178   Dali::WrapMode::Type arg3 ;
17179   Dali::WrapMode::Type arg4 ;
17180
17181   arg1 = (Dali::Sampler *)jarg1;
17182   arg2 = (Dali::WrapMode::Type)jarg2;
17183   arg3 = (Dali::WrapMode::Type)jarg3;
17184   arg4 = (Dali::WrapMode::Type)jarg4;
17185   {
17186     try {
17187       (arg1)->SetWrapMode(arg2,arg3,arg4);
17188     } CALL_CATCH_EXCEPTION();
17189   }
17190
17191 }
17192
17193
17194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
17195   void * jresult ;
17196   Dali::TextureSet result;
17197
17198   {
17199     try {
17200       result = Dali::TextureSet::New();
17201     } CALL_CATCH_EXCEPTION(0);
17202   }
17203
17204   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
17205   return jresult;
17206 }
17207
17208
17209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
17210   void * jresult ;
17211   Dali::TextureSet *result = 0 ;
17212
17213   {
17214     try {
17215       result = (Dali::TextureSet *)new Dali::TextureSet();
17216     } CALL_CATCH_EXCEPTION(0);
17217   }
17218
17219   jresult = (void *)result;
17220   return jresult;
17221 }
17222
17223
17224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
17225   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
17226
17227   arg1 = (Dali::TextureSet *)jarg1;
17228   {
17229     try {
17230       delete arg1;
17231     } CALL_CATCH_EXCEPTION();
17232   }
17233
17234 }
17235
17236
17237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
17238   void * jresult ;
17239   Dali::TextureSet *arg1 = 0 ;
17240   Dali::TextureSet *result = 0 ;
17241
17242   arg1 = (Dali::TextureSet *)jarg1;
17243   if (!arg1) {
17244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
17245     return 0;
17246   }
17247   {
17248     try {
17249       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
17250     } CALL_CATCH_EXCEPTION(0);
17251   }
17252
17253   jresult = (void *)result;
17254   return jresult;
17255 }
17256
17257
17258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
17259   void * jresult ;
17260   Dali::BaseHandle arg1 ;
17261   Dali::BaseHandle *argp1 ;
17262   Dali::TextureSet result;
17263
17264   argp1 = (Dali::BaseHandle *)jarg1;
17265   if (!argp1) {
17266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17267     return 0;
17268   }
17269   arg1 = *argp1;
17270   {
17271     try {
17272       result = Dali::TextureSet::DownCast(arg1);
17273     } CALL_CATCH_EXCEPTION(0);
17274   }
17275
17276   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
17277   return jresult;
17278 }
17279
17280
17281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
17282   void * jresult ;
17283   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
17284   Dali::TextureSet *arg2 = 0 ;
17285   Dali::TextureSet *result = 0 ;
17286
17287   arg1 = (Dali::TextureSet *)jarg1;
17288   arg2 = (Dali::TextureSet *)jarg2;
17289   if (!arg2) {
17290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
17291     return 0;
17292   }
17293   {
17294     try {
17295       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
17296     } CALL_CATCH_EXCEPTION(0);
17297   }
17298
17299   jresult = (void *)result;
17300   return jresult;
17301 }
17302
17303
17304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
17305   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
17306   size_t arg2 ;
17307   Dali::Texture arg3 ;
17308   Dali::Texture *argp3 ;
17309
17310   arg1 = (Dali::TextureSet *)jarg1;
17311   arg2 = (size_t)jarg2;
17312   argp3 = (Dali::Texture *)jarg3;
17313   if (!argp3) {
17314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
17315     return ;
17316   }
17317   arg3 = *argp3;
17318   {
17319     try {
17320       (arg1)->SetTexture(arg2,arg3);
17321     } CALL_CATCH_EXCEPTION();
17322   }
17323
17324 }
17325
17326
17327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
17328   void * jresult ;
17329   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
17330   size_t arg2 ;
17331   Dali::Texture result;
17332
17333   arg1 = (Dali::TextureSet *)jarg1;
17334   arg2 = (size_t)jarg2;
17335   {
17336     try {
17337       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
17338     } CALL_CATCH_EXCEPTION(0);
17339   }
17340
17341   jresult = new Dali::Texture((const Dali::Texture &)result);
17342   return jresult;
17343 }
17344
17345
17346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
17347   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
17348   size_t arg2 ;
17349   Dali::Sampler arg3 ;
17350   Dali::Sampler *argp3 ;
17351
17352   arg1 = (Dali::TextureSet *)jarg1;
17353   arg2 = (size_t)jarg2;
17354   argp3 = (Dali::Sampler *)jarg3;
17355   if (!argp3) {
17356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
17357     return ;
17358   }
17359   arg3 = *argp3;
17360   {
17361     try {
17362       (arg1)->SetSampler(arg2,arg3);
17363     } CALL_CATCH_EXCEPTION();
17364   }
17365
17366 }
17367
17368
17369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
17370   void * jresult ;
17371   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
17372   size_t arg2 ;
17373   Dali::Sampler result;
17374
17375   arg1 = (Dali::TextureSet *)jarg1;
17376   arg2 = (size_t)jarg2;
17377   {
17378     try {
17379       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
17380     } CALL_CATCH_EXCEPTION(0);
17381   }
17382
17383   jresult = new Dali::Sampler((const Dali::Sampler &)result);
17384   return jresult;
17385 }
17386
17387
17388 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
17389   unsigned long jresult ;
17390   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
17391   size_t result;
17392
17393   arg1 = (Dali::TextureSet *)jarg1;
17394   {
17395     try {
17396       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
17397     } CALL_CATCH_EXCEPTION(0);
17398   }
17399
17400   jresult = (unsigned long)result;
17401   return jresult;
17402 }
17403
17404
17405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_New(void * jarg1) {
17406   void * jresult ;
17407   Dali::Property::Map *arg1 = 0 ;
17408   Dali::VertexBuffer result;
17409
17410   arg1 = (Dali::Property::Map *)jarg1;
17411   if (!arg1) {
17412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17413     return 0;
17414   }
17415   {
17416     try {
17417       result = Dali::VertexBuffer::New(*arg1);
17418     } CALL_CATCH_EXCEPTION(0);
17419   }
17420
17421   jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result);
17422   return jresult;
17423 }
17424
17425
17426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_0() {
17427   void * jresult ;
17428   Dali::VertexBuffer *result = 0 ;
17429
17430   {
17431     try {
17432       result = (Dali::VertexBuffer *)new Dali::VertexBuffer();
17433     } CALL_CATCH_EXCEPTION(0);
17434   }
17435
17436   jresult = (void *)result;
17437   return jresult;
17438 }
17439
17440
17441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VertexBuffer(void * jarg1) {
17442   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
17443
17444   arg1 = (Dali::VertexBuffer *)jarg1;
17445   {
17446     try {
17447       delete arg1;
17448     } CALL_CATCH_EXCEPTION();
17449   }
17450
17451 }
17452
17453
17454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_1(void * jarg1) {
17455   void * jresult ;
17456   Dali::VertexBuffer *arg1 = 0 ;
17457   Dali::VertexBuffer *result = 0 ;
17458
17459   arg1 = (Dali::VertexBuffer *)jarg1;
17460   if (!arg1) {
17461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0);
17462     return 0;
17463   }
17464   {
17465     try {
17466       result = (Dali::VertexBuffer *)new Dali::VertexBuffer((Dali::VertexBuffer const &)*arg1);
17467     } CALL_CATCH_EXCEPTION(0);
17468   }
17469
17470   jresult = (void *)result;
17471   return jresult;
17472 }
17473
17474
17475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_DownCast(void * jarg1) {
17476   void * jresult ;
17477   Dali::BaseHandle arg1 ;
17478   Dali::BaseHandle *argp1 ;
17479   Dali::VertexBuffer result;
17480
17481   argp1 = (Dali::BaseHandle *)jarg1;
17482   if (!argp1) {
17483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17484     return 0;
17485   }
17486   arg1 = *argp1;
17487   {
17488     try {
17489       result = Dali::VertexBuffer::DownCast(arg1);
17490     } CALL_CATCH_EXCEPTION(0);
17491   }
17492
17493   jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result);
17494   return jresult;
17495 }
17496
17497
17498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_Assign(void * jarg1, void * jarg2) {
17499   void * jresult ;
17500   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
17501   Dali::VertexBuffer *arg2 = 0 ;
17502   Dali::VertexBuffer *result = 0 ;
17503
17504   arg1 = (Dali::VertexBuffer *)jarg1;
17505   arg2 = (Dali::VertexBuffer *)jarg2;
17506   if (!arg2) {
17507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0);
17508     return 0;
17509   }
17510   {
17511     try {
17512       result = (Dali::VertexBuffer *) &(arg1)->operator =((Dali::VertexBuffer const &)*arg2);
17513     } CALL_CATCH_EXCEPTION(0);
17514   }
17515
17516   jresult = (void *)result;
17517   return jresult;
17518 }
17519
17520
17521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VertexBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
17522   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
17523   void *arg2 = (void *) 0 ;
17524   std::size_t arg3 ;
17525
17526   arg1 = (Dali::VertexBuffer *)jarg1;
17527   arg2 = jarg2;
17528   arg3 = (std::size_t)jarg3;
17529   {
17530     try {
17531       (arg1)->SetData((void const *)arg2,arg3);
17532     } CALL_CATCH_EXCEPTION();
17533   }
17534
17535 }
17536
17537
17538 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VertexBuffer_GetSize(void * jarg1) {
17539   unsigned long jresult ;
17540   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
17541   std::size_t result;
17542
17543   arg1 = (Dali::VertexBuffer *)jarg1;
17544   {
17545     try {
17546       result = ((Dali::VertexBuffer const *)arg1)->GetSize();
17547     } CALL_CATCH_EXCEPTION(0);
17548   }
17549
17550   jresult = (unsigned long)result;
17551   return jresult;
17552 }
17553
17554
17555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
17556   void * jresult ;
17557   Dali::Geometry result;
17558
17559   {
17560     try {
17561       result = Dali::Geometry::New();
17562     } CALL_CATCH_EXCEPTION(0);
17563   }
17564
17565   jresult = new Dali::Geometry((const Dali::Geometry &)result);
17566   return jresult;
17567 }
17568
17569
17570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
17571   void * jresult ;
17572   Dali::Geometry *result = 0 ;
17573
17574   {
17575     try {
17576       result = (Dali::Geometry *)new Dali::Geometry();
17577     } CALL_CATCH_EXCEPTION(0);
17578   }
17579
17580   jresult = (void *)result;
17581   return jresult;
17582 }
17583
17584
17585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
17586   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17587
17588   arg1 = (Dali::Geometry *)jarg1;
17589   {
17590     try {
17591       delete arg1;
17592     } CALL_CATCH_EXCEPTION();
17593   }
17594
17595 }
17596
17597
17598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
17599   void * jresult ;
17600   Dali::Geometry *arg1 = 0 ;
17601   Dali::Geometry *result = 0 ;
17602
17603   arg1 = (Dali::Geometry *)jarg1;
17604   if (!arg1) {
17605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
17606     return 0;
17607   }
17608   {
17609     try {
17610       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
17611     } CALL_CATCH_EXCEPTION(0);
17612   }
17613
17614   jresult = (void *)result;
17615   return jresult;
17616 }
17617
17618
17619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
17620   void * jresult ;
17621   Dali::BaseHandle arg1 ;
17622   Dali::BaseHandle *argp1 ;
17623   Dali::Geometry result;
17624
17625   argp1 = (Dali::BaseHandle *)jarg1;
17626   if (!argp1) {
17627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17628     return 0;
17629   }
17630   arg1 = *argp1;
17631   {
17632     try {
17633       result = Dali::Geometry::DownCast(arg1);
17634     } CALL_CATCH_EXCEPTION(0);
17635   }
17636
17637   jresult = new Dali::Geometry((const Dali::Geometry &)result);
17638   return jresult;
17639 }
17640
17641
17642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
17643   void * jresult ;
17644   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17645   Dali::Geometry *arg2 = 0 ;
17646   Dali::Geometry *result = 0 ;
17647
17648   arg1 = (Dali::Geometry *)jarg1;
17649   arg2 = (Dali::Geometry *)jarg2;
17650   if (!arg2) {
17651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
17652     return 0;
17653   }
17654   {
17655     try {
17656       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
17657     } CALL_CATCH_EXCEPTION(0);
17658   }
17659
17660   jresult = (void *)result;
17661   return jresult;
17662 }
17663
17664
17665 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
17666   unsigned long jresult ;
17667   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17668   Dali::VertexBuffer *arg2 = 0 ;
17669   std::size_t result;
17670
17671   arg1 = (Dali::Geometry *)jarg1;
17672   arg2 = (Dali::VertexBuffer *)jarg2;
17673   if (!arg2) {
17674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer & type is null", 0);
17675     return 0;
17676   }
17677   {
17678     try {
17679       result = (arg1)->AddVertexBuffer(*arg2);
17680     } CALL_CATCH_EXCEPTION(0);
17681   }
17682
17683   jresult = (unsigned long)result;
17684   return jresult;
17685 }
17686
17687
17688 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
17689   unsigned long jresult ;
17690   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17691   std::size_t result;
17692
17693   arg1 = (Dali::Geometry *)jarg1;
17694   {
17695     try {
17696       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
17697     } CALL_CATCH_EXCEPTION(0);
17698   }
17699
17700   jresult = (unsigned long)result;
17701   return jresult;
17702 }
17703
17704
17705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
17706   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17707   std::size_t arg2 ;
17708
17709   arg1 = (Dali::Geometry *)jarg1;
17710   arg2 = (std::size_t)jarg2;
17711   {
17712     try {
17713       (arg1)->RemoveVertexBuffer(arg2);
17714     } CALL_CATCH_EXCEPTION();
17715   }
17716
17717 }
17718
17719
17720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
17721   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17722   unsigned short *arg2 = (unsigned short *) 0 ;
17723   size_t arg3 ;
17724
17725   arg1 = (Dali::Geometry *)jarg1;
17726   arg2 = jarg2;
17727   arg3 = (size_t)jarg3;
17728   {
17729     try {
17730       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
17731     } CALL_CATCH_EXCEPTION();
17732   }
17733
17734
17735
17736 }
17737
17738
17739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
17740   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17741   Dali::Geometry::Type arg2 ;
17742
17743   arg1 = (Dali::Geometry *)jarg1;
17744   arg2 = (Dali::Geometry::Type)jarg2;
17745   {
17746     try {
17747       (arg1)->SetType(arg2);
17748     } CALL_CATCH_EXCEPTION();
17749   }
17750
17751 }
17752
17753
17754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
17755   int jresult ;
17756   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17757   Dali::Geometry::Type result;
17758
17759   arg1 = (Dali::Geometry *)jarg1;
17760   {
17761     try {
17762       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
17763     } CALL_CATCH_EXCEPTION(0);
17764   }
17765
17766   jresult = (int)result;
17767   return jresult;
17768 }
17769
17770
17771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
17772   void * jresult ;
17773   Dali::Shader::Hint *result = 0 ;
17774
17775   {
17776     try {
17777       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
17778     } CALL_CATCH_EXCEPTION(0);
17779   }
17780
17781   jresult = (void *)result;
17782   return jresult;
17783 }
17784
17785
17786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
17787   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
17788
17789   arg1 = (Dali::Shader::Hint *)jarg1;
17790   {
17791     try {
17792       delete arg1;
17793     } CALL_CATCH_EXCEPTION();
17794   }
17795
17796 }
17797
17798
17799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
17800   int jresult ;
17801   int result;
17802
17803   result = (int)Dali::Shader::Property::PROGRAM;
17804   jresult = (int)result;
17805   return jresult;
17806 }
17807
17808
17809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
17810   void * jresult ;
17811   Dali::Shader::Property *result = 0 ;
17812
17813   {
17814     try {
17815       result = (Dali::Shader::Property *)new Dali::Shader::Property();
17816     } CALL_CATCH_EXCEPTION(0);
17817   }
17818
17819   jresult = (void *)result;
17820   return jresult;
17821 }
17822
17823
17824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
17825   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
17826
17827   arg1 = (Dali::Shader::Property *)jarg1;
17828   {
17829     try {
17830       delete arg1;
17831     } CALL_CATCH_EXCEPTION();
17832   }
17833
17834 }
17835
17836
17837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
17838   void * jresult ;
17839   std::string *arg1 = 0 ;
17840   std::string *arg2 = 0 ;
17841   Dali::Shader::Hint::Value arg3 ;
17842   Dali::Shader result;
17843
17844   if (!jarg1) {
17845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17846     return 0;
17847   }
17848   std::string arg1_str(jarg1);
17849   arg1 = &arg1_str;
17850   if (!jarg2) {
17851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17852     return 0;
17853   }
17854   std::string arg2_str(jarg2);
17855   arg2 = &arg2_str;
17856   arg3 = (Dali::Shader::Hint::Value)jarg3;
17857   {
17858     try {
17859       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
17860     } CALL_CATCH_EXCEPTION(0);
17861   }
17862
17863   jresult = new Dali::Shader((const Dali::Shader &)result);
17864
17865   //argout typemap for const std::string&
17866
17867
17868   //argout typemap for const std::string&
17869
17870   return jresult;
17871 }
17872
17873
17874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
17875   void * jresult ;
17876   std::string *arg1 = 0 ;
17877   std::string *arg2 = 0 ;
17878   Dali::Shader result;
17879
17880   if (!jarg1) {
17881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17882     return 0;
17883   }
17884   std::string arg1_str(jarg1);
17885   arg1 = &arg1_str;
17886   if (!jarg2) {
17887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17888     return 0;
17889   }
17890   std::string arg2_str(jarg2);
17891   arg2 = &arg2_str;
17892   {
17893     try {
17894       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
17895     } CALL_CATCH_EXCEPTION(0);
17896   }
17897
17898   jresult = new Dali::Shader((const Dali::Shader &)result);
17899
17900   //argout typemap for const std::string&
17901
17902
17903   //argout typemap for const std::string&
17904
17905   return jresult;
17906 }
17907
17908
17909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
17910   void * jresult ;
17911   Dali::Shader *result = 0 ;
17912
17913   {
17914     try {
17915       result = (Dali::Shader *)new Dali::Shader();
17916     } CALL_CATCH_EXCEPTION(0);
17917   }
17918
17919   jresult = (void *)result;
17920   return jresult;
17921 }
17922
17923
17924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
17925   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
17926
17927   arg1 = (Dali::Shader *)jarg1;
17928   {
17929     try {
17930       delete arg1;
17931     } CALL_CATCH_EXCEPTION();
17932   }
17933
17934 }
17935
17936
17937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
17938   void * jresult ;
17939   Dali::Shader *arg1 = 0 ;
17940   Dali::Shader *result = 0 ;
17941
17942   arg1 = (Dali::Shader *)jarg1;
17943   if (!arg1) {
17944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
17945     return 0;
17946   }
17947   {
17948     try {
17949       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
17950     } CALL_CATCH_EXCEPTION(0);
17951   }
17952
17953   jresult = (void *)result;
17954   return jresult;
17955 }
17956
17957
17958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
17959   void * jresult ;
17960   Dali::BaseHandle arg1 ;
17961   Dali::BaseHandle *argp1 ;
17962   Dali::Shader result;
17963
17964   argp1 = (Dali::BaseHandle *)jarg1;
17965   if (!argp1) {
17966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17967     return 0;
17968   }
17969   arg1 = *argp1;
17970   {
17971     try {
17972       result = Dali::Shader::DownCast(arg1);
17973     } CALL_CATCH_EXCEPTION(0);
17974   }
17975
17976   jresult = new Dali::Shader((const Dali::Shader &)result);
17977   return jresult;
17978 }
17979
17980
17981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
17982   void * jresult ;
17983   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
17984   Dali::Shader *arg2 = 0 ;
17985   Dali::Shader *result = 0 ;
17986
17987   arg1 = (Dali::Shader *)jarg1;
17988   arg2 = (Dali::Shader *)jarg2;
17989   if (!arg2) {
17990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
17991     return 0;
17992   }
17993   {
17994     try {
17995       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
17996     } CALL_CATCH_EXCEPTION(0);
17997   }
17998
17999   jresult = (void *)result;
18000   return jresult;
18001 }
18002
18003
18004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
18005   int jresult ;
18006   int result;
18007
18008   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
18009   jresult = (int)result;
18010   return jresult;
18011 }
18012
18013
18014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
18015   int jresult ;
18016   int result;
18017
18018   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
18019   jresult = (int)result;
18020   return jresult;
18021 }
18022
18023
18024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
18025   int jresult ;
18026   int result;
18027
18028   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
18029   jresult = (int)result;
18030   return jresult;
18031 }
18032
18033
18034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
18035   int jresult ;
18036   int result;
18037
18038   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
18039   jresult = (int)result;
18040   return jresult;
18041 }
18042
18043
18044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
18045   int jresult ;
18046   int result;
18047
18048   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
18049   jresult = (int)result;
18050   return jresult;
18051 }
18052
18053
18054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
18055   int jresult ;
18056   int result;
18057
18058   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
18059   jresult = (int)result;
18060   return jresult;
18061 }
18062
18063
18064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
18065   int jresult ;
18066   int result;
18067
18068   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
18069   jresult = (int)result;
18070   return jresult;
18071 }
18072
18073
18074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
18075   int jresult ;
18076   int result;
18077
18078   result = (int)Dali::Renderer::Property::BLEND_MODE;
18079   jresult = (int)result;
18080   return jresult;
18081 }
18082
18083
18084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
18085   int jresult ;
18086   int result;
18087
18088   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
18089   jresult = (int)result;
18090   return jresult;
18091 }
18092
18093
18094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
18095   int jresult ;
18096   int result;
18097
18098   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
18099   jresult = (int)result;
18100   return jresult;
18101 }
18102
18103
18104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
18105   int jresult ;
18106   int result;
18107
18108   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
18109   jresult = (int)result;
18110   return jresult;
18111 }
18112
18113
18114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
18115   int jresult ;
18116   int result;
18117
18118   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
18119   jresult = (int)result;
18120   return jresult;
18121 }
18122
18123
18124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
18125   int jresult ;
18126   int result;
18127
18128   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
18129   jresult = (int)result;
18130   return jresult;
18131 }
18132
18133
18134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
18135   int jresult ;
18136   int result;
18137
18138   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
18139   jresult = (int)result;
18140   return jresult;
18141 }
18142
18143
18144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
18145   int jresult ;
18146   int result;
18147
18148   result = (int)Dali::Renderer::Property::BLEND_COLOR;
18149   jresult = (int)result;
18150   return jresult;
18151 }
18152
18153
18154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
18155   int jresult ;
18156   int result;
18157
18158   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
18159   jresult = (int)result;
18160   return jresult;
18161 }
18162
18163
18164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
18165   int jresult ;
18166   int result;
18167
18168   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
18169   jresult = (int)result;
18170   return jresult;
18171 }
18172
18173
18174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
18175   int jresult ;
18176   int result;
18177
18178   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
18179   jresult = (int)result;
18180   return jresult;
18181 }
18182
18183
18184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
18185   int jresult ;
18186   int result;
18187
18188   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
18189   jresult = (int)result;
18190   return jresult;
18191 }
18192
18193
18194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
18195   int jresult ;
18196   int result;
18197
18198   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
18199   jresult = (int)result;
18200   return jresult;
18201 }
18202
18203
18204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
18205   int jresult ;
18206   int result;
18207
18208   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
18209   jresult = (int)result;
18210   return jresult;
18211 }
18212
18213
18214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
18215   int jresult ;
18216   int result;
18217
18218   result = (int)Dali::Renderer::Property::RENDER_MODE;
18219   jresult = (int)result;
18220   return jresult;
18221 }
18222
18223
18224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
18225   int jresult ;
18226   int result;
18227
18228   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
18229   jresult = (int)result;
18230   return jresult;
18231 }
18232
18233
18234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
18235   int jresult ;
18236   int result;
18237
18238   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
18239   jresult = (int)result;
18240   return jresult;
18241 }
18242
18243
18244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
18245   int jresult ;
18246   int result;
18247
18248   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
18249   jresult = (int)result;
18250   return jresult;
18251 }
18252
18253
18254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
18255   int jresult ;
18256   int result;
18257
18258   result = (int)Dali::Renderer::Property::STENCIL_MASK;
18259   jresult = (int)result;
18260   return jresult;
18261 }
18262
18263
18264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
18265   int jresult ;
18266   int result;
18267
18268   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
18269   jresult = (int)result;
18270   return jresult;
18271 }
18272
18273
18274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
18275   int jresult ;
18276   int result;
18277
18278   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
18279   jresult = (int)result;
18280   return jresult;
18281 }
18282
18283
18284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
18285   int jresult ;
18286   int result;
18287
18288   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
18289   jresult = (int)result;
18290   return jresult;
18291 }
18292
18293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CULLED_get() {
18294   return Dali::Actor::Property::CULLED;
18295 }
18296
18297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
18298   void * jresult ;
18299   Dali::Renderer::Property *result = 0 ;
18300
18301   {
18302     try {
18303       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
18304     } CALL_CATCH_EXCEPTION(0);
18305   }
18306
18307   jresult = (void *)result;
18308   return jresult;
18309 }
18310
18311
18312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
18313   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
18314
18315   arg1 = (Dali::Renderer::Property *)jarg1;
18316   {
18317     try {
18318       delete arg1;
18319     } CALL_CATCH_EXCEPTION();
18320   }
18321
18322 }
18323
18324
18325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
18326   void * jresult ;
18327   Dali::Geometry *arg1 = 0 ;
18328   Dali::Shader *arg2 = 0 ;
18329   Dali::Renderer result;
18330
18331   arg1 = (Dali::Geometry *)jarg1;
18332   if (!arg1) {
18333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
18334     return 0;
18335   }
18336   arg2 = (Dali::Shader *)jarg2;
18337   if (!arg2) {
18338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
18339     return 0;
18340   }
18341   {
18342     try {
18343       result = Dali::Renderer::New(*arg1,*arg2);
18344     } CALL_CATCH_EXCEPTION(0);
18345   }
18346
18347   jresult = new Dali::Renderer((const Dali::Renderer &)result);
18348   return jresult;
18349 }
18350
18351
18352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
18353   void * jresult ;
18354   Dali::Renderer *result = 0 ;
18355
18356   {
18357     try {
18358       result = (Dali::Renderer *)new Dali::Renderer();
18359     } CALL_CATCH_EXCEPTION(0);
18360   }
18361
18362   jresult = (void *)result;
18363   return jresult;
18364 }
18365
18366
18367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
18368   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
18369
18370   arg1 = (Dali::Renderer *)jarg1;
18371   {
18372     try {
18373       delete arg1;
18374     } CALL_CATCH_EXCEPTION();
18375   }
18376
18377 }
18378
18379
18380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
18381   void * jresult ;
18382   Dali::Renderer *arg1 = 0 ;
18383   Dali::Renderer *result = 0 ;
18384
18385   arg1 = (Dali::Renderer *)jarg1;
18386   if (!arg1) {
18387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
18388     return 0;
18389   }
18390   {
18391     try {
18392       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
18393     } CALL_CATCH_EXCEPTION(0);
18394   }
18395
18396   jresult = (void *)result;
18397   return jresult;
18398 }
18399
18400
18401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
18402   void * jresult ;
18403   Dali::BaseHandle arg1 ;
18404   Dali::BaseHandle *argp1 ;
18405   Dali::Renderer result;
18406
18407   argp1 = (Dali::BaseHandle *)jarg1;
18408   if (!argp1) {
18409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
18410     return 0;
18411   }
18412   arg1 = *argp1;
18413   {
18414     try {
18415       result = Dali::Renderer::DownCast(arg1);
18416     } CALL_CATCH_EXCEPTION(0);
18417   }
18418
18419   jresult = new Dali::Renderer((const Dali::Renderer &)result);
18420   return jresult;
18421 }
18422
18423
18424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
18425   void * jresult ;
18426   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
18427   Dali::Renderer *arg2 = 0 ;
18428   Dali::Renderer *result = 0 ;
18429
18430   arg1 = (Dali::Renderer *)jarg1;
18431   arg2 = (Dali::Renderer *)jarg2;
18432   if (!arg2) {
18433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
18434     return 0;
18435   }
18436   {
18437     try {
18438       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
18439     } CALL_CATCH_EXCEPTION(0);
18440   }
18441
18442   jresult = (void *)result;
18443   return jresult;
18444 }
18445
18446
18447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
18448   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
18449   Dali::Geometry *arg2 = 0 ;
18450
18451   arg1 = (Dali::Renderer *)jarg1;
18452   arg2 = (Dali::Geometry *)jarg2;
18453   if (!arg2) {
18454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
18455     return ;
18456   }
18457   {
18458     try {
18459       (arg1)->SetGeometry(*arg2);
18460     } CALL_CATCH_EXCEPTION();
18461   }
18462
18463 }
18464
18465
18466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
18467   void * jresult ;
18468   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
18469   Dali::Geometry result;
18470
18471   arg1 = (Dali::Renderer *)jarg1;
18472   {
18473     try {
18474       result = ((Dali::Renderer const *)arg1)->GetGeometry();
18475     } CALL_CATCH_EXCEPTION(0);
18476   }
18477
18478   jresult = new Dali::Geometry((const Dali::Geometry &)result);
18479   return jresult;
18480 }
18481
18482
18483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
18484   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
18485   int arg2 ;
18486   int arg3 ;
18487
18488   arg1 = (Dali::Renderer *)jarg1;
18489   arg2 = (int)jarg2;
18490   arg3 = (int)jarg3;
18491   {
18492     try {
18493       (arg1)->SetIndexRange(arg2,arg3);
18494     } CALL_CATCH_EXCEPTION();
18495   }
18496
18497 }
18498
18499
18500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
18501   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
18502   Dali::TextureSet *arg2 = 0 ;
18503
18504   arg1 = (Dali::Renderer *)jarg1;
18505   arg2 = (Dali::TextureSet *)jarg2;
18506   if (!arg2) {
18507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
18508     return ;
18509   }
18510   {
18511     try {
18512       (arg1)->SetTextures(*arg2);
18513     } CALL_CATCH_EXCEPTION();
18514   }
18515
18516 }
18517
18518
18519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
18520   void * jresult ;
18521   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
18522   Dali::TextureSet result;
18523
18524   arg1 = (Dali::Renderer *)jarg1;
18525   {
18526     try {
18527       result = ((Dali::Renderer const *)arg1)->GetTextures();
18528     } CALL_CATCH_EXCEPTION(0);
18529   }
18530
18531   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
18532   return jresult;
18533 }
18534
18535
18536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
18537   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
18538   Dali::Shader *arg2 = 0 ;
18539
18540   arg1 = (Dali::Renderer *)jarg1;
18541   arg2 = (Dali::Shader *)jarg2;
18542   if (!arg2) {
18543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
18544     return ;
18545   }
18546   {
18547     try {
18548       (arg1)->SetShader(*arg2);
18549     } CALL_CATCH_EXCEPTION();
18550   }
18551
18552 }
18553
18554
18555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
18556   void * jresult ;
18557   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
18558   Dali::Shader result;
18559
18560   arg1 = (Dali::Renderer *)jarg1;
18561   {
18562     try {
18563       result = ((Dali::Renderer const *)arg1)->GetShader();
18564     } CALL_CATCH_EXCEPTION(0);
18565   }
18566
18567   jresult = new Dali::Shader((const Dali::Shader &)result);
18568   return jresult;
18569 }
18570
18571
18572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
18573   void * jresult ;
18574   Dali::FrameBuffer::Attachment *result = 0 ;
18575
18576   {
18577     try {
18578       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
18579     } CALL_CATCH_EXCEPTION(0);
18580   }
18581
18582   jresult = (void *)result;
18583   return jresult;
18584 }
18585
18586
18587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
18588   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
18589
18590   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
18591   {
18592     try {
18593       delete arg1;
18594     } CALL_CATCH_EXCEPTION();
18595   }
18596
18597 }
18598
18599
18600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
18601   void * jresult ;
18602   unsigned int arg1 ;
18603   unsigned int arg2 ;
18604   unsigned int arg3 ;
18605   Dali::FrameBuffer result;
18606
18607   arg1 = (unsigned int)jarg1;
18608   arg2 = (unsigned int)jarg2;
18609   arg3 = (unsigned int)jarg3;
18610   {
18611     try {
18612       result = Dali::FrameBuffer::New(arg1,arg2,static_cast<Dali::FrameBuffer::Attachment::Mask>(arg3));
18613     } CALL_CATCH_EXCEPTION(0);
18614   }
18615
18616   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
18617   return jresult;
18618 }
18619
18620
18621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
18622   void * jresult ;
18623   Dali::FrameBuffer *result = 0 ;
18624
18625   {
18626     try {
18627       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
18628     } CALL_CATCH_EXCEPTION(0);
18629   }
18630
18631   jresult = (void *)result;
18632   return jresult;
18633 }
18634
18635
18636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
18637   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
18638
18639   arg1 = (Dali::FrameBuffer *)jarg1;
18640   {
18641     try {
18642       delete arg1;
18643     } CALL_CATCH_EXCEPTION();
18644   }
18645
18646 }
18647
18648
18649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
18650   void * jresult ;
18651   Dali::FrameBuffer *arg1 = 0 ;
18652   Dali::FrameBuffer *result = 0 ;
18653
18654   arg1 = (Dali::FrameBuffer *)jarg1;
18655   if (!arg1) {
18656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
18657     return 0;
18658   }
18659   {
18660     try {
18661       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
18662     } CALL_CATCH_EXCEPTION(0);
18663   }
18664
18665   jresult = (void *)result;
18666   return jresult;
18667 }
18668
18669
18670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
18671   void * jresult ;
18672   Dali::BaseHandle arg1 ;
18673   Dali::BaseHandle *argp1 ;
18674   Dali::FrameBuffer result;
18675
18676   argp1 = (Dali::BaseHandle *)jarg1;
18677   if (!argp1) {
18678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
18679     return 0;
18680   }
18681   arg1 = *argp1;
18682   {
18683     try {
18684       result = Dali::FrameBuffer::DownCast(arg1);
18685     } CALL_CATCH_EXCEPTION(0);
18686   }
18687
18688   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
18689   return jresult;
18690 }
18691
18692
18693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
18694   void * jresult ;
18695   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
18696   Dali::FrameBuffer *arg2 = 0 ;
18697   Dali::FrameBuffer *result = 0 ;
18698
18699   arg1 = (Dali::FrameBuffer *)jarg1;
18700   arg2 = (Dali::FrameBuffer *)jarg2;
18701   if (!arg2) {
18702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
18703     return 0;
18704   }
18705   {
18706     try {
18707       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
18708     } CALL_CATCH_EXCEPTION(0);
18709   }
18710
18711   jresult = (void *)result;
18712   return jresult;
18713 }
18714
18715
18716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
18717   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
18718   Dali::Texture *arg2 = 0 ;
18719
18720   arg1 = (Dali::FrameBuffer *)jarg1;
18721   arg2 = (Dali::Texture *)jarg2;
18722   if (!arg2) {
18723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
18724     return ;
18725   }
18726   {
18727     try {
18728       (arg1)->AttachColorTexture(*arg2);
18729     } CALL_CATCH_EXCEPTION();
18730   }
18731
18732 }
18733
18734
18735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
18736   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
18737   Dali::Texture *arg2 = 0 ;
18738   unsigned int arg3 ;
18739   unsigned int arg4 ;
18740
18741   arg1 = (Dali::FrameBuffer *)jarg1;
18742   arg2 = (Dali::Texture *)jarg2;
18743   if (!arg2) {
18744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
18745     return ;
18746   }
18747   arg3 = (unsigned int)jarg3;
18748   arg4 = (unsigned int)jarg4;
18749   {
18750     try {
18751       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
18752     } CALL_CATCH_EXCEPTION();
18753   }
18754
18755 }
18756
18757
18758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
18759   void * jresult ;
18760   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
18761   Dali::Texture result;
18762
18763   arg1 = (Dali::FrameBuffer *)jarg1;
18764   {
18765     try {
18766       result = (arg1)->GetColorTexture();
18767     } CALL_CATCH_EXCEPTION(0);
18768   }
18769
18770   jresult = new Dali::Texture((const Dali::Texture &)result);
18771   return jresult;
18772 }
18773
18774 SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_FrameBuffer_GenerateUrl(void *jFrameBuffer, int pixelFormat, int width, int height)
18775 {
18776   void *jresult;
18777   Dali::Toolkit::ImageUrl result;
18778   Dali::FrameBuffer *frameBuffer = (Dali::FrameBuffer*)jFrameBuffer;;
18779
18780   if (!frameBuffer)
18781   {
18782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer is null", 0);
18783     return 0;
18784   }
18785   {
18786     try
18787     {
18788       result = Dali::Toolkit::Image::GenerateUrl((const Dali::FrameBuffer&)*frameBuffer, (Pixel::Format)pixelFormat, (uint32_t)width, (uint32_t)height);
18789     }
18790     CALL_CATCH_EXCEPTION(0);
18791   }
18792
18793   jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl &)result);
18794   return jresult;
18795 }
18796
18797
18798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
18799   void * jresult ;
18800   Dali::RenderTaskList *result = 0 ;
18801
18802   {
18803     try {
18804       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
18805     } CALL_CATCH_EXCEPTION(0);
18806   }
18807
18808   jresult = (void *)result;
18809   return jresult;
18810 }
18811
18812
18813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
18814   void * jresult ;
18815   Dali::BaseHandle arg1 ;
18816   Dali::BaseHandle *argp1 ;
18817   Dali::RenderTaskList result;
18818
18819   argp1 = (Dali::BaseHandle *)jarg1;
18820   if (!argp1) {
18821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
18822     return 0;
18823   }
18824   arg1 = *argp1;
18825   {
18826     try {
18827       result = Dali::RenderTaskList::DownCast(arg1);
18828     } CALL_CATCH_EXCEPTION(0);
18829   }
18830
18831   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
18832   return jresult;
18833 }
18834
18835
18836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
18837   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
18838
18839   arg1 = (Dali::RenderTaskList *)jarg1;
18840   {
18841     try {
18842       delete arg1;
18843     } CALL_CATCH_EXCEPTION();
18844   }
18845
18846 }
18847
18848
18849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
18850   void * jresult ;
18851   Dali::RenderTaskList *arg1 = 0 ;
18852   Dali::RenderTaskList *result = 0 ;
18853
18854   arg1 = (Dali::RenderTaskList *)jarg1;
18855   if (!arg1) {
18856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
18857     return 0;
18858   }
18859   {
18860     try {
18861       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
18862     } CALL_CATCH_EXCEPTION(0);
18863   }
18864
18865   jresult = (void *)result;
18866   return jresult;
18867 }
18868
18869
18870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
18871   void * jresult ;
18872   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
18873   Dali::RenderTaskList *arg2 = 0 ;
18874   Dali::RenderTaskList *result = 0 ;
18875
18876   arg1 = (Dali::RenderTaskList *)jarg1;
18877   arg2 = (Dali::RenderTaskList *)jarg2;
18878   if (!arg2) {
18879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
18880     return 0;
18881   }
18882   {
18883     try {
18884       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
18885     } CALL_CATCH_EXCEPTION(0);
18886   }
18887
18888   jresult = (void *)result;
18889   return jresult;
18890 }
18891
18892
18893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
18894   void * jresult ;
18895   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
18896   Dali::RenderTask result;
18897
18898   arg1 = (Dali::RenderTaskList *)jarg1;
18899   {
18900     try {
18901       result = (arg1)->CreateTask();
18902     } CALL_CATCH_EXCEPTION(0);
18903   }
18904
18905   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
18906   return jresult;
18907 }
18908
18909
18910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
18911   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
18912   Dali::RenderTask arg2 ;
18913   Dali::RenderTask *argp2 ;
18914
18915   arg1 = (Dali::RenderTaskList *)jarg1;
18916   argp2 = (Dali::RenderTask *)jarg2;
18917   if (!argp2) {
18918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
18919     return ;
18920   }
18921   arg2 = *argp2;
18922   {
18923     try {
18924       (arg1)->RemoveTask(arg2);
18925     } CALL_CATCH_EXCEPTION();
18926   }
18927
18928 }
18929
18930
18931 //// ===============================================end part 1 =================
18932
18933 //// ========================= part 2 ===============================
18934
18935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
18936   unsigned int jresult ;
18937   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
18938   unsigned int result;
18939
18940   arg1 = (Dali::RenderTaskList *)jarg1;
18941   {
18942     try {
18943       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
18944     } CALL_CATCH_EXCEPTION(0);
18945   }
18946
18947   jresult = result;
18948   return jresult;
18949 }
18950
18951
18952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
18953   void * jresult ;
18954   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
18955   unsigned int arg2 ;
18956   Dali::RenderTask result;
18957
18958   arg1 = (Dali::RenderTaskList *)jarg1;
18959   arg2 = (unsigned int)jarg2;
18960   {
18961     try {
18962       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
18963     } CALL_CATCH_EXCEPTION(0);
18964   }
18965
18966   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
18967   return jresult;
18968 }
18969
18970
18971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
18972   int jresult ;
18973   int result;
18974
18975   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
18976   jresult = (int)result;
18977   return jresult;
18978 }
18979
18980
18981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
18982   int jresult ;
18983   int result;
18984
18985   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
18986   jresult = (int)result;
18987   return jresult;
18988 }
18989
18990
18991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
18992   int jresult ;
18993   int result;
18994
18995   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
18996   jresult = (int)result;
18997   return jresult;
18998 }
18999
19000
19001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
19002   int jresult ;
19003   int result;
19004
19005   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
19006   jresult = (int)result;
19007   return jresult;
19008 }
19009
19010
19011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
19012   void * jresult ;
19013   Dali::RenderTask::Property *result = 0 ;
19014
19015   {
19016     try {
19017       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
19018     } CALL_CATCH_EXCEPTION(0);
19019   }
19020
19021   jresult = (void *)result;
19022   return jresult;
19023 }
19024
19025
19026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
19027   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
19028
19029   arg1 = (Dali::RenderTask::Property *)jarg1;
19030   {
19031     try {
19032       delete arg1;
19033     } CALL_CATCH_EXCEPTION();
19034   }
19035
19036 }
19037
19038
19039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
19040   void * jresult ;
19041   bool (*result)(Dali::Vector2 &) = 0 ;
19042
19043   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
19044   jresult = (void *)result;
19045   return jresult;
19046 }
19047
19048
19049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
19050   void * jresult ;
19051   bool (*result)(Dali::Vector2 &) = 0 ;
19052
19053   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
19054   jresult = (void *)result;
19055   return jresult;
19056 }
19057
19058
19059 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
19060   bool jresult ;
19061   bool result;
19062
19063   result = (bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
19064   jresult = result;
19065   return jresult;
19066 }
19067
19068
19069 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
19070   bool jresult ;
19071   bool result;
19072
19073   result = (bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
19074   jresult = result;
19075   return jresult;
19076 }
19077
19078
19079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
19080   void * jresult ;
19081   Dali::Vector4 *result = 0 ;
19082
19083   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
19084   jresult = (void *)result;
19085   return jresult;
19086 }
19087
19088
19089 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
19090   bool jresult ;
19091   bool result;
19092
19093   result = (bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
19094   jresult = result;
19095   return jresult;
19096 }
19097
19098
19099 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
19100   bool jresult ;
19101   bool result;
19102
19103   result = (bool)Dali::RenderTask::DEFAULT_CULL_MODE;
19104   jresult = result;
19105   return jresult;
19106 }
19107
19108
19109 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
19110   unsigned int jresult ;
19111   unsigned int result;
19112
19113   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
19114   jresult = result;
19115   return jresult;
19116 }
19117
19118
19119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
19120   void * jresult ;
19121   Dali::RenderTask *result = 0 ;
19122
19123   {
19124     try {
19125       result = (Dali::RenderTask *)new Dali::RenderTask();
19126     } CALL_CATCH_EXCEPTION(0);
19127   }
19128
19129   jresult = (void *)result;
19130   return jresult;
19131 }
19132
19133
19134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
19135   void * jresult ;
19136   Dali::BaseHandle arg1 ;
19137   Dali::BaseHandle *argp1 ;
19138   Dali::RenderTask result;
19139
19140   argp1 = (Dali::BaseHandle *)jarg1;
19141   if (!argp1) {
19142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19143     return 0;
19144   }
19145   arg1 = *argp1;
19146   {
19147     try {
19148       result = Dali::RenderTask::DownCast(arg1);
19149     } CALL_CATCH_EXCEPTION(0);
19150   }
19151
19152   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
19153   return jresult;
19154 }
19155
19156
19157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
19158   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19159
19160   arg1 = (Dali::RenderTask *)jarg1;
19161   {
19162     try {
19163       delete arg1;
19164     } CALL_CATCH_EXCEPTION();
19165   }
19166
19167 }
19168
19169
19170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
19171   void * jresult ;
19172   Dali::RenderTask *arg1 = 0 ;
19173   Dali::RenderTask *result = 0 ;
19174
19175   arg1 = (Dali::RenderTask *)jarg1;
19176   if (!arg1) {
19177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
19178     return 0;
19179   }
19180   {
19181     try {
19182       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
19183     } CALL_CATCH_EXCEPTION(0);
19184   }
19185
19186   jresult = (void *)result;
19187   return jresult;
19188 }
19189
19190
19191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
19192   void * jresult ;
19193   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19194   Dali::RenderTask *arg2 = 0 ;
19195   Dali::RenderTask *result = 0 ;
19196
19197   arg1 = (Dali::RenderTask *)jarg1;
19198   arg2 = (Dali::RenderTask *)jarg2;
19199   if (!arg2) {
19200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
19201     return 0;
19202   }
19203   {
19204     try {
19205       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
19206     } CALL_CATCH_EXCEPTION(0);
19207   }
19208
19209   jresult = (void *)result;
19210   return jresult;
19211 }
19212
19213
19214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
19215   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19216   Dali::Actor arg2 ;
19217   Dali::Actor *argp2 ;
19218
19219   arg1 = (Dali::RenderTask *)jarg1;
19220   argp2 = (Dali::Actor *)jarg2;
19221   if (!argp2) {
19222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
19223     return ;
19224   }
19225   arg2 = *argp2;
19226   {
19227     try {
19228       (arg1)->SetSourceActor(arg2);
19229     } CALL_CATCH_EXCEPTION();
19230   }
19231
19232 }
19233
19234
19235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
19236   void * jresult ;
19237   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19238   Dali::Actor result;
19239
19240   arg1 = (Dali::RenderTask *)jarg1;
19241   {
19242     try {
19243       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
19244     } CALL_CATCH_EXCEPTION(0);
19245   }
19246
19247   jresult = new Dali::Actor((const Dali::Actor &)result);
19248   return jresult;
19249 }
19250
19251
19252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, bool jarg2) {
19253   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19254   bool arg2 ;
19255
19256   arg1 = (Dali::RenderTask *)jarg1;
19257   arg2 = jarg2 ? true : false;
19258   {
19259     try {
19260       (arg1)->SetExclusive(arg2);
19261     } CALL_CATCH_EXCEPTION();
19262   }
19263
19264 }
19265
19266
19267 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
19268   bool jresult ;
19269   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19270   bool result;
19271
19272   arg1 = (Dali::RenderTask *)jarg1;
19273   {
19274     try {
19275       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
19276     } CALL_CATCH_EXCEPTION(0);
19277   }
19278
19279   jresult = result;
19280   return jresult;
19281 }
19282
19283
19284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, bool jarg2) {
19285   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19286   bool arg2 ;
19287
19288   arg1 = (Dali::RenderTask *)jarg1;
19289   arg2 = jarg2 ? true : false;
19290   {
19291     try {
19292       (arg1)->SetInputEnabled(arg2);
19293     } CALL_CATCH_EXCEPTION();
19294   }
19295
19296 }
19297
19298
19299 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
19300   bool jresult ;
19301   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19302   bool result;
19303
19304   arg1 = (Dali::RenderTask *)jarg1;
19305   {
19306     try {
19307       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
19308     } CALL_CATCH_EXCEPTION(0);
19309   }
19310
19311   jresult = result;
19312   return jresult;
19313 }
19314
19315
19316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
19317   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19318   Dali::CameraActor arg2 ;
19319   Dali::CameraActor *argp2 ;
19320
19321   arg1 = (Dali::RenderTask *)jarg1;
19322   argp2 = (Dali::CameraActor *)jarg2;
19323   if (!argp2) {
19324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
19325     return ;
19326   }
19327   arg2 = *argp2;
19328   {
19329     try {
19330       (arg1)->SetCameraActor(arg2);
19331     } CALL_CATCH_EXCEPTION();
19332   }
19333
19334 }
19335
19336
19337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
19338   void * jresult ;
19339   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19340   Dali::CameraActor result;
19341
19342   arg1 = (Dali::RenderTask *)jarg1;
19343   {
19344     try {
19345       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
19346     } CALL_CATCH_EXCEPTION(0);
19347   }
19348
19349   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
19350   return jresult;
19351 }
19352
19353
19354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
19355   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19356   Dali::FrameBuffer arg2 ;
19357   Dali::FrameBuffer *argp2 ;
19358
19359   arg1 = (Dali::RenderTask *)jarg1;
19360   argp2 = (Dali::FrameBuffer *)jarg2;
19361   if (!argp2) {
19362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
19363     return ;
19364   }
19365   arg2 = *argp2;
19366   {
19367     try {
19368       (arg1)->SetFrameBuffer(arg2);
19369     } CALL_CATCH_EXCEPTION();
19370   }
19371
19372 }
19373
19374
19375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
19376   void * jresult ;
19377   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19378   Dali::FrameBuffer result;
19379
19380   arg1 = (Dali::RenderTask *)jarg1;
19381   {
19382     try {
19383       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
19384     } CALL_CATCH_EXCEPTION(0);
19385   }
19386
19387   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
19388   return jresult;
19389 }
19390
19391
19392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
19393   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19394   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
19395
19396   arg1 = (Dali::RenderTask *)jarg1;
19397   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
19398   {
19399     try {
19400       (arg1)->SetScreenToFrameBufferFunction(arg2);
19401     } CALL_CATCH_EXCEPTION();
19402   }
19403
19404 }
19405
19406
19407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
19408   void * jresult ;
19409   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19410   Dali::RenderTask::ScreenToFrameBufferFunction result;
19411
19412   arg1 = (Dali::RenderTask *)jarg1;
19413   {
19414     try {
19415       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
19416     } CALL_CATCH_EXCEPTION(0);
19417   }
19418
19419   jresult = (void *)result;
19420   return jresult;
19421 }
19422
19423
19424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
19425   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19426   Dali::Actor arg2 ;
19427   Dali::Actor *argp2 ;
19428
19429   arg1 = (Dali::RenderTask *)jarg1;
19430   argp2 = (Dali::Actor *)jarg2;
19431   if (!argp2) {
19432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
19433     return ;
19434   }
19435   arg2 = *argp2;
19436   {
19437     try {
19438       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
19439     } CALL_CATCH_EXCEPTION();
19440   }
19441
19442 }
19443
19444
19445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
19446   void * jresult ;
19447   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19448   Dali::Actor result;
19449
19450   arg1 = (Dali::RenderTask *)jarg1;
19451   {
19452     try {
19453       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
19454     } CALL_CATCH_EXCEPTION(0);
19455   }
19456
19457   jresult = new Dali::Actor((const Dali::Actor &)result);
19458   return jresult;
19459 }
19460
19461
19462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
19463   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19464   Dali::Vector2 arg2 ;
19465   Dali::Vector2 *argp2 ;
19466
19467   arg1 = (Dali::RenderTask *)jarg1;
19468   argp2 = (Dali::Vector2 *)jarg2;
19469   if (!argp2) {
19470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
19471     return ;
19472   }
19473   arg2 = *argp2;
19474   {
19475     try {
19476       (arg1)->SetViewportPosition(arg2);
19477     } CALL_CATCH_EXCEPTION();
19478   }
19479
19480 }
19481
19482
19483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
19484   void * jresult ;
19485   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19486   Dali::Vector2 result;
19487
19488   arg1 = (Dali::RenderTask *)jarg1;
19489   {
19490     try {
19491       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
19492     } CALL_CATCH_EXCEPTION(0);
19493   }
19494
19495   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
19496   return jresult;
19497 }
19498
19499
19500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
19501   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19502   Dali::Vector2 arg2 ;
19503   Dali::Vector2 *argp2 ;
19504
19505   arg1 = (Dali::RenderTask *)jarg1;
19506   argp2 = (Dali::Vector2 *)jarg2;
19507   if (!argp2) {
19508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
19509     return ;
19510   }
19511   arg2 = *argp2;
19512   {
19513     try {
19514       (arg1)->SetViewportSize(arg2);
19515     } CALL_CATCH_EXCEPTION();
19516   }
19517
19518 }
19519
19520
19521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
19522   void * jresult ;
19523   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19524   Dali::Vector2 result;
19525
19526   arg1 = (Dali::RenderTask *)jarg1;
19527   {
19528     try {
19529       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
19530     } CALL_CATCH_EXCEPTION(0);
19531   }
19532
19533   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
19534   return jresult;
19535 }
19536
19537
19538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
19539   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19540   Dali::Viewport arg2 ;
19541   Dali::Viewport *argp2 ;
19542
19543   arg1 = (Dali::RenderTask *)jarg1;
19544   argp2 = (Dali::Viewport *)jarg2;
19545   if (!argp2) {
19546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
19547     return ;
19548   }
19549   arg2 = *argp2;
19550   {
19551     try {
19552       (arg1)->SetViewport(arg2);
19553     } CALL_CATCH_EXCEPTION();
19554   }
19555
19556 }
19557
19558
19559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
19560   void * jresult ;
19561   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19562   Dali::Viewport result;
19563
19564   arg1 = (Dali::RenderTask *)jarg1;
19565   {
19566     try {
19567       result = ((Dali::RenderTask const *)arg1)->GetViewport();
19568     } CALL_CATCH_EXCEPTION(0);
19569   }
19570
19571   jresult = new Dali::Viewport((const Dali::Viewport &)result);
19572   return jresult;
19573 }
19574
19575
19576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
19577   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19578   Dali::Vector4 *arg2 = 0 ;
19579
19580   arg1 = (Dali::RenderTask *)jarg1;
19581   arg2 = (Dali::Vector4 *)jarg2;
19582   if (!arg2) {
19583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
19584     return ;
19585   }
19586   {
19587     try {
19588       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
19589     } CALL_CATCH_EXCEPTION();
19590   }
19591
19592 }
19593
19594
19595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
19596   void * jresult ;
19597   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19598   Dali::Vector4 result;
19599
19600   arg1 = (Dali::RenderTask *)jarg1;
19601   {
19602     try {
19603       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
19604     } CALL_CATCH_EXCEPTION(0);
19605   }
19606
19607   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
19608   return jresult;
19609 }
19610
19611
19612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, bool jarg2) {
19613   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19614   bool arg2 ;
19615
19616   arg1 = (Dali::RenderTask *)jarg1;
19617   arg2 = jarg2 ? true : false;
19618   {
19619     try {
19620       (arg1)->SetClearEnabled(arg2);
19621     } CALL_CATCH_EXCEPTION();
19622   }
19623
19624 }
19625
19626
19627 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
19628   bool jresult ;
19629   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19630   bool result;
19631
19632   arg1 = (Dali::RenderTask *)jarg1;
19633   {
19634     try {
19635       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
19636     } CALL_CATCH_EXCEPTION(0);
19637   }
19638
19639   jresult = result;
19640   return jresult;
19641 }
19642
19643
19644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, bool jarg2) {
19645   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19646   bool arg2 ;
19647
19648   arg1 = (Dali::RenderTask *)jarg1;
19649   arg2 = jarg2 ? true : false;
19650   {
19651     try {
19652       (arg1)->SetCullMode(arg2);
19653     } CALL_CATCH_EXCEPTION();
19654   }
19655
19656 }
19657
19658
19659 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
19660   bool jresult ;
19661   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19662   bool result;
19663
19664   arg1 = (Dali::RenderTask *)jarg1;
19665   {
19666     try {
19667       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
19668     } CALL_CATCH_EXCEPTION(0);
19669   }
19670
19671   jresult = result;
19672   return jresult;
19673 }
19674
19675
19676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
19677   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19678   unsigned int arg2 ;
19679
19680   arg1 = (Dali::RenderTask *)jarg1;
19681   arg2 = (unsigned int)jarg2;
19682   {
19683     try {
19684       (arg1)->SetRefreshRate(arg2);
19685     } CALL_CATCH_EXCEPTION();
19686   }
19687
19688 }
19689
19690
19691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
19692   unsigned int jresult ;
19693   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19694   unsigned int result;
19695
19696   arg1 = (Dali::RenderTask *)jarg1;
19697   {
19698     try {
19699       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
19700     } CALL_CATCH_EXCEPTION(0);
19701   }
19702
19703   jresult = result;
19704   return jresult;
19705 }
19706
19707
19708 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
19709   bool jresult ;
19710   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19711   Dali::Vector3 *arg2 = 0 ;
19712   float *arg3 = 0 ;
19713   float *arg4 = 0 ;
19714   bool result;
19715
19716   arg1 = (Dali::RenderTask *)jarg1;
19717   arg2 = (Dali::Vector3 *)jarg2;
19718   if (!arg2) {
19719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
19720     return 0;
19721   }
19722   arg3 = (float *)jarg3;
19723   arg4 = (float *)jarg4;
19724   {
19725     try {
19726       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
19727     } CALL_CATCH_EXCEPTION(0);
19728   }
19729
19730   jresult = result;
19731   return jresult;
19732 }
19733
19734
19735 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
19736   bool jresult ;
19737   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19738   Dali::Actor arg2 ;
19739   float arg3 ;
19740   float arg4 ;
19741   float *arg5 = 0 ;
19742   float *arg6 = 0 ;
19743   Dali::Actor *argp2 ;
19744   bool result;
19745
19746   arg1 = (Dali::RenderTask *)jarg1;
19747   argp2 = (Dali::Actor *)jarg2;
19748   if (!argp2) {
19749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
19750     return 0;
19751   }
19752   arg2 = *argp2;
19753   arg3 = (float)jarg3;
19754   arg4 = (float)jarg4;
19755   arg5 = (float *)jarg5;
19756   arg6 = (float *)jarg6;
19757   {
19758     try {
19759       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
19760     } CALL_CATCH_EXCEPTION(0);
19761   }
19762
19763   jresult = result;
19764   return jresult;
19765 }
19766
19767
19768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
19769   void * jresult ;
19770   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19771   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
19772
19773   arg1 = (Dali::RenderTask *)jarg1;
19774   {
19775     try {
19776       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
19777     } CALL_CATCH_EXCEPTION(0);
19778   }
19779
19780   jresult = (void *)result;
19781   return jresult;
19782 }
19783
19784
19785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
19786   void * jresult ;
19787   int arg1 ;
19788   Dali::PointState::Type arg2 ;
19789   float arg3 ;
19790   float arg4 ;
19791   Dali::TouchPoint *result = 0 ;
19792
19793   arg1 = (int)jarg1;
19794   arg2 = (Dali::PointState::Type)jarg2;
19795   arg3 = (float)jarg3;
19796   arg4 = (float)jarg4;
19797   {
19798     try {
19799       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
19800     } CALL_CATCH_EXCEPTION(0);
19801   }
19802
19803   jresult = (void *)result;
19804   return jresult;
19805 }
19806
19807
19808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
19809   void * jresult ;
19810   int arg1 ;
19811   Dali::PointState::Type arg2 ;
19812   float arg3 ;
19813   float arg4 ;
19814   float arg5 ;
19815   float arg6 ;
19816   Dali::TouchPoint *result = 0 ;
19817
19818   arg1 = (int)jarg1;
19819   arg2 = (Dali::PointState::Type)jarg2;
19820   arg3 = (float)jarg3;
19821   arg4 = (float)jarg4;
19822   arg5 = (float)jarg5;
19823   arg6 = (float)jarg6;
19824   {
19825     try {
19826       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
19827     } CALL_CATCH_EXCEPTION(0);
19828   }
19829
19830   jresult = (void *)result;
19831   return jresult;
19832 }
19833
19834
19835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
19836   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19837
19838   arg1 = (Dali::TouchPoint *)jarg1;
19839   {
19840     try {
19841       delete arg1;
19842     } CALL_CATCH_EXCEPTION();
19843   }
19844
19845 }
19846
19847
19848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
19849   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19850   int arg2 ;
19851
19852   arg1 = (Dali::TouchPoint *)jarg1;
19853   arg2 = (int)jarg2;
19854   if (arg1) (arg1)->deviceId = arg2;
19855 }
19856
19857
19858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
19859   int jresult ;
19860   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19861   int result;
19862
19863   arg1 = (Dali::TouchPoint *)jarg1;
19864   result = (int) ((arg1)->deviceId);
19865   jresult = result;
19866   return jresult;
19867 }
19868
19869
19870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
19871   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19872   Dali::PointState::Type arg2 ;
19873
19874   arg1 = (Dali::TouchPoint *)jarg1;
19875   arg2 = (Dali::PointState::Type)jarg2;
19876   if (arg1) (arg1)->state = arg2;
19877 }
19878
19879
19880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
19881   int jresult ;
19882   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19883   Dali::PointState::Type result;
19884
19885   arg1 = (Dali::TouchPoint *)jarg1;
19886   result = (Dali::PointState::Type) ((arg1)->state);
19887   jresult = (int)result;
19888   return jresult;
19889 }
19890
19891
19892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
19893   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19894   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
19895
19896   arg1 = (Dali::TouchPoint *)jarg1;
19897   arg2 = (Dali::Actor *)jarg2;
19898   if (arg1) (arg1)->hitActor = *arg2;
19899 }
19900
19901
19902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
19903   void * jresult ;
19904   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19905   Dali::Actor *result = 0 ;
19906
19907   arg1 = (Dali::TouchPoint *)jarg1;
19908   result = (Dali::Actor *)& ((arg1)->hitActor);
19909   jresult = (void *)result;
19910   return jresult;
19911 }
19912
19913
19914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
19915   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19916   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
19917
19918   arg1 = (Dali::TouchPoint *)jarg1;
19919   arg2 = (Dali::Vector2 *)jarg2;
19920   if (arg1) (arg1)->local = *arg2;
19921 }
19922
19923
19924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
19925   void * jresult ;
19926   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19927   Dali::Vector2 *result = 0 ;
19928
19929   arg1 = (Dali::TouchPoint *)jarg1;
19930   result = (Dali::Vector2 *)& ((arg1)->local);
19931   jresult = (void *)result;
19932   return jresult;
19933 }
19934
19935
19936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
19937   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19938   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
19939
19940   arg1 = (Dali::TouchPoint *)jarg1;
19941   arg2 = (Dali::Vector2 *)jarg2;
19942   if (arg1) (arg1)->screen = *arg2;
19943 }
19944
19945
19946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
19947   void * jresult ;
19948   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19949   Dali::Vector2 *result = 0 ;
19950
19951   arg1 = (Dali::TouchPoint *)jarg1;
19952   result = (Dali::Vector2 *)& ((arg1)->screen);
19953   jresult = (void *)result;
19954   return jresult;
19955 }
19956
19957
19958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
19959   void * jresult ;
19960   Dali::TouchEvent *result = 0 ;
19961
19962   {
19963     try {
19964       result = (Dali::TouchEvent *)new Dali::TouchEvent();
19965     } CALL_CATCH_EXCEPTION(0);
19966   }
19967
19968   jresult = (void *)result;
19969   return jresult;
19970 }
19971
19972
19973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
19974   void * jresult ;
19975   Dali::TouchEvent *arg1 = 0 ;
19976   Dali::TouchEvent *result = 0 ;
19977
19978   arg1 = (Dali::TouchEvent *)jarg1;
19979   if (!arg1) {
19980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
19981     return 0;
19982   }
19983   {
19984     try {
19985       result = (Dali::TouchEvent *)new Dali::TouchEvent((Dali::TouchEvent const &)*arg1);
19986     } CALL_CATCH_EXCEPTION(0);
19987   }
19988
19989   jresult = (void *)result;
19990   return jresult;
19991 }
19992
19993
19994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
19995   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19996
19997   arg1 = (Dali::TouchEvent *)jarg1;
19998   {
19999     try {
20000       delete arg1;
20001     } CALL_CATCH_EXCEPTION();
20002   }
20003
20004 }
20005
20006
20007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
20008   void * jresult ;
20009   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
20010   Dali::TouchEvent *arg2 = 0 ;
20011   Dali::TouchEvent *result = 0 ;
20012
20013   arg1 = (Dali::TouchEvent *)jarg1;
20014   arg2 = (Dali::TouchEvent *)jarg2;
20015   if (!arg2) {
20016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
20017     return 0;
20018   }
20019   {
20020     try {
20021       result = (Dali::TouchEvent *) &(arg1)->operator =((Dali::TouchEvent const &)*arg2);
20022     } CALL_CATCH_EXCEPTION(0);
20023   }
20024
20025   jresult = (void *)result;
20026   return jresult;
20027 }
20028
20029
20030 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
20031   unsigned long jresult ;
20032   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
20033   unsigned long result;
20034
20035   arg1 = (Dali::TouchEvent *)jarg1;
20036   {
20037     try {
20038       result = (unsigned long)((Dali::TouchEvent const *)arg1)->GetTime();
20039     } CALL_CATCH_EXCEPTION(0);
20040   }
20041
20042   jresult = (unsigned long)result;
20043   return jresult;
20044 }
20045
20046
20047 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
20048   unsigned long jresult ;
20049   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
20050   std::size_t result;
20051
20052   arg1 = (Dali::TouchEvent *)jarg1;
20053   {
20054     try {
20055       result = ((Dali::TouchEvent const *)arg1)->GetPointCount();
20056     } CALL_CATCH_EXCEPTION(0);
20057   }
20058
20059   jresult = (unsigned long)result;
20060   return jresult;
20061 }
20062
20063
20064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
20065   int jresult ;
20066   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
20067   std::size_t arg2 ;
20068   int32_t result;
20069
20070   arg1 = (Dali::TouchEvent *)jarg1;
20071   arg2 = (std::size_t)jarg2;
20072   {
20073     try {
20074       result = ((Dali::TouchEvent const *)arg1)->GetDeviceId(arg2);
20075     } CALL_CATCH_EXCEPTION(0);
20076   }
20077
20078   jresult = result;
20079   return jresult;
20080 }
20081
20082
20083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
20084   int jresult ;
20085   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
20086   std::size_t arg2 ;
20087   Dali::PointState::Type result;
20088
20089   arg1 = (Dali::TouchEvent *)jarg1;
20090   arg2 = (std::size_t)jarg2;
20091   {
20092     try {
20093       result = (Dali::PointState::Type)((Dali::TouchEvent const *)arg1)->GetState(arg2);
20094     } CALL_CATCH_EXCEPTION(0);
20095   }
20096
20097   jresult = (int)result;
20098   return jresult;
20099 }
20100
20101
20102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
20103   void * jresult ;
20104   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
20105   std::size_t arg2 ;
20106   Dali::Actor result;
20107
20108   arg1 = (Dali::TouchEvent *)jarg1;
20109   arg2 = (std::size_t)jarg2;
20110   {
20111     try {
20112       result = ((Dali::TouchEvent const *)arg1)->GetHitActor(arg2);
20113     } CALL_CATCH_EXCEPTION(0);
20114   }
20115
20116   jresult = new Dali::Actor((const Dali::Actor &)result);
20117   return jresult;
20118 }
20119
20120
20121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
20122   void * jresult ;
20123   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
20124   std::size_t arg2 ;
20125   Dali::Vector2 *result = 0 ;
20126
20127   arg1 = (Dali::TouchEvent *)jarg1;
20128   arg2 = (std::size_t)jarg2;
20129   {
20130     try {
20131       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetLocalPosition(arg2);
20132     } CALL_CATCH_EXCEPTION(0);
20133   }
20134
20135   jresult = (void *)result;
20136   return jresult;
20137 }
20138
20139
20140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
20141   void * jresult ;
20142   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
20143   std::size_t arg2 ;
20144   Dali::Vector2 *result = 0 ;
20145
20146   arg1 = (Dali::TouchEvent *)jarg1;
20147   arg2 = (std::size_t)jarg2;
20148   {
20149     try {
20150       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetScreenPosition(arg2);
20151     } CALL_CATCH_EXCEPTION(0);
20152   }
20153
20154   jresult = (void *)result;
20155   return jresult;
20156 }
20157
20158
20159 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
20160   float jresult ;
20161   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
20162   std::size_t arg2 ;
20163   float result;
20164
20165   arg1 = (Dali::TouchEvent *)jarg1;
20166   arg2 = (std::size_t)jarg2;
20167   {
20168     try {
20169       result = (float)((Dali::TouchEvent const *)arg1)->GetRadius(arg2);
20170     } CALL_CATCH_EXCEPTION(0);
20171   }
20172
20173   jresult = result;
20174   return jresult;
20175 }
20176
20177
20178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
20179   void * jresult ;
20180   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
20181   std::size_t arg2 ;
20182   Dali::Vector2 *result = 0 ;
20183
20184   arg1 = (Dali::TouchEvent *)jarg1;
20185   arg2 = (std::size_t)jarg2;
20186   {
20187     try {
20188       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetEllipseRadius(arg2);
20189     } CALL_CATCH_EXCEPTION(0);
20190   }
20191
20192   jresult = (void *)result;
20193   return jresult;
20194 }
20195
20196
20197 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
20198   float jresult ;
20199   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
20200   std::size_t arg2 ;
20201   float result;
20202
20203   arg1 = (Dali::TouchEvent *)jarg1;
20204   arg2 = (std::size_t)jarg2;
20205   {
20206     try {
20207       result = (float)((Dali::TouchEvent const *)arg1)->GetPressure(arg2);
20208     } CALL_CATCH_EXCEPTION(0);
20209   }
20210
20211   jresult = result;
20212   return jresult;
20213 }
20214
20215
20216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
20217   void * jresult ;
20218   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
20219   std::size_t arg2 ;
20220   Dali::Degree result;
20221
20222   arg1 = (Dali::TouchEvent *)jarg1;
20223   arg2 = (std::size_t)jarg2;
20224   {
20225     try {
20226       result = ((Dali::TouchEvent const *)arg1)->GetAngle(arg2);
20227     } CALL_CATCH_EXCEPTION(0);
20228   }
20229
20230   jresult = new Dali::Degree((const Dali::Degree &)result);
20231   return jresult;
20232 }
20233
20234
20235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceClass(void * jarg1, unsigned long jarg2) {
20236   int jresult ;
20237   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
20238   std::size_t arg2 ;
20239   Dali::Device::Class::Type result;
20240
20241   arg1 = (Dali::TouchEvent *)jarg1;
20242   arg2 = (std::size_t)jarg2;
20243   {
20244     try {
20245       result = ((Dali::TouchEvent const *)arg1)->GetDeviceClass(arg2);
20246     } CALL_CATCH_EXCEPTION(0);
20247   }
20248
20249   jresult = (int)result;
20250   return jresult;
20251 }
20252
20253
20254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceSubclass(void * jarg1, unsigned long jarg2) {
20255   int jresult ;
20256   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
20257   std::size_t arg2 ;
20258   Dali::Device::Subclass::Type result;
20259
20260   arg1 = (Dali::TouchEvent *)jarg1;
20261   arg2 = (std::size_t)jarg2;
20262   {
20263     try {
20264       result = ((Dali::TouchEvent const *)arg1)->GetDeviceSubclass(arg2);
20265     } CALL_CATCH_EXCEPTION(0);
20266   }
20267
20268   jresult = (int)result;
20269   return jresult;
20270 }
20271
20272
20273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
20274   int jresult ;
20275   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
20276   std::size_t arg2 ;
20277   Dali::MouseButton::Type result;
20278
20279   arg1 = (Dali::TouchEvent *)jarg1;
20280   arg2 = (std::size_t)jarg2;
20281   {
20282     try {
20283       result = ((Dali::TouchEvent const *)arg1)->GetMouseButton(arg2);
20284     } CALL_CATCH_EXCEPTION(0);
20285   }
20286
20287   jresult = static_cast< int >(result);
20288   return jresult;
20289 }
20290
20291
20292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
20293   void * jresult ;
20294   Dali::GestureDetector *result = 0 ;
20295
20296   {
20297     try {
20298       result = (Dali::GestureDetector *)new Dali::GestureDetector();
20299     } CALL_CATCH_EXCEPTION(0);
20300   }
20301
20302   jresult = (void *)result;
20303   return jresult;
20304 }
20305
20306
20307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
20308   void * jresult ;
20309   Dali::BaseHandle arg1 ;
20310   Dali::BaseHandle *argp1 ;
20311   Dali::GestureDetector result;
20312
20313   argp1 = (Dali::BaseHandle *)jarg1;
20314   if (!argp1) {
20315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20316     return 0;
20317   }
20318   arg1 = *argp1;
20319   {
20320     try {
20321       result = Dali::GestureDetector::DownCast(arg1);
20322     } CALL_CATCH_EXCEPTION(0);
20323   }
20324
20325   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
20326   return jresult;
20327 }
20328
20329
20330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
20331   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
20332
20333   arg1 = (Dali::GestureDetector *)jarg1;
20334   {
20335     try {
20336       delete arg1;
20337     } CALL_CATCH_EXCEPTION();
20338   }
20339
20340 }
20341
20342
20343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
20344   void * jresult ;
20345   Dali::GestureDetector *arg1 = 0 ;
20346   Dali::GestureDetector *result = 0 ;
20347
20348   arg1 = (Dali::GestureDetector *)jarg1;
20349   if (!arg1) {
20350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
20351     return 0;
20352   }
20353   {
20354     try {
20355       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
20356     } CALL_CATCH_EXCEPTION(0);
20357   }
20358
20359   jresult = (void *)result;
20360   return jresult;
20361 }
20362
20363
20364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
20365   void * jresult ;
20366   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
20367   Dali::GestureDetector *arg2 = 0 ;
20368   Dali::GestureDetector *result = 0 ;
20369
20370   arg1 = (Dali::GestureDetector *)jarg1;
20371   arg2 = (Dali::GestureDetector *)jarg2;
20372   if (!arg2) {
20373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
20374     return 0;
20375   }
20376   {
20377     try {
20378       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
20379     } CALL_CATCH_EXCEPTION(0);
20380   }
20381
20382   jresult = (void *)result;
20383   return jresult;
20384 }
20385
20386
20387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
20388   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
20389   Dali::Actor arg2 ;
20390   Dali::Actor *argp2 ;
20391
20392   arg1 = (Dali::GestureDetector *)jarg1;
20393   argp2 = (Dali::Actor *)jarg2;
20394   if (!argp2) {
20395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20396     return ;
20397   }
20398   arg2 = *argp2;
20399   {
20400     try {
20401       (arg1)->Attach(arg2);
20402     } CALL_CATCH_EXCEPTION();
20403   }
20404
20405 }
20406
20407
20408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
20409   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
20410   Dali::Actor arg2 ;
20411   Dali::Actor *argp2 ;
20412
20413   arg1 = (Dali::GestureDetector *)jarg1;
20414   argp2 = (Dali::Actor *)jarg2;
20415   if (!argp2) {
20416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20417     return ;
20418   }
20419   arg2 = *argp2;
20420   {
20421     try {
20422       (arg1)->Detach(arg2);
20423     } CALL_CATCH_EXCEPTION();
20424   }
20425
20426 }
20427
20428
20429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
20430   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
20431
20432   arg1 = (Dali::GestureDetector *)jarg1;
20433   {
20434     try {
20435       (arg1)->DetachAll();
20436     } CALL_CATCH_EXCEPTION();
20437   }
20438
20439 }
20440
20441
20442 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
20443   unsigned long jresult ;
20444   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
20445   size_t result;
20446
20447   arg1 = (Dali::GestureDetector *)jarg1;
20448   {
20449     try {
20450       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
20451     } CALL_CATCH_EXCEPTION(0);
20452   }
20453
20454   jresult = (unsigned long)result;
20455   return jresult;
20456 }
20457
20458
20459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
20460   void * jresult ;
20461   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
20462   size_t arg2 ;
20463   Dali::Actor result;
20464
20465   arg1 = (Dali::GestureDetector *)jarg1;
20466   arg2 = (size_t)jarg2;
20467   {
20468     try {
20469       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
20470     } CALL_CATCH_EXCEPTION(0);
20471   }
20472
20473   jresult = new Dali::Actor((const Dali::Actor &)result);
20474   return jresult;
20475 }
20476
20477
20478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
20479   void * jresult ;
20480   Dali::Gesture *arg1 = 0 ;
20481   Dali::Gesture *result = 0 ;
20482
20483   arg1 = (Dali::Gesture *)jarg1;
20484   if (!arg1) {
20485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
20486     return 0;
20487   }
20488   {
20489     try {
20490       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
20491     } CALL_CATCH_EXCEPTION(0);
20492   }
20493
20494   jresult = (void *)result;
20495   return jresult;
20496 }
20497
20498
20499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
20500   void * jresult ;
20501   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
20502   Dali::Gesture *arg2 = 0 ;
20503   Dali::Gesture *result = 0 ;
20504
20505   arg1 = (Dali::Gesture *)jarg1;
20506   arg2 = (Dali::Gesture *)jarg2;
20507   if (!arg2) {
20508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
20509     return 0;
20510   }
20511   {
20512     try {
20513       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
20514     } CALL_CATCH_EXCEPTION(0);
20515   }
20516
20517   jresult = (void *)result;
20518   return jresult;
20519 }
20520
20521
20522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
20523   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
20524
20525   arg1 = (Dali::Gesture *)jarg1;
20526   {
20527     try {
20528       delete arg1;
20529     } CALL_CATCH_EXCEPTION();
20530   }
20531
20532 }
20533
20534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
20535   int jresult ;
20536   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
20537   Dali::GestureType::Value result;
20538
20539   arg1 = (Dali::Gesture *)jarg1;
20540   result = (Dali::GestureType::Value) ((arg1)->GetType());
20541   jresult = (int)result;
20542   return jresult;
20543 }
20544
20545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
20546   int jresult ;
20547   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
20548   Dali::GestureState result;
20549
20550   arg1 = (Dali::Gesture *)jarg1;
20551   result = (Dali::GestureState) ((arg1)->GetState());
20552   jresult = (int)result;
20553   return jresult;
20554 }
20555
20556 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
20557   unsigned int jresult ;
20558   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
20559   unsigned int result;
20560
20561   arg1 = (Dali::Gesture *)jarg1;
20562   result = (unsigned int) ((arg1)->GetTime());
20563   jresult = result;
20564   return jresult;
20565 }
20566
20567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_sourceType_get(void * gesture) {
20568   int jresult ;
20569   Dali::Gesture *jGesture = (Dali::Gesture *) gesture;
20570   Dali::GestureSourceType result;
20571
20572   if (!jGesture) {
20573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
20574     return 0;
20575   }
20576   {
20577     try {
20578       result = (Dali::GestureSourceType)jGesture->GetSourceType();
20579     } CALL_CATCH_EXCEPTION(0);
20580   }
20581
20582   jresult = (int)result;
20583   return jresult;
20584 }
20585
20586
20587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_sourceData_get(void * gesture) {
20588   int jresult ;
20589   Dali::Gesture *jGesture = (Dali::Gesture *) gesture;
20590   Dali::GestureSourceData result;
20591
20592   if (!jGesture) {
20593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::gesture const & type is null", 0);
20594     return 0;
20595   }
20596   {
20597     try {
20598       result = (Dali::GestureSourceData)jGesture->GetSourceData();
20599     } CALL_CATCH_EXCEPTION(0);
20600   }
20601
20602   jresult = (int)result;
20603   return jresult;
20604 }
20605
20606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
20607   void * jresult ;
20608   Dali::HoverEvent *result = 0 ;
20609
20610   {
20611     try {
20612       result = (Dali::HoverEvent *)new Dali::HoverEvent();
20613     } CALL_CATCH_EXCEPTION(0);
20614   }
20615
20616   jresult = (void *)result;
20617   return jresult;
20618 }
20619
20620
20621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(void * jarg1) {
20622   void * jresult ;
20623   Dali::HoverEvent *arg1 = 0 ;
20624   Dali::HoverEvent *result = 0 ;
20625
20626   arg1 = (Dali::HoverEvent *)jarg1;
20627   if (!arg1) {
20628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
20629     return 0;
20630   }
20631   {
20632     try {
20633       result = (Dali::HoverEvent *)new Dali::HoverEvent((Dali::HoverEvent const &)*arg1);
20634     } CALL_CATCH_EXCEPTION(0);
20635   }
20636
20637   jresult = (void *)result;
20638   return jresult;
20639 }
20640
20641
20642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
20643   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20644
20645   arg1 = (Dali::HoverEvent *)jarg1;
20646   {
20647     try {
20648       delete arg1;
20649     } CALL_CATCH_EXCEPTION();
20650   }
20651
20652 }
20653
20654
20655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_Assign(void * jarg1, void * jarg2) {
20656   void * jresult ;
20657   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20658   Dali::HoverEvent *arg2 = 0 ;
20659   Dali::HoverEvent *result = 0 ;
20660
20661   arg1 = (Dali::HoverEvent *)jarg1;
20662   arg2 = (Dali::HoverEvent *)jarg2;
20663   if (!arg2) {
20664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
20665     return 0;
20666   }
20667   {
20668     try {
20669       result = (Dali::HoverEvent *) &(arg1)->operator =((Dali::HoverEvent const &)*arg2);
20670     } catch (std::out_of_range& e) {
20671       {
20672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20673       };
20674     } catch (std::exception& e) {
20675       {
20676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20677       };
20678     } catch (Dali::DaliException e) {
20679       {
20680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20681       };
20682     } catch (...) {
20683       {
20684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20685       };
20686     }
20687   }
20688
20689   jresult = (void *)result;
20690   return jresult;
20691 }
20692
20693
20694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_New(unsigned int jarg1) {
20695   void * jresult ;
20696   unsigned int arg1 ;
20697   Dali::HoverEvent result;
20698
20699   arg1 = (unsigned int)jarg1;
20700   {
20701     try {
20702       result = DevelHoverEvent::New(arg1);
20703     } CALL_CATCH_EXCEPTION(0);
20704   }
20705
20706   jresult = new Dali::HoverEvent((const Dali::HoverEvent &)result);
20707   return jresult;
20708 }
20709
20710
20711 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetTime(void * jarg1) {
20712   unsigned long jresult ;
20713   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20714   unsigned long result;
20715
20716   arg1 = (Dali::HoverEvent *)jarg1;
20717   {
20718     try {
20719       result = (unsigned long)((Dali::HoverEvent const *)arg1)->GetTime();
20720     } catch (std::out_of_range& e) {
20721       {
20722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20723       };
20724     } catch (std::exception& e) {
20725       {
20726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20727       };
20728     } catch (Dali::DaliException e) {
20729       {
20730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20731       };
20732     } catch (...) {
20733       {
20734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20735       };
20736     }
20737   }
20738
20739   jresult = (unsigned long)result;
20740   return jresult;
20741 }
20742
20743
20744 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
20745   unsigned long jresult ;
20746   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20747   std::size_t result;
20748
20749   arg1 = (Dali::HoverEvent *)jarg1;
20750   {
20751     try {
20752       result = ((Dali::HoverEvent const *)arg1)->GetPointCount();
20753     } catch (std::out_of_range& e) {
20754       {
20755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20756       };
20757     } catch (std::exception& e) {
20758       {
20759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20760       };
20761     } catch (Dali::DaliException e) {
20762       {
20763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20764       };
20765     } catch (...) {
20766       {
20767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20768       };
20769     }
20770   }
20771
20772   jresult = (unsigned long)result;
20773   return jresult;
20774 }
20775
20776
20777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetDeviceId(void * jarg1, unsigned long jarg2) {
20778   int jresult ;
20779   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20780   std::size_t arg2 ;
20781   int32_t result;
20782
20783   arg1 = (Dali::HoverEvent *)jarg1;
20784   arg2 = (std::size_t)jarg2;
20785   {
20786     try {
20787       result = ((Dali::HoverEvent const *)arg1)->GetDeviceId(arg2);
20788     } catch (std::out_of_range& e) {
20789       {
20790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20791       };
20792     } catch (std::exception& e) {
20793       {
20794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20795       };
20796     } catch (Dali::DaliException e) {
20797       {
20798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20799       };
20800     } catch (...) {
20801       {
20802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20803       };
20804     }
20805   }
20806
20807   jresult = result;
20808   return jresult;
20809 }
20810
20811
20812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetState(void * jarg1, unsigned long jarg2) {
20813   int jresult ;
20814   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20815   std::size_t arg2 ;
20816   Dali::PointState::Type result;
20817
20818   arg1 = (Dali::HoverEvent *)jarg1;
20819   arg2 = (std::size_t)jarg2;
20820   {
20821     try {
20822       result = (Dali::PointState::Type)((Dali::HoverEvent const *)arg1)->GetState(arg2);
20823     } CALL_CATCH_EXCEPTION(0);
20824   }
20825
20826   jresult = (int)result;
20827   return jresult;
20828 }
20829
20830
20831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetHitActor(void * jarg1, unsigned long jarg2) {
20832   void * jresult ;
20833   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20834   std::size_t arg2 ;
20835   Dali::Actor result;
20836
20837   arg1 = (Dali::HoverEvent *)jarg1;
20838   arg2 = (std::size_t)jarg2;
20839   {
20840     try {
20841       result = ((Dali::HoverEvent const *)arg1)->GetHitActor(arg2);
20842     } catch (std::out_of_range& e) {
20843       {
20844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20845       };
20846     } catch (std::exception& e) {
20847       {
20848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20849       };
20850     } catch (Dali::DaliException e) {
20851       {
20852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20853       };
20854     } catch (...) {
20855       {
20856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20857       };
20858     }
20859   }
20860
20861   jresult = new Dali::Actor((const Dali::Actor &)result);
20862   return jresult;
20863 }
20864
20865
20866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetLocalPosition(void * jarg1, unsigned long jarg2) {
20867   void * jresult ;
20868   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20869   std::size_t arg2 ;
20870   Dali::Vector2 *result = 0 ;
20871
20872   arg1 = (Dali::HoverEvent *)jarg1;
20873   arg2 = (std::size_t)jarg2;
20874   {
20875     try {
20876       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetLocalPosition(arg2);
20877     } catch (std::out_of_range& e) {
20878       {
20879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20880       };
20881     } catch (std::exception& e) {
20882       {
20883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20884       };
20885     } catch (Dali::DaliException e) {
20886       {
20887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20888       };
20889     } catch (...) {
20890       {
20891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20892       };
20893     }
20894   }
20895
20896   jresult = (void *)result;
20897   return jresult;
20898 }
20899
20900
20901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetScreenPosition(void * jarg1, unsigned long jarg2) {
20902   void * jresult ;
20903   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20904   std::size_t arg2 ;
20905   Dali::Vector2 *result = 0 ;
20906
20907   arg1 = (Dali::HoverEvent *)jarg1;
20908   arg2 = (std::size_t)jarg2;
20909   {
20910     try {
20911       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetScreenPosition(arg2);
20912     } CALL_CATCH_EXCEPTION(0);
20913   }
20914
20915   jresult = (void *)result;
20916   return jresult;
20917 }
20918
20919
20920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
20921   void * jresult ;
20922   Dali::KeyEvent *result = 0 ;
20923
20924   {
20925     try {
20926       result = (Dali::KeyEvent *)new Dali::KeyEvent();
20927     } CALL_CATCH_EXCEPTION(0);
20928   }
20929
20930   jresult = (void *)result;
20931   return jresult;
20932 }
20933
20934
20935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(void * jarg1) {
20936   void * jresult ;
20937   Dali::KeyEvent *arg1 = 0 ;
20938   Dali::KeyEvent *result = 0 ;
20939
20940   arg1 = (Dali::KeyEvent *)jarg1;
20941   if (!arg1) {
20942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
20943     return 0;
20944   }
20945   {
20946     try {
20947       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
20948     } CALL_CATCH_EXCEPTION(0);
20949   }
20950
20951   jresult = (void *)result;
20952   return jresult;
20953 }
20954
20955
20956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
20957   void * jresult ;
20958   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
20959   Dali::KeyEvent *arg2 = 0 ;
20960   Dali::KeyEvent *result = 0 ;
20961
20962   arg1 = (Dali::KeyEvent *)jarg1;
20963   arg2 = (Dali::KeyEvent *)jarg2;
20964   if (!arg2) {
20965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
20966     return 0;
20967   }
20968   {
20969     try {
20970       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
20971     } CALL_CATCH_EXCEPTION(0);
20972   }
20973
20974   jresult = (void *)result;
20975   return jresult;
20976 }
20977
20978
20979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_New(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
20980   void * jresult ;
20981   std::string *arg1 = 0 ;
20982   std::string *arg2 = 0 ;
20983   int arg3 ;
20984   int arg4 ;
20985   unsigned long arg5 ;
20986   Dali::KeyEvent::State *arg6 = 0 ;
20987   Dali::KeyEvent::State temp6 ;
20988   Dali::KeyEvent result;
20989
20990   if (!jarg1) {
20991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20992     return 0;
20993   }
20994   std::string arg1_str(jarg1);
20995   arg1 = &arg1_str;
20996   if (!jarg2) {
20997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20998     return 0;
20999   }
21000   std::string arg2_str(jarg2);
21001   arg2 = &arg2_str;
21002   arg3 = (int)jarg3;
21003   arg4 = (int)jarg4;
21004   arg5 = (unsigned long)jarg5;
21005   temp6 = (Dali::KeyEvent::State)jarg6;
21006   arg6 = &temp6;
21007   {
21008     try {
21009       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);
21010     } CALL_CATCH_EXCEPTION(0);
21011   }
21012
21013   jresult = new Dali::KeyEvent((const Dali::KeyEvent &)result);
21014
21015   //argout typemap for const std::string&
21016
21017
21018   //argout typemap for const std::string&
21019
21020   return jresult;
21021 }
21022
21023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
21024   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
21025
21026   arg1 = (Dali::KeyEvent *)jarg1;
21027   {
21028     try {
21029       delete arg1;
21030     } CALL_CATCH_EXCEPTION();
21031   }
21032
21033 }
21034
21035
21036 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
21037   bool jresult ;
21038   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
21039   bool result;
21040
21041   arg1 = (Dali::KeyEvent *)jarg1;
21042   {
21043     try {
21044       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
21045     } CALL_CATCH_EXCEPTION(0);
21046   }
21047
21048   jresult = result;
21049   return jresult;
21050 }
21051
21052
21053 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
21054   bool jresult ;
21055   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
21056   bool result;
21057
21058   arg1 = (Dali::KeyEvent *)jarg1;
21059   {
21060     try {
21061       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
21062     } CALL_CATCH_EXCEPTION(0);
21063   }
21064
21065   jresult = result;
21066   return jresult;
21067 }
21068
21069
21070 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
21071   bool jresult ;
21072   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
21073   bool result;
21074
21075   arg1 = (Dali::KeyEvent *)jarg1;
21076   {
21077     try {
21078       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
21079     } CALL_CATCH_EXCEPTION(0);
21080   }
21081
21082   jresult = result;
21083   return jresult;
21084 }
21085
21086
21087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
21088   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
21089   std::string *arg2 = 0 ;
21090
21091   argp1 = (Dali::KeyEvent *) jarg1;
21092   if (!argp1) {
21093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
21094     return ;
21095   }
21096
21097   Dali::KeyEvent arg1 = *argp1;
21098   if (!jarg2) {
21099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21100     return ;
21101   }
21102   std::string arg2_str(jarg2);
21103   arg2 = &arg2_str;
21104
21105   {
21106     try {
21107       Dali::DevelKeyEvent::SetKeyName(arg1, (std::string const &)*arg2);
21108     } catch (std::out_of_range& e) {
21109       {
21110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21111       };
21112     } catch (std::exception& e) {
21113       {
21114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21115       };
21116     } catch (Dali::DaliException e) {
21117       {
21118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21119       };
21120     } catch (...) {
21121       {
21122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21123       };
21124     }
21125   }
21126 }
21127
21128
21129 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
21130   char * jresult ;
21131
21132   if( jarg1 == NULL )
21133   {
21134     jresult = SWIG_csharp_string_callback( "" );
21135   }
21136   else
21137   {
21138     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
21139     std::string *result = 0;
21140     std::string str = "";
21141
21142     arg1 = ( Dali::KeyEvent * )jarg1;
21143     {
21144       try {
21145         str = ((Dali::KeyEvent const *)arg1)->GetKeyName();
21146         result = (std::string *) &str;
21147         jresult = SWIG_csharp_string_callback(result->c_str());
21148       } catch (std::out_of_range& e) {
21149         {
21150           SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21151         };
21152       } catch (std::exception& e) {
21153         {
21154           SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21155         };
21156       } catch (Dali::DaliException e) {
21157         {
21158           SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21159         };
21160       } catch (...) {
21161         {
21162           SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21163         };
21164       }
21165     }
21166
21167   }
21168
21169   return jresult;
21170 }
21171
21172
21173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
21174   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
21175   std::string *arg2 = 0 ;
21176
21177   argp1 = (Dali::KeyEvent *) jarg1;
21178   if (!argp1) {
21179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
21180     return ;
21181   }
21182
21183   Dali::KeyEvent arg1 = *argp1;
21184   if (!jarg2) {
21185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21186     return ;
21187   }
21188   std::string arg2_str(jarg2);
21189   arg2 = &arg2_str;
21190
21191   {
21192     try {
21193       Dali::DevelKeyEvent::SetKeyString(arg1, (std::string const &)*arg2);
21194     } catch (std::out_of_range& e) {
21195       {
21196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21197       };
21198     } catch (std::exception& e) {
21199       {
21200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21201       };
21202     } catch (Dali::DaliException e) {
21203       {
21204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21205       };
21206     } catch (...) {
21207       {
21208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21209       };
21210     }
21211   }
21212 }
21213
21214
21215 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
21216   char * jresult ;
21217
21218   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
21219   std::string *result = 0;
21220   std::string str = "";
21221   arg1 = ( Dali::KeyEvent * )jarg1;
21222   {
21223     try {
21224       str = ((Dali::KeyEvent const *)arg1)->GetKeyString();
21225       result = (std::string *) &str;
21226       jresult = SWIG_csharp_string_callback(result->c_str());
21227     } catch (std::out_of_range& e) {
21228       {
21229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21230       };
21231     } catch (std::exception& e) {
21232       {
21233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21234       };
21235     } catch (Dali::DaliException e) {
21236       {
21237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21238       };
21239     } catch (...) {
21240       {
21241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21242       };
21243     }
21244   }
21245
21246   return jresult;
21247 }
21248
21249
21250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
21251   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
21252   int arg2 ;
21253
21254   argp1 = (Dali::KeyEvent *) jarg1;
21255   if (!argp1) {
21256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
21257     return ;
21258   }
21259
21260   Dali::KeyEvent arg1 = *argp1;
21261   arg2 = (int)jarg2;
21262   {
21263     try {
21264       Dali::DevelKeyEvent::SetKeyCode(arg1, arg2);
21265     } catch (std::out_of_range& e) {
21266       {
21267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21268       };
21269     } catch (std::exception& e) {
21270       {
21271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21272       };
21273     } catch (Dali::DaliException e) {
21274       {
21275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21276       };
21277     } catch (...) {
21278       {
21279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21280       };
21281     }
21282   }
21283 }
21284
21285
21286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
21287   int jresult ;
21288   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
21289   int result;
21290
21291   arg1 = (Dali::KeyEvent *)jarg1;
21292   {
21293     try {
21294       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyCode();
21295     } catch (std::out_of_range& e) {
21296       {
21297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21298       };
21299     } catch (std::exception& e) {
21300       {
21301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21302       };
21303     } catch (Dali::DaliException e) {
21304       {
21305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21306       };
21307     } catch (...) {
21308       {
21309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21310       };
21311     }
21312   }
21313
21314   jresult = result;
21315   return jresult;
21316 }
21317
21318
21319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
21320   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
21321   int arg2 ;
21322
21323   argp1 = (Dali::KeyEvent *) jarg1;
21324   if (!argp1) {
21325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
21326     return ;
21327   }
21328
21329   Dali::KeyEvent arg1 = *argp1;
21330   arg2 = (int)jarg2;
21331   {
21332     try {
21333       Dali::DevelKeyEvent::SetKeyModifier(arg1, arg2);
21334     } catch (std::out_of_range& e) {
21335       {
21336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21337       };
21338     } catch (std::exception& e) {
21339       {
21340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21341       };
21342     } catch (Dali::DaliException e) {
21343       {
21344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21345       };
21346     } catch (...) {
21347       {
21348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21349       };
21350     }
21351   }
21352 }
21353
21354
21355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
21356   int jresult ;
21357   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
21358   int result;
21359
21360   arg1 = (Dali::KeyEvent *)jarg1;
21361   {
21362     try {
21363       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyModifier();
21364     } catch (std::out_of_range& e) {
21365       {
21366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21367       };
21368     } catch (std::exception& e) {
21369       {
21370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21371       };
21372     } catch (Dali::DaliException e) {
21373       {
21374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21375       };
21376     } catch (...) {
21377       {
21378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21379       };
21380     }
21381   }
21382
21383   jresult = result;
21384   return jresult;
21385 }
21386
21387
21388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
21389   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
21390   unsigned long arg2 ;
21391
21392   argp1 = (Dali::KeyEvent *) jarg1;
21393   if (!argp1) {
21394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
21395     return ;
21396   }
21397
21398   Dali::KeyEvent arg1 = *argp1;
21399   arg2 = (int)jarg2;
21400   {
21401     try {
21402       Dali::DevelKeyEvent::SetTime(arg1, arg2);
21403     } catch (std::out_of_range& e) {
21404       {
21405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21406       };
21407     } catch (std::exception& e) {
21408       {
21409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21410       };
21411     } catch (Dali::DaliException e) {
21412       {
21413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21414       };
21415     } catch (...) {
21416       {
21417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21418       };
21419     }
21420   }
21421 }
21422
21423
21424 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
21425   unsigned long jresult ;
21426   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
21427   unsigned long result;
21428
21429   arg1 = (Dali::KeyEvent *)jarg1;
21430   {
21431     try {
21432       result = (int)((Dali::KeyEvent const *)arg1)->GetTime();
21433     } catch (std::out_of_range& e) {
21434       {
21435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21436       };
21437     } catch (std::exception& e) {
21438       {
21439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21440       };
21441     } catch (Dali::DaliException e) {
21442       {
21443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21444       };
21445     } catch (...) {
21446       {
21447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21448       };
21449     }
21450   }
21451
21452   jresult = result;
21453   return jresult;
21454 }
21455
21456
21457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
21458   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0;
21459   Dali::KeyEvent::State arg2;
21460
21461   argp1 = (Dali::KeyEvent *) jarg1;
21462   if (!argp1) {
21463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
21464     return ;
21465   }
21466
21467   Dali::KeyEvent arg1 = *argp1;
21468   arg2 = (Dali::KeyEvent::State)jarg2;
21469   {
21470     try {
21471       Dali::DevelKeyEvent::SetState(arg1, arg2);
21472     } catch (std::out_of_range& e) {
21473       {
21474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21475       };
21476     } catch (std::exception& e) {
21477       {
21478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21479       };
21480     } catch (Dali::DaliException e) {
21481       {
21482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21483       };
21484     } catch (...) {
21485       {
21486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21487       };
21488     }
21489   }
21490 }
21491
21492
21493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
21494   int jresult ;
21495   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
21496   Dali::KeyEvent::State result;
21497
21498   arg1 = (Dali::KeyEvent *)jarg1;
21499   {
21500     try {
21501       result = (Dali::KeyEvent::State)((Dali::KeyEvent const *)arg1)->GetState();
21502     } catch (std::out_of_range& e) {
21503       {
21504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21505       };
21506     } catch (std::exception& e) {
21507       {
21508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21509       };
21510     } catch (Dali::DaliException e) {
21511       {
21512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21513       };
21514     } catch (...) {
21515       {
21516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21517       };
21518     }
21519   }
21520
21521   jresult = (int)result;
21522   return jresult;
21523
21524 }
21525
21526 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
21527   char * jresult ;
21528
21529   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
21530   std::string *result = 0;
21531   std::string str = "";
21532
21533   arg1 = ( Dali::KeyEvent * )jarg1;
21534   {
21535     try {
21536       str = ((Dali::KeyEvent const *)arg1)->GetLogicalKey();
21537       result = (std::string *) &str;
21538       jresult = SWIG_csharp_string_callback(result->c_str());
21539     } CALL_CATCH_EXCEPTION(0);
21540   }
21541
21542   return jresult;
21543 }
21544
21545
21546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
21547   void * jresult ;
21548   Dali::LongPressGestureDetector *result = 0 ;
21549
21550   {
21551     try {
21552       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
21553     } CALL_CATCH_EXCEPTION(0);
21554   }
21555
21556   jresult = (void *)result;
21557   return jresult;
21558 }
21559
21560
21561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
21562   void * jresult ;
21563   Dali::LongPressGestureDetector result;
21564
21565   {
21566     try {
21567       result = Dali::LongPressGestureDetector::New();
21568     } CALL_CATCH_EXCEPTION(0);
21569   }
21570
21571   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
21572   return jresult;
21573 }
21574
21575
21576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
21577   void * jresult ;
21578   unsigned int arg1 ;
21579   Dali::LongPressGestureDetector result;
21580
21581   arg1 = (unsigned int)jarg1;
21582   {
21583     try {
21584       result = Dali::LongPressGestureDetector::New(arg1);
21585     } CALL_CATCH_EXCEPTION(0);
21586   }
21587
21588   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
21589   return jresult;
21590 }
21591
21592
21593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
21594   void * jresult ;
21595   unsigned int arg1 ;
21596   unsigned int arg2 ;
21597   Dali::LongPressGestureDetector result;
21598
21599   arg1 = (unsigned int)jarg1;
21600   arg2 = (unsigned int)jarg2;
21601   {
21602     try {
21603       result = Dali::LongPressGestureDetector::New(arg1,arg2);
21604     } CALL_CATCH_EXCEPTION(0);
21605   }
21606
21607   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
21608   return jresult;
21609 }
21610
21611
21612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
21613   void * jresult ;
21614   Dali::BaseHandle arg1 ;
21615   Dali::BaseHandle *argp1 ;
21616   Dali::LongPressGestureDetector result;
21617
21618   argp1 = (Dali::BaseHandle *)jarg1;
21619   if (!argp1) {
21620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21621     return 0;
21622   }
21623   arg1 = *argp1;
21624   {
21625     try {
21626       result = Dali::LongPressGestureDetector::DownCast(arg1);
21627     } CALL_CATCH_EXCEPTION(0);
21628   }
21629
21630   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
21631   return jresult;
21632 }
21633
21634
21635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
21636   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
21637
21638   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21639   {
21640     try {
21641       delete arg1;
21642     } CALL_CATCH_EXCEPTION();
21643   }
21644
21645 }
21646
21647
21648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
21649   void * jresult ;
21650   Dali::LongPressGestureDetector *arg1 = 0 ;
21651   Dali::LongPressGestureDetector *result = 0 ;
21652
21653   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21654   if (!arg1) {
21655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
21656     return 0;
21657   }
21658   {
21659     try {
21660       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
21661     } CALL_CATCH_EXCEPTION(0);
21662   }
21663
21664   jresult = (void *)result;
21665   return jresult;
21666 }
21667
21668
21669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
21670   void * jresult ;
21671   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
21672   Dali::LongPressGestureDetector *arg2 = 0 ;
21673   Dali::LongPressGestureDetector *result = 0 ;
21674
21675   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21676   arg2 = (Dali::LongPressGestureDetector *)jarg2;
21677   if (!arg2) {
21678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
21679     return 0;
21680   }
21681   {
21682     try {
21683       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
21684     } CALL_CATCH_EXCEPTION(0);
21685   }
21686
21687   jresult = (void *)result;
21688   return jresult;
21689 }
21690
21691
21692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
21693   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
21694   unsigned int arg2 ;
21695
21696   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21697   arg2 = (unsigned int)jarg2;
21698   {
21699     try {
21700       (arg1)->SetTouchesRequired(arg2);
21701     } CALL_CATCH_EXCEPTION();
21702   }
21703
21704 }
21705
21706
21707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
21708   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
21709   unsigned int arg2 ;
21710   unsigned int arg3 ;
21711
21712   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21713   arg2 = (unsigned int)jarg2;
21714   arg3 = (unsigned int)jarg3;
21715   {
21716     try {
21717       (arg1)->SetTouchesRequired(arg2,arg3);
21718     } CALL_CATCH_EXCEPTION();
21719   }
21720
21721 }
21722
21723
21724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
21725   unsigned int jresult ;
21726   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
21727   unsigned int result;
21728
21729   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21730   {
21731     try {
21732       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
21733     } CALL_CATCH_EXCEPTION(0);
21734   }
21735
21736   jresult = result;
21737   return jresult;
21738 }
21739
21740
21741 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
21742   unsigned int jresult ;
21743   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
21744   unsigned int result;
21745
21746   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21747   {
21748     try {
21749       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
21750     } CALL_CATCH_EXCEPTION(0);
21751   }
21752
21753   jresult = result;
21754   return jresult;
21755 }
21756
21757
21758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
21759   void * jresult ;
21760   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
21761   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
21762
21763   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21764   {
21765     try {
21766       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
21767     } CALL_CATCH_EXCEPTION(0);
21768   }
21769
21770   jresult = (void *)result;
21771   return jresult;
21772 }
21773
21774
21775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0() {
21776   void * jresult ;
21777   Dali::LongPressGesture *result = 0 ;
21778
21779   {
21780     try {
21781       result = (Dali::LongPressGesture *)new Dali::LongPressGesture();
21782     } CALL_CATCH_EXCEPTION(0);
21783   }
21784
21785   jresult = (void *)result;
21786   return jresult;
21787 }
21788
21789
21790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_New(int jarg1) {
21791   void * jresult ;
21792   Dali::GestureState arg1 ;
21793   Dali::LongPressGesture result;
21794
21795   arg1 = (Dali::GestureState)jarg1;
21796   {
21797     try {
21798       result = DevelLongPressGesture::New(arg1);
21799     } CALL_CATCH_EXCEPTION(0);
21800   }
21801
21802   jresult = new Dali::LongPressGesture((const Dali::LongPressGesture &)result);
21803   return jresult;
21804 }
21805
21806
21807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
21808   void * jresult ;
21809   Dali::LongPressGesture *arg1 = 0 ;
21810   Dali::LongPressGesture *result = 0 ;
21811
21812   arg1 = (Dali::LongPressGesture *)jarg1;
21813   if (!arg1) {
21814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
21815     return 0;
21816   }
21817   {
21818     try {
21819       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
21820     } CALL_CATCH_EXCEPTION(0);
21821   }
21822
21823   jresult = (void *)result;
21824   return jresult;
21825 }
21826
21827
21828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
21829   void * jresult ;
21830   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
21831   Dali::LongPressGesture *arg2 = 0 ;
21832   Dali::LongPressGesture *result = 0 ;
21833
21834   arg1 = (Dali::LongPressGesture *)jarg1;
21835   arg2 = (Dali::LongPressGesture *)jarg2;
21836   if (!arg2) {
21837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
21838     return 0;
21839   }
21840   {
21841     try {
21842       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
21843     } CALL_CATCH_EXCEPTION(0);
21844   }
21845
21846   jresult = (void *)result;
21847   return jresult;
21848 }
21849
21850
21851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
21852   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
21853
21854   arg1 = (Dali::LongPressGesture *)jarg1;
21855   {
21856     try {
21857       delete arg1;
21858     } CALL_CATCH_EXCEPTION();
21859   }
21860
21861 }
21862
21863
21864 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
21865   unsigned int jresult ;
21866   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
21867   unsigned int result;
21868
21869   arg1 = (Dali::LongPressGesture *)jarg1;
21870   result = (unsigned int) ((arg1)->GetNumberOfTouches());
21871   jresult = result;
21872   return jresult;
21873 }
21874
21875
21876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
21877   void * jresult ;
21878   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
21879   Dali::Vector2 result;
21880
21881   arg1 = (Dali::LongPressGesture *)jarg1;
21882   {
21883     try {
21884       result = ((Dali::LongPressGesture const *)arg1)->GetScreenPoint();
21885     } catch (std::out_of_range& e) {
21886       {
21887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21888       };
21889     } catch (std::exception& e) {
21890       {
21891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21892       };
21893     } catch (Dali::DaliException e) {
21894       {
21895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21896       };
21897     } catch (...) {
21898       {
21899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21900       };
21901     }
21902   }
21903   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
21904   return jresult;
21905 }
21906
21907
21908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
21909   void * jresult ;
21910   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
21911   Dali::Vector2 result;
21912
21913   arg1 = (Dali::LongPressGesture *)jarg1;
21914   {
21915     try {
21916       result = ((Dali::LongPressGesture const *)arg1)->GetLocalPoint();
21917     } catch (std::out_of_range& e) {
21918       {
21919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21920       };
21921     } catch (std::exception& e) {
21922       {
21923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21924       };
21925     } catch (Dali::DaliException e) {
21926       {
21927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21928       };
21929     } catch (...) {
21930       {
21931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21932       };
21933     }
21934   }
21935   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
21936   return jresult;
21937 }
21938
21939
21940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
21941   void * jresult ;
21942   Dali::WheelEvent *result = 0 ;
21943
21944   {
21945     try {
21946       result = (Dali::WheelEvent *)new Dali::WheelEvent();
21947     } CALL_CATCH_EXCEPTION(0);
21948   }
21949
21950   jresult = (void *)result;
21951   return jresult;
21952 }
21953
21954
21955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(void * jarg1) {
21956   void * jresult ;
21957   Dali::WheelEvent *arg1 = 0 ;
21958   Dali::WheelEvent *result = 0 ;
21959
21960   arg1 = (Dali::WheelEvent *)jarg1;
21961   if (!arg1) {
21962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
21963     return 0;
21964   }
21965   {
21966     try {
21967       result = (Dali::WheelEvent *)new Dali::WheelEvent((Dali::WheelEvent const &)*arg1);
21968     } catch (std::out_of_range& e) {
21969       {
21970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21971       };
21972     } catch (std::exception& e) {
21973       {
21974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21975       };
21976     } catch (Dali::DaliException e) {
21977       {
21978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21979       };
21980     } catch (...) {
21981       {
21982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21983       };
21984     }
21985   }
21986
21987   jresult = (void *)result;
21988   return jresult;
21989 }
21990
21991
21992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_Assign(void * jarg1, void * jarg2) {
21993   void * jresult ;
21994   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21995   Dali::WheelEvent *arg2 = 0 ;
21996   Dali::WheelEvent *result = 0 ;
21997
21998   arg1 = (Dali::WheelEvent *)jarg1;
21999   arg2 = (Dali::WheelEvent *)jarg2;
22000   if (!arg2) {
22001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
22002     return 0;
22003   }
22004   {
22005     try {
22006       result = (Dali::WheelEvent *) &(arg1)->operator =((Dali::WheelEvent const &)*arg2);
22007     } catch (std::out_of_range& e) {
22008       {
22009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22010       };
22011     } catch (std::exception& e) {
22012       {
22013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22014       };
22015     } catch (Dali::DaliException e) {
22016       {
22017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22018       };
22019     } catch (...) {
22020       {
22021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22022       };
22023     }
22024   }
22025
22026   jresult = (void *)result;
22027   return jresult;
22028 }
22029
22030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_New(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
22031   void * jresult ;
22032   Dali::WheelEvent::Type arg1 ;
22033   int arg2 ;
22034   unsigned int arg3 ;
22035   Dali::Vector2 arg4 ;
22036   int arg5 ;
22037   unsigned int arg6 ;
22038   Dali::Vector2 *argp4 ;
22039   Dali::WheelEvent result;
22040
22041   arg1 = (Dali::WheelEvent::Type)jarg1;
22042   arg2 = (int)jarg2;
22043   arg3 = (unsigned int)jarg3;
22044   argp4 = (Dali::Vector2 *)jarg4;
22045   if (!argp4) {
22046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
22047     return 0;
22048   }
22049   arg4 = *argp4;
22050   arg5 = (int)jarg5;
22051   arg6 = (unsigned int)jarg6;
22052   {
22053     try {
22054       result = DevelWheelEvent::New(arg1,arg2,arg3,arg4,arg5,arg6);
22055     } CALL_CATCH_EXCEPTION(0);
22056   }
22057
22058   jresult = new Dali::WheelEvent((const Dali::WheelEvent &)result);
22059   return jresult;
22060 }
22061
22062
22063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
22064   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
22065
22066   arg1 = (Dali::WheelEvent *)jarg1;
22067   {
22068     try {
22069       delete arg1;
22070     } CALL_CATCH_EXCEPTION();
22071   }
22072
22073 }
22074
22075
22076 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
22077   bool jresult ;
22078   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
22079   bool result;
22080
22081   arg1 = (Dali::WheelEvent *)jarg1;
22082   {
22083     try {
22084       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
22085     } CALL_CATCH_EXCEPTION(0);
22086   }
22087
22088   jresult = result;
22089   return jresult;
22090 }
22091
22092
22093 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
22094   bool jresult ;
22095   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
22096   bool result;
22097
22098   arg1 = (Dali::WheelEvent *)jarg1;
22099   {
22100     try {
22101       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
22102     } catch (std::out_of_range& e) {
22103       {
22104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22105       };
22106     } catch (std::exception& e) {
22107       {
22108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22109       };
22110     } catch (Dali::DaliException e) {
22111       {
22112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22113       };
22114     } catch (...) {
22115       {
22116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22117       };
22118     }
22119   }
22120
22121   jresult = result;
22122   return jresult;
22123 }
22124
22125
22126 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
22127   bool jresult ;
22128   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
22129   bool result;
22130
22131   arg1 = (Dali::WheelEvent *)jarg1;
22132   {
22133     try {
22134       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
22135     } catch (std::out_of_range& e) {
22136       {
22137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22138       };
22139     } catch (std::exception& e) {
22140       {
22141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22142       };
22143     } catch (Dali::DaliException e) {
22144       {
22145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22146       };
22147     } catch (...) {
22148       {
22149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22150       };
22151     }
22152   }
22153
22154   jresult = result;
22155   return jresult;
22156 }
22157
22158
22159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
22160   int jresult ;
22161   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
22162   Dali::WheelEvent::Type result;
22163
22164   arg1 = (Dali::WheelEvent *)jarg1;
22165   {
22166     try {
22167       result = ((Dali::WheelEvent const *)arg1)->GetType();
22168     } catch (std::out_of_range& e) {
22169       {
22170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22171       };
22172     } catch (std::exception& e) {
22173       {
22174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22175       };
22176     } catch (Dali::DaliException e) {
22177       {
22178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22179       };
22180     } catch (...) {
22181       {
22182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22183       };
22184     }
22185   }
22186
22187   jresult = (int)result;
22188   return jresult;
22189 }
22190
22191
22192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
22193   int jresult ;
22194   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
22195   int result;
22196
22197   arg1 = (Dali::WheelEvent *)jarg1;
22198   {
22199     try {
22200       result = ((Dali::WheelEvent const *)arg1)->GetDirection();
22201     } catch (std::out_of_range& e) {
22202       {
22203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22204       };
22205     } catch (std::exception& e) {
22206       {
22207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22208       };
22209     } catch (Dali::DaliException e) {
22210       {
22211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22212       };
22213     } catch (...) {
22214       {
22215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22216       };
22217     }
22218   }
22219
22220   jresult = result;
22221   return jresult;
22222 }
22223
22224
22225 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
22226   unsigned int jresult ;
22227   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
22228   unsigned int result;
22229
22230   arg1 = (Dali::WheelEvent *)jarg1;
22231   {
22232     try {
22233       result = ((Dali::WheelEvent const *)arg1)->GetModifiers();
22234     } CALL_CATCH_EXCEPTION(0);
22235   }
22236
22237   jresult = result;
22238   return jresult;
22239 }
22240
22241
22242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
22243   void * jresult ;
22244   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
22245   Dali::Vector2 *result = 0 ;
22246
22247   arg1 = (Dali::WheelEvent *)jarg1;
22248   {
22249     try {
22250       result = (Dali::Vector2 *) &((Dali::WheelEvent const *)arg1)->GetPoint();
22251     } CALL_CATCH_EXCEPTION(0);
22252   }
22253
22254   jresult = (void *)result;
22255   return jresult;
22256 }
22257
22258
22259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_delta_get(void * jarg1) {
22260   int jresult ;
22261   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
22262   int result;
22263
22264   arg1 = (Dali::WheelEvent *)jarg1;
22265   {
22266     try {
22267       result = ((Dali::WheelEvent const *)arg1)->GetDelta();
22268     } catch (std::out_of_range& e) {
22269       {
22270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22271       };
22272     } catch (std::exception& e) {
22273       {
22274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22275       };
22276     } catch (Dali::DaliException e) {
22277       {
22278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22279       };
22280     } catch (...) {
22281       {
22282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22283       };
22284     }
22285   }
22286
22287   jresult = result;
22288   return jresult;
22289 }
22290
22291
22292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
22293   unsigned int jresult ;
22294   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
22295   unsigned int result;
22296
22297   arg1 = (Dali::WheelEvent *)jarg1;
22298   {
22299     try {
22300       result = ((Dali::WheelEvent const *)arg1)->GetTime();
22301     } catch (std::out_of_range& e) {
22302       {
22303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22304       };
22305     } catch (std::exception& e) {
22306       {
22307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22308       };
22309     } catch (Dali::DaliException e) {
22310       {
22311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22312       };
22313     } catch (...) {
22314       {
22315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22316       };
22317     }
22318   }
22319
22320   jresult = result;
22321   return jresult;
22322 }
22323
22324 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
22325   char * jresult ;
22326   Dali::KeyEvent *arg1 = 0 ;
22327   std::string result;
22328
22329   arg1 = (Dali::KeyEvent *)jarg1;
22330   if (!arg1) {
22331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
22332     return 0;
22333   }
22334   {
22335     try {
22336       result = arg1->GetDeviceName();
22337     } CALL_CATCH_EXCEPTION(0);
22338   }
22339
22340   jresult = SWIG_csharp_string_callback((&result)->c_str());
22341   return jresult;
22342 }
22343
22344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
22345   int jresult ;
22346   Dali::KeyEvent *arg1 = 0 ;
22347   Dali::Device::Class::Type result;
22348
22349   arg1 = (Dali::KeyEvent *)jarg1;
22350   if (!arg1) {
22351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
22352     return 0;
22353   }
22354   {
22355     try {
22356       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
22357     } CALL_CATCH_EXCEPTION(0);
22358   }
22359
22360   jresult = (int)result;
22361   return jresult;
22362 }
22363
22364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
22365   int jresult ;
22366   Dali::KeyEvent *arg1 = 0 ;
22367   Dali::Device::Subclass::Type result;
22368
22369   arg1 = (Dali::KeyEvent *)jarg1;
22370   if (!arg1) {
22371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
22372     return 0;
22373   }
22374   {
22375     try {
22376       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
22377     } CALL_CATCH_EXCEPTION(0);
22378   }
22379
22380   jresult = (int)result;
22381   return jresult;
22382 }
22383
22384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
22385   Dali::Actor arg1 ;
22386   Dali::Actor *argp1 ;
22387
22388   argp1 = (Dali::Actor *)jarg1;
22389   if (!argp1) {
22390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
22391     return ;
22392   }
22393   arg1 = *argp1;
22394   {
22395     try {
22396       arg1.Raise();
22397     } CALL_CATCH_EXCEPTION();
22398   }
22399
22400 }
22401
22402
22403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
22404   Dali::Actor arg1 ;
22405   Dali::Actor *argp1 ;
22406
22407   argp1 = (Dali::Actor *)jarg1;
22408   if (!argp1) {
22409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
22410     return ;
22411   }
22412   arg1 = *argp1;
22413   {
22414     try {
22415       arg1.Lower();
22416     } CALL_CATCH_EXCEPTION();
22417   }
22418
22419 }
22420
22421
22422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
22423   Dali::Actor arg1 ;
22424   Dali::Actor *argp1 ;
22425
22426   argp1 = (Dali::Actor *)jarg1;
22427   if (!argp1) {
22428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
22429     return ;
22430   }
22431   arg1 = *argp1;
22432   {
22433     try {
22434       arg1.RaiseToTop();
22435     } CALL_CATCH_EXCEPTION();
22436   }
22437
22438 }
22439
22440
22441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
22442   Dali::Actor arg1 ;
22443   Dali::Actor *argp1 ;
22444
22445   argp1 = (Dali::Actor *)jarg1;
22446   if (!argp1) {
22447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
22448     return ;
22449   }
22450   arg1 = *argp1;
22451   {
22452     try {
22453       arg1.LowerToBottom();
22454     } CALL_CATCH_EXCEPTION();
22455   }
22456
22457 }
22458
22459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
22460   Dali::Actor arg1 ;
22461   Dali::Actor arg2 ;
22462   Dali::Actor *argp1 ;
22463   Dali::Actor *argp2 ;
22464
22465   argp1 = (Dali::Actor *)jarg1;
22466   if (!argp1) {
22467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
22468     return ;
22469   }
22470   arg1 = *argp1;
22471   argp2 = (Dali::Actor *)jarg2;
22472   if (!argp2) {
22473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
22474     return ;
22475   }
22476   arg2 = *argp2;
22477   {
22478     try {
22479       arg1.RaiseAbove(arg2);
22480     } CALL_CATCH_EXCEPTION();
22481   }
22482
22483 }
22484
22485
22486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
22487   Dali::Actor arg1 ;
22488   Dali::Actor arg2 ;
22489   Dali::Actor *argp1 ;
22490   Dali::Actor *argp2 ;
22491
22492   argp1 = (Dali::Actor *)jarg1;
22493   if (!argp1) {
22494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
22495     return ;
22496   }
22497   arg1 = *argp1;
22498   argp2 = (Dali::Actor *)jarg2;
22499   if (!argp2) {
22500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
22501     return ;
22502   }
22503   arg2 = *argp2;
22504   {
22505     try {
22506       arg1.LowerBelow(arg2);
22507     } CALL_CATCH_EXCEPTION();
22508   }
22509
22510 }
22511
22512
22513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
22514   void * jresult ;
22515   Dali::Actor arg1 ;
22516   Dali::Actor *argp1 ;
22517   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
22518
22519   argp1 = (Dali::Actor *)jarg1;
22520   if (!argp1) {
22521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
22522     return 0;
22523   }
22524   arg1 = *argp1;
22525   {
22526     try {
22527       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
22528     } CALL_CATCH_EXCEPTION(0);
22529   }
22530
22531   jresult = (void *)result;
22532   return jresult;
22533 }
22534
22535
22536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
22537   void * jresult ;
22538   Dali::Actor *arg1 ;
22539   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
22540
22541   arg1 = (Dali::Actor *)jarg1;
22542   {
22543     try {
22544       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
22545     } CALL_CATCH_EXCEPTION(0);
22546   }
22547
22548   jresult = (void *)result;
22549   return jresult;
22550 }
22551
22552
22553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
22554   int jresult ;
22555   int result;
22556
22557   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
22558   jresult = (int)result;
22559   return jresult;
22560 }
22561
22562
22563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
22564   int jresult ;
22565   int result;
22566
22567   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
22568   jresult = (int)result;
22569   return jresult;
22570 }
22571
22572
22573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
22574   int jresult ;
22575   int result;
22576
22577   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
22578   jresult = (int)result;
22579   return jresult;
22580 }
22581
22582
22583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
22584   int jresult ;
22585   int result;
22586
22587   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
22588   jresult = (int)result;
22589   return jresult;
22590 }
22591
22592
22593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
22594   int jresult ;
22595   int result;
22596
22597   result = (int)Dali::Actor::Property::ANCHOR_POINT;
22598   jresult = (int)result;
22599   return jresult;
22600 }
22601
22602
22603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
22604   int jresult ;
22605   int result;
22606
22607   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
22608   jresult = (int)result;
22609   return jresult;
22610 }
22611
22612
22613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
22614   int jresult ;
22615   int result;
22616
22617   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
22618   jresult = (int)result;
22619   return jresult;
22620 }
22621
22622
22623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
22624   int jresult ;
22625   int result;
22626
22627   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
22628   jresult = (int)result;
22629   return jresult;
22630 }
22631
22632
22633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
22634   int jresult ;
22635   int result;
22636
22637   result = (int)Dali::Actor::Property::SIZE;
22638   jresult = (int)result;
22639   return jresult;
22640 }
22641
22642
22643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
22644   int jresult ;
22645   int result;
22646
22647   result = (int)Dali::Actor::Property::SIZE_WIDTH;
22648   jresult = (int)result;
22649   return jresult;
22650 }
22651
22652
22653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
22654   int jresult ;
22655   int result;
22656
22657   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
22658   jresult = (int)result;
22659   return jresult;
22660 }
22661
22662
22663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
22664   int jresult ;
22665   int result;
22666
22667   result = (int)Dali::Actor::Property::SIZE_DEPTH;
22668   jresult = (int)result;
22669   return jresult;
22670 }
22671
22672
22673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
22674   int jresult ;
22675   int result;
22676
22677   result = (int)Dali::Actor::Property::POSITION;
22678   jresult = (int)result;
22679   return jresult;
22680 }
22681
22682
22683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
22684   int jresult ;
22685   int result;
22686
22687   result = (int)Dali::Actor::Property::POSITION_X;
22688   jresult = (int)result;
22689   return jresult;
22690 }
22691
22692
22693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
22694   int jresult ;
22695   int result;
22696
22697   result = (int)Dali::Actor::Property::POSITION_Y;
22698   jresult = (int)result;
22699   return jresult;
22700 }
22701
22702
22703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
22704   int jresult ;
22705   int result;
22706
22707   result = (int)Dali::Actor::Property::POSITION_Z;
22708   jresult = (int)result;
22709   return jresult;
22710 }
22711
22712
22713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
22714   int jresult ;
22715   int result;
22716
22717   result = (int)Dali::Actor::Property::WORLD_POSITION;
22718   jresult = (int)result;
22719   return jresult;
22720 }
22721
22722
22723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
22724   int jresult ;
22725   int result;
22726
22727   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
22728   jresult = (int)result;
22729   return jresult;
22730 }
22731
22732
22733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
22734   int jresult ;
22735   int result;
22736
22737   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
22738   jresult = (int)result;
22739   return jresult;
22740 }
22741
22742
22743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
22744   int jresult ;
22745   int result;
22746
22747   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
22748   jresult = (int)result;
22749   return jresult;
22750 }
22751
22752
22753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
22754   int jresult ;
22755   int result;
22756
22757   result = (int)Dali::Actor::Property::ORIENTATION;
22758   jresult = (int)result;
22759   return jresult;
22760 }
22761
22762
22763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
22764   int jresult ;
22765   int result;
22766
22767   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
22768   jresult = (int)result;
22769   return jresult;
22770 }
22771
22772
22773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
22774   int jresult ;
22775   int result;
22776
22777   result = (int)Dali::Actor::Property::SCALE;
22778   jresult = (int)result;
22779   return jresult;
22780 }
22781
22782
22783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
22784   int jresult ;
22785   int result;
22786
22787   result = (int)Dali::Actor::Property::SCALE_X;
22788   jresult = (int)result;
22789   return jresult;
22790 }
22791
22792
22793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
22794   int jresult ;
22795   int result;
22796
22797   result = (int)Dali::Actor::Property::SCALE_Y;
22798   jresult = (int)result;
22799   return jresult;
22800 }
22801
22802
22803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
22804   int jresult ;
22805   int result;
22806
22807   result = (int)Dali::Actor::Property::SCALE_Z;
22808   jresult = (int)result;
22809   return jresult;
22810 }
22811
22812
22813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
22814   int jresult ;
22815   int result;
22816
22817   result = (int)Dali::Actor::Property::WORLD_SCALE;
22818   jresult = (int)result;
22819   return jresult;
22820 }
22821
22822
22823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
22824   int jresult ;
22825   int result;
22826
22827   result = (int)Dali::Actor::Property::VISIBLE;
22828   jresult = (int)result;
22829   return jresult;
22830 }
22831
22832
22833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
22834   int jresult ;
22835   int result;
22836
22837   result = (int)Dali::Actor::Property::COLOR;
22838   jresult = (int)result;
22839   return jresult;
22840 }
22841
22842
22843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
22844   int jresult ;
22845   int result;
22846
22847   result = (int)Dali::Actor::Property::COLOR_RED;
22848   jresult = (int)result;
22849   return jresult;
22850 }
22851
22852
22853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
22854   int jresult ;
22855   int result;
22856
22857   result = (int)Dali::Actor::Property::COLOR_GREEN;
22858   jresult = (int)result;
22859   return jresult;
22860 }
22861
22862
22863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
22864   int jresult ;
22865   int result;
22866
22867   result = (int)Dali::Actor::Property::COLOR_BLUE;
22868   jresult = (int)result;
22869   return jresult;
22870 }
22871
22872
22873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
22874   int jresult ;
22875   int result;
22876
22877   result = (int)Dali::Actor::Property::COLOR_ALPHA;
22878   jresult = (int)result;
22879   return jresult;
22880 }
22881
22882
22883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
22884   int jresult ;
22885   int result;
22886
22887   result = (int)Dali::Actor::Property::WORLD_COLOR;
22888   jresult = (int)result;
22889   return jresult;
22890 }
22891
22892
22893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
22894   int jresult ;
22895   int result;
22896
22897   result = (int)Dali::Actor::Property::WORLD_MATRIX;
22898   jresult = (int)result;
22899   return jresult;
22900 }
22901
22902
22903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
22904   int jresult ;
22905   int result;
22906
22907   result = (int)Dali::Actor::Property::NAME;
22908   jresult = (int)result;
22909   return jresult;
22910 }
22911
22912
22913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
22914   int jresult ;
22915   int result;
22916
22917   result = (int)Dali::Actor::Property::SENSITIVE;
22918   jresult = (int)result;
22919   return jresult;
22920 }
22921
22922
22923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_USER_INTERACTION_ENABLED_get() {
22924   int jresult ;
22925   int result;
22926
22927   result = (int)Dali::DevelActor::Property::USER_INTERACTION_ENABLED;
22928   jresult = (int)result;
22929   return jresult;
22930 }
22931
22932
22933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
22934   int jresult ;
22935   int result;
22936
22937   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
22938   jresult = (int)result;
22939   return jresult;
22940 }
22941
22942
22943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
22944   int jresult ;
22945   int result;
22946
22947   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
22948   jresult = (int)result;
22949   return jresult;
22950 }
22951
22952
22953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
22954   int jresult ;
22955   int result;
22956
22957   result = (int)Dali::Actor::Property::INHERIT_SCALE;
22958   jresult = (int)result;
22959   return jresult;
22960 }
22961
22962
22963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
22964   int jresult ;
22965   int result;
22966
22967   result = (int)Dali::Actor::Property::COLOR_MODE;
22968   jresult = (int)result;
22969   return jresult;
22970 }
22971
22972
22973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
22974   int jresult ;
22975   int result;
22976
22977   result = (int)Dali::Actor::Property::DRAW_MODE;
22978   jresult = (int)result;
22979   return jresult;
22980 }
22981
22982
22983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
22984   int jresult ;
22985   int result;
22986
22987   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
22988   jresult = (int)result;
22989   return jresult;
22990 }
22991
22992
22993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
22994   int jresult ;
22995   int result;
22996
22997   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
22998   jresult = (int)result;
22999   return jresult;
23000 }
23001
23002
23003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
23004   int jresult ;
23005   int result;
23006
23007   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
23008   jresult = (int)result;
23009   return jresult;
23010 }
23011
23012
23013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
23014   int jresult ;
23015   int result;
23016
23017   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
23018   jresult = (int)result;
23019   return jresult;
23020 }
23021
23022
23023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
23024   int jresult ;
23025   int result;
23026
23027   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
23028   jresult = (int)result;
23029   return jresult;
23030 }
23031
23032
23033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
23034   int jresult ;
23035   int result;
23036
23037   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
23038   jresult = (int)result;
23039   return jresult;
23040 }
23041
23042
23043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
23044   int jresult ;
23045   int result;
23046
23047   result = (int)Dali::Actor::Property::PADDING;
23048   jresult = (int)result;
23049   return jresult;
23050 }
23051
23052
23053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
23054   int jresult ;
23055   int result;
23056
23057   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
23058   jresult = (int)result;
23059   return jresult;
23060 }
23061
23062
23063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
23064   int jresult ;
23065   int result;
23066
23067   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
23068   jresult = (int)result;
23069   return jresult;
23070 }
23071
23072
23073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
23074   int jresult ;
23075   int result;
23076
23077   result = (int)Dali::Actor::Property::INHERIT_POSITION;
23078   jresult = (int)result;
23079   return jresult;
23080 }
23081
23082
23083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
23084   int jresult ;
23085   int result;
23086
23087   result = (int)Dali::Actor::Property::CLIPPING_MODE;
23088   jresult = (int)result;
23089   return jresult;
23090 }
23091
23092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_UPDATE_AREA_HINT_get() {
23093   int jresult ;
23094   int result;
23095
23096   result = (int)Dali::Actor::Property::UPDATE_AREA_HINT;
23097   jresult = (int)result;
23098   return jresult;
23099 }
23100
23101 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_OPACITY_get() {
23102
23103   return Dali::Actor::Property::OPACITY;
23104 }
23105
23106 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SCREEN_POSITION_get() {
23107
23108   return Dali::Actor::Property::SCREEN_POSITION;
23109 }
23110
23111 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_POSITION_USES_ANCHOR_POINT_get() {
23112
23113   return Dali::Actor::Property::POSITION_USES_ANCHOR_POINT;
23114 }
23115
23116 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_INHERIT_LAYOUT_DIRECTION_get() {
23117   return Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION;
23118 }
23119
23120 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_LAYOUT_DIRECTION_get() {
23121   return Dali::Actor::Property::LAYOUT_DIRECTION;
23122 }
23123
23124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
23125   void * jresult ;
23126   Dali::Actor::Property *result = 0 ;
23127
23128   {
23129     try {
23130       result = (Dali::Actor::Property *)new Dali::Actor::Property();
23131     } CALL_CATCH_EXCEPTION(0);
23132   }
23133
23134   jresult = (void *)result;
23135   return jresult;
23136 }
23137
23138
23139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
23140   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
23141
23142   arg1 = (Dali::Actor::Property *)jarg1;
23143   {
23144     try {
23145       delete arg1;
23146     } CALL_CATCH_EXCEPTION();
23147   }
23148
23149 }
23150
23151
23152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
23153   void * jresult ;
23154   Dali::Actor *result = 0 ;
23155
23156   {
23157     try {
23158       result = (Dali::Actor *)new Dali::Actor();
23159     } CALL_CATCH_EXCEPTION(0);
23160   }
23161
23162   jresult = (void *)result;
23163   return jresult;
23164 }
23165
23166
23167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
23168   void * jresult ;
23169   Dali::Actor result;
23170
23171   {
23172     try {
23173       result = Dali::Actor::New();
23174     } CALL_CATCH_EXCEPTION(0);
23175   }
23176
23177   jresult = new Dali::Actor((const Dali::Actor &)result);
23178   return jresult;
23179 }
23180
23181
23182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
23183   void * jresult ;
23184   Dali::BaseHandle arg1 ;
23185   Dali::BaseHandle *argp1 ;
23186   Dali::Actor result;
23187
23188   argp1 = (Dali::BaseHandle *)jarg1;
23189   if (!argp1) {
23190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23191     return 0;
23192   }
23193   arg1 = *argp1;
23194   {
23195     try {
23196       result = Dali::Actor::DownCast(arg1);
23197     } CALL_CATCH_EXCEPTION(0);
23198   }
23199
23200   jresult = new Dali::Actor((const Dali::Actor &)result);
23201   return jresult;
23202 }
23203
23204
23205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
23206   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23207
23208   arg1 = (Dali::Actor *)jarg1;
23209   {
23210     try {
23211       delete arg1;
23212     } CALL_CATCH_EXCEPTION();
23213   }
23214
23215 }
23216
23217
23218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
23219   void * jresult ;
23220   Dali::Actor *arg1 = 0 ;
23221   Dali::Actor *result = 0 ;
23222
23223   arg1 = (Dali::Actor *)jarg1;
23224   if (!arg1) {
23225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
23226     return 0;
23227   }
23228   {
23229     try {
23230       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
23231     } CALL_CATCH_EXCEPTION(0);
23232   }
23233
23234   jresult = (void *)result;
23235   return jresult;
23236 }
23237
23238
23239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
23240   void * jresult ;
23241   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23242   Dali::Actor *arg2 = 0 ;
23243   Dali::Actor *result = 0 ;
23244
23245   if (!jarg1) {
23246     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23247     return 0;
23248   }
23249
23250   if (!jarg2) {
23251     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg2 is null!");
23252     return 0;
23253   }
23254
23255   arg1 = (Dali::Actor *)jarg1;
23256   arg2 = (Dali::Actor *)jarg2;
23257   {
23258     try {
23259       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
23260     } CALL_CATCH_EXCEPTION(0);
23261   }
23262
23263   jresult = (void *)result;
23264   return jresult;
23265 }
23266
23267
23268 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
23269   char * jresult ;
23270   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23271   std::string *result = 0 ;
23272   std::string name = "";
23273
23274   if (!jarg1) {
23275     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23276     return 0;
23277   }
23278
23279   arg1 = (Dali::Actor *)jarg1;
23280   {
23281     try {
23282       name = ((Dali::Actor const *)arg1)->GetProperty< std::string >( Dali::Actor::Property::NAME );
23283       result = (std::string *) &name;
23284       jresult = SWIG_csharp_string_callback(result->c_str());
23285     } CALL_CATCH_EXCEPTION(0);
23286   }
23287   return jresult;
23288 }
23289
23290
23291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
23292   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23293   std::string *arg2 = 0 ;
23294
23295   if (!jarg1) {
23296     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23297     return ;
23298   }
23299
23300   arg1 = (Dali::Actor *)jarg1;
23301   if (!jarg2) {
23302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23303     return ;
23304   }
23305   std::string arg2_str(jarg2);
23306   arg2 = &arg2_str;
23307   {
23308     try {
23309       (arg1)->SetProperty( Dali::Actor::Property::NAME, (std::string const &)*arg2);
23310     } CALL_CATCH_EXCEPTION();
23311   }
23312
23313
23314   //argout typemap for const std::string&
23315
23316 }
23317
23318
23319 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
23320   unsigned int jresult ;
23321   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23322   unsigned int result;
23323
23324   arg1 = (Dali::Actor *)jarg1;
23325
23326   if(!arg1) {
23327     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
23328     return -1;
23329   }
23330
23331   {
23332     try {
23333       result = (unsigned int)((Dali::Actor const *)arg1)->GetProperty< int >( Actor::Property::ID );
23334     } CALL_CATCH_EXCEPTION(0);
23335   }
23336
23337   jresult = result;
23338   return jresult;
23339 }
23340
23341
23342 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
23343   bool jresult ;
23344   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23345   bool result;
23346
23347   if (!jarg1) {
23348     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23349     return 0;
23350   }
23351
23352   arg1 = (Dali::Actor *)jarg1;
23353   {
23354     try {
23355       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_ROOT );
23356     } CALL_CATCH_EXCEPTION(0);
23357   }
23358
23359   jresult = result;
23360   return jresult;
23361 }
23362
23363
23364 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
23365   bool jresult ;
23366   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23367   bool result;
23368
23369   if (!jarg1) {
23370     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23371     return 0;
23372   }
23373
23374   arg1 = (Dali::Actor *)jarg1;
23375   {
23376     try {
23377       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE );
23378     } CALL_CATCH_EXCEPTION(0);
23379   }
23380
23381   jresult = result;
23382   return jresult;
23383 }
23384
23385
23386 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
23387   bool jresult ;
23388   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23389   bool result;
23390
23391   if (!jarg1) {
23392     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23393     return 0;
23394   }
23395
23396   arg1 = (Dali::Actor *)jarg1;
23397   {
23398     try {
23399       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_LAYER );
23400     } CALL_CATCH_EXCEPTION(0);
23401   }
23402
23403   jresult = result;
23404   return jresult;
23405 }
23406
23407
23408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
23409   void * jresult ;
23410   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23411   Dali::Layer result;
23412
23413   if (!jarg1) {
23414     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23415     return 0;
23416   }
23417
23418   arg1 = (Dali::Actor *)jarg1;
23419   {
23420     try {
23421       result = (arg1)->GetLayer();
23422     } CALL_CATCH_EXCEPTION(0);
23423   }
23424
23425   jresult = new Dali::Layer((const Dali::Layer &)result);
23426   return jresult;
23427 }
23428
23429
23430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
23431   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23432   Dali::Actor arg2 ;
23433
23434   if (!jarg1) {
23435     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23436     return ;
23437   }
23438   if (!jarg2) {
23439     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg2 is null!");
23440     return ;
23441   }
23442
23443   arg1 = (Dali::Actor *)jarg1;
23444   arg2 = *((Dali::Actor *)jarg2);
23445   {
23446     try {
23447       (arg1)->Add(arg2);
23448     } CALL_CATCH_EXCEPTION();
23449   }
23450
23451 }
23452
23453
23454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
23455   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23456   Dali::Actor arg2 ;
23457
23458   if (!jarg1) {
23459     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23460     return ;
23461   }
23462   if (!jarg2) {
23463     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg2 is null!");
23464     return ;
23465   }
23466
23467   arg1 = (Dali::Actor *)jarg1;
23468   arg2 = *((Dali::Actor *)jarg2);
23469   {
23470     try {
23471       (arg1)->Remove(arg2);
23472     } CALL_CATCH_EXCEPTION();
23473   }
23474
23475 }
23476
23477
23478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
23479   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23480
23481   if (!jarg1) {
23482     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23483     return ;
23484   }
23485
23486   arg1 = (Dali::Actor *)jarg1;
23487   {
23488     try {
23489       (arg1)->Unparent();
23490     } CALL_CATCH_EXCEPTION();
23491   }
23492
23493 }
23494
23495
23496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
23497   unsigned int jresult ;
23498   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23499   unsigned int result;
23500
23501   if (!jarg1) {
23502     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23503     return 0;
23504   }
23505
23506   arg1 = (Dali::Actor *)jarg1;
23507   {
23508     try {
23509       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
23510     } CALL_CATCH_EXCEPTION(0);
23511   }
23512
23513   jresult = result;
23514   return jresult;
23515 }
23516
23517
23518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
23519   void * jresult ;
23520   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23521   unsigned int arg2 ;
23522   Dali::Actor result;
23523
23524   if (!jarg1) {
23525     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23526     return 0;
23527   }
23528
23529   arg1 = (Dali::Actor *)jarg1;
23530   arg2 = (unsigned int)jarg2;
23531   {
23532     try {
23533       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
23534     } CALL_CATCH_EXCEPTION(0);
23535   }
23536
23537   jresult = new Dali::Actor((const Dali::Actor &)result);
23538   return jresult;
23539 }
23540
23541
23542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
23543   void * jresult ;
23544   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23545   std::string *arg2 = 0 ;
23546   Dali::Actor result;
23547
23548   if (!jarg1) {
23549     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23550     return 0;
23551   }
23552
23553   arg1 = (Dali::Actor *)jarg1;
23554   if (!jarg2) {
23555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23556     return 0;
23557   }
23558   std::string arg2_str(jarg2);
23559   arg2 = &arg2_str;
23560   {
23561     try {
23562       result = (arg1)->FindChildByName((std::string const &)*arg2);
23563     } CALL_CATCH_EXCEPTION(0);
23564   }
23565
23566   jresult = new Dali::Actor((const Dali::Actor &)result);
23567
23568   //argout typemap for const std::string&
23569
23570   return jresult;
23571 }
23572
23573
23574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
23575   void * jresult ;
23576   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23577   unsigned int arg2 ;
23578   Dali::Actor result;
23579
23580   if (!jarg1) {
23581     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23582     return 0;
23583   }
23584
23585   arg1 = (Dali::Actor *)jarg1;
23586   arg2 = (unsigned int)jarg2;
23587   {
23588     try {
23589       result = (arg1)->FindChildById(arg2);
23590     } CALL_CATCH_EXCEPTION(0);
23591   }
23592
23593   jresult = new Dali::Actor((const Dali::Actor &)result);
23594   return jresult;
23595 }
23596
23597
23598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
23599   void * jresult ;
23600   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23601   Dali::Actor result;
23602
23603   if (!jarg1) {
23604     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23605     return 0;
23606   }
23607
23608   arg1 = (Dali::Actor *)jarg1;
23609   {
23610     try {
23611       result = ((Dali::Actor const *)arg1)->GetParent();
23612     } CALL_CATCH_EXCEPTION(0);
23613   }
23614
23615   jresult = new Dali::Actor((const Dali::Actor &)result);
23616   return jresult;
23617 }
23618
23619
23620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
23621   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23622   Dali::Vector3 *arg2 = 0 ;
23623
23624   if (!jarg1) {
23625     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23626     return ;
23627   }
23628
23629   arg1 = (Dali::Actor *)jarg1;
23630   arg2 = (Dali::Vector3 *)jarg2;
23631   if (!arg2) {
23632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23633     return ;
23634   }
23635   {
23636     try {
23637       (arg1)->SetProperty( Actor::Property::PARENT_ORIGIN,(Dali::Vector3 const &)*arg2);
23638     } CALL_CATCH_EXCEPTION();
23639   }
23640
23641 }
23642
23643
23644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
23645   void * jresult ;
23646   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23647   Dali::Vector3 result;
23648
23649   if (!jarg1) {
23650     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23651     return 0;
23652   }
23653
23654   arg1 = (Dali::Actor *)jarg1;
23655   {
23656     try {
23657       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN );
23658     } CALL_CATCH_EXCEPTION(0);
23659   }
23660
23661   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23662   return jresult;
23663 }
23664
23665
23666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
23667   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23668   Dali::Vector3 *arg2 = 0 ;
23669
23670   if (!jarg1) {
23671     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23672     return ;
23673   }
23674
23675   arg1 = (Dali::Actor *)jarg1;
23676   arg2 = (Dali::Vector3 *)jarg2;
23677   if (!arg2) {
23678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23679     return ;
23680   }
23681   {
23682     try {
23683       (arg1)->SetProperty( Actor::Property::ANCHOR_POINT,(Dali::Vector3 const &)*arg2);
23684     } CALL_CATCH_EXCEPTION();
23685   }
23686
23687 }
23688
23689
23690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
23691   void * jresult ;
23692   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23693   Dali::Vector3 result;
23694
23695   if (!jarg1) {
23696     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23697     return 0;
23698   }
23699
23700   arg1 = (Dali::Actor *)jarg1;
23701   {
23702     try {
23703       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
23704     } CALL_CATCH_EXCEPTION(0);
23705   }
23706
23707   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23708   return jresult;
23709 }
23710
23711
23712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
23713   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23714   float arg2 ;
23715   float arg3 ;
23716
23717   if (!jarg1) {
23718     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23719     return ;
23720   }
23721
23722   arg1 = (Dali::Actor *)jarg1;
23723   arg2 = (float)jarg2;
23724   arg3 = (float)jarg3;
23725   {
23726     try {
23727       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector2(arg2,arg3) );
23728     } CALL_CATCH_EXCEPTION();
23729   }
23730
23731 }
23732
23733
23734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
23735   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23736   float arg2 ;
23737   float arg3 ;
23738   float arg4 ;
23739
23740   if (!jarg1) {
23741     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23742     return ;
23743   }
23744
23745   arg1 = (Dali::Actor *)jarg1;
23746   arg2 = (float)jarg2;
23747   arg3 = (float)jarg3;
23748   arg4 = (float)jarg4;
23749   {
23750     try {
23751       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector3(arg2,arg3,arg4) );
23752     } CALL_CATCH_EXCEPTION();
23753   }
23754
23755 }
23756
23757
23758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
23759   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23760   Dali::Vector2 *arg2 = 0 ;
23761
23762   if (!jarg1) {
23763     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23764     return ;
23765   }
23766
23767   arg1 = (Dali::Actor *)jarg1;
23768   arg2 = (Dali::Vector2 *)jarg2;
23769   if (!arg2) {
23770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
23771     return ;
23772   }
23773   {
23774     try {
23775       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector2 const &)*arg2);
23776     } CALL_CATCH_EXCEPTION();
23777   }
23778
23779 }
23780
23781
23782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
23783   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23784   Dali::Vector3 *arg2 = 0 ;
23785
23786   if (!jarg1) {
23787     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23788     return ;
23789   }
23790
23791   arg1 = (Dali::Actor *)jarg1;
23792   arg2 = (Dali::Vector3 *)jarg2;
23793   if (!arg2) {
23794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23795     return ;
23796   }
23797   {
23798     try {
23799       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector3 const &)*arg2);
23800     } CALL_CATCH_EXCEPTION();
23801   }
23802
23803 }
23804
23805
23806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
23807   void * jresult ;
23808   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23809   Dali::Vector3 result;
23810
23811   if (!jarg1) {
23812     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23813     return 0;
23814   }
23815
23816   arg1 = (Dali::Actor *)jarg1;
23817   {
23818     try {
23819       result = ((Dali::Actor const *)arg1)->GetTargetSize();
23820     } CALL_CATCH_EXCEPTION(0);
23821   }
23822
23823   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23824   return jresult;
23825 }
23826
23827
23828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
23829   void * jresult ;
23830   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23831   Dali::Vector3 result;
23832
23833   if (!jarg1) {
23834     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23835     return 0;
23836   }
23837
23838   arg1 = (Dali::Actor *)jarg1;
23839   {
23840     try {
23841       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
23842     } CALL_CATCH_EXCEPTION(0);
23843   }
23844
23845   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23846   return jresult;
23847 }
23848
23849
23850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
23851   void * jresult ;
23852   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23853   Dali::Vector3 result;
23854
23855   if (!jarg1) {
23856     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23857     return 0;
23858   }
23859
23860   arg1 = (Dali::Actor *)jarg1;
23861   {
23862     try {
23863       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
23864     } CALL_CATCH_EXCEPTION(0);
23865   }
23866
23867   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23868   return jresult;
23869 }
23870
23871
23872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
23873   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23874   float arg2 ;
23875   float arg3 ;
23876
23877   if (!jarg1) {
23878     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23879     return ;
23880   }
23881
23882   arg1 = (Dali::Actor *)jarg1;
23883   arg2 = (float)jarg2;
23884   arg3 = (float)jarg3;
23885   {
23886     try {
23887       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector2( arg2, arg3 ) );
23888     } CALL_CATCH_EXCEPTION();
23889   }
23890
23891 }
23892
23893
23894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
23895   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23896   float arg2 ;
23897   float arg3 ;
23898   float arg4 ;
23899
23900   if (!jarg1) {
23901     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23902     return ;
23903   }
23904
23905   arg1 = (Dali::Actor *)jarg1;
23906   arg2 = (float)jarg2;
23907   arg3 = (float)jarg3;
23908   arg4 = (float)jarg4;
23909   {
23910     try {
23911       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector3( arg2, arg3, arg4 ) );
23912     } CALL_CATCH_EXCEPTION();
23913   }
23914
23915 }
23916
23917
23918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
23919   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23920   Dali::Vector3 *arg2 = 0 ;
23921
23922   if (!jarg1) {
23923     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23924     return ;
23925   }
23926
23927   arg1 = (Dali::Actor *)jarg1;
23928   arg2 = (Dali::Vector3 *)jarg2;
23929   if (!arg2) {
23930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23931     return ;
23932   }
23933   {
23934     try {
23935       (arg1)->SetProperty( Actor::Property::POSITION, (Dali::Vector3 const &)*arg2 );
23936     } CALL_CATCH_EXCEPTION();
23937   }
23938
23939 }
23940
23941
23942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
23943   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23944   float arg2 ;
23945
23946   if (!jarg1) {
23947     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23948     return ;
23949   }
23950
23951   arg1 = (Dali::Actor *)jarg1;
23952   arg2 = (float)jarg2;
23953   {
23954     try {
23955       (arg1)->SetProperty( Actor::Property::POSITION_X, (arg2) );
23956     } CALL_CATCH_EXCEPTION();
23957   }
23958
23959 }
23960
23961
23962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
23963   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23964   float arg2 ;
23965
23966   if (!jarg1) {
23967     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23968     return ;
23969   }
23970
23971   arg1 = (Dali::Actor *)jarg1;
23972   arg2 = (float)jarg2;
23973   {
23974     try {
23975       (arg1)->SetProperty( Actor::Property::POSITION_Y, arg2 );
23976     } CALL_CATCH_EXCEPTION();
23977   }
23978
23979 }
23980
23981
23982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
23983   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23984   float arg2 ;
23985
23986   if (!jarg1) {
23987     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
23988     return ;
23989   }
23990
23991   arg1 = (Dali::Actor *)jarg1;
23992   arg2 = (float)jarg2;
23993   {
23994     try {
23995       (arg1)->SetProperty( Actor::Property::POSITION_Z, arg2 );
23996     } CALL_CATCH_EXCEPTION();
23997   }
23998
23999 }
24000
24001
24002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
24003   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24004   Dali::Vector3 *arg2 = 0 ;
24005
24006   if (!jarg1) {
24007     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24008     return ;
24009   }
24010
24011   arg1 = (Dali::Actor *)jarg1;
24012   arg2 = (Dali::Vector3 *)jarg2;
24013   if (!arg2) {
24014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
24015     return ;
24016   }
24017   {
24018     try {
24019       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
24020     } CALL_CATCH_EXCEPTION();
24021   }
24022
24023 }
24024
24025
24026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
24027   void * jresult ;
24028   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24029   Dali::Vector3 result;
24030
24031   if (!jarg1) {
24032     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24033     return 0;
24034   }
24035
24036   arg1 = (Dali::Actor *)jarg1;
24037   {
24038     try {
24039       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
24040     } CALL_CATCH_EXCEPTION(0);
24041   }
24042
24043   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
24044   return jresult;
24045 }
24046
24047
24048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
24049   void * jresult ;
24050   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24051   Dali::Vector3 result;
24052
24053   if (!jarg1) {
24054     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24055     return 0;
24056   }
24057
24058   arg1 = (Dali::Actor *)jarg1;
24059   {
24060     try {
24061       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION );
24062     } CALL_CATCH_EXCEPTION(0);
24063   }
24064
24065   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
24066   return jresult;
24067 }
24068
24069
24070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, bool jarg2) {
24071   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24072   bool arg2 ;
24073
24074   if (!jarg1) {
24075     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24076     return ;
24077   }
24078
24079   arg1 = (Dali::Actor *)jarg1;
24080   arg2 = jarg2 ? true : false;
24081   {
24082     try {
24083       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
24084     } CALL_CATCH_EXCEPTION();
24085   }
24086
24087 }
24088
24089
24090 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
24091   bool jresult ;
24092   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24093   bool result;
24094
24095   if (!jarg1) {
24096     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24097     return 0;
24098   }
24099
24100   arg1 = (Dali::Actor *)jarg1;
24101   {
24102     try {
24103       result = (bool)((Dali::Actor const *)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
24104     } CALL_CATCH_EXCEPTION(0);
24105   }
24106
24107   jresult = result;
24108   return jresult;
24109 }
24110
24111
24112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
24113   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24114   Dali::Degree *arg2 = 0 ;
24115   Dali::Vector3 *arg3 = 0 ;
24116
24117   if (!jarg1) {
24118     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24119     return ;
24120   }
24121
24122   arg1 = (Dali::Actor *)jarg1;
24123   arg2 = (Dali::Degree *)jarg2;
24124   if (!arg2) {
24125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
24126     return ;
24127   }
24128   arg3 = (Dali::Vector3 *)jarg3;
24129   if (!arg3) {
24130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
24131     return ;
24132   }
24133   {
24134     try {
24135       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
24136     } CALL_CATCH_EXCEPTION();
24137   }
24138
24139 }
24140
24141
24142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
24143   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24144   Dali::Radian *arg2 = 0 ;
24145   Dali::Vector3 *arg3 = 0 ;
24146
24147   if (!jarg1) {
24148     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24149     return ;
24150   }
24151
24152   arg1 = (Dali::Actor *)jarg1;
24153   arg2 = (Dali::Radian *)jarg2;
24154   if (!arg2) {
24155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
24156     return ;
24157   }
24158   arg3 = (Dali::Vector3 *)jarg3;
24159   if (!arg3) {
24160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
24161     return ;
24162   }
24163   {
24164     try {
24165       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
24166     } CALL_CATCH_EXCEPTION();
24167   }
24168
24169 }
24170
24171
24172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
24173   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24174   Dali::Quaternion *arg2 = 0 ;
24175
24176   if (!jarg1) {
24177     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24178     return ;
24179   }
24180
24181   arg1 = (Dali::Actor *)jarg1;
24182   arg2 = (Dali::Quaternion *)jarg2;
24183   if (!arg2) {
24184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
24185     return ;
24186   }
24187   {
24188     try {
24189       (arg1)->SetProperty( Actor::Property::ORIENTATION, (Dali::Quaternion const &)*arg2 );
24190     } CALL_CATCH_EXCEPTION();
24191   }
24192
24193 }
24194
24195
24196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
24197   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24198   Dali::Degree *arg2 = 0 ;
24199   Dali::Vector3 *arg3 = 0 ;
24200
24201   if (!jarg1) {
24202     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24203     return ;
24204   }
24205
24206   arg1 = (Dali::Actor *)jarg1;
24207   arg2 = (Dali::Degree *)jarg2;
24208   if (!arg2) {
24209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
24210     return ;
24211   }
24212   arg3 = (Dali::Vector3 *)jarg3;
24213   if (!arg3) {
24214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
24215     return ;
24216   }
24217   {
24218     try {
24219       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
24220     } CALL_CATCH_EXCEPTION();
24221   }
24222
24223 }
24224
24225
24226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
24227   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24228   Dali::Radian *arg2 = 0 ;
24229   Dali::Vector3 *arg3 = 0 ;
24230
24231   if (!jarg1) {
24232     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24233     return ;
24234   }
24235
24236   arg1 = (Dali::Actor *)jarg1;
24237   arg2 = (Dali::Radian *)jarg2;
24238   if (!arg2) {
24239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
24240     return ;
24241   }
24242   arg3 = (Dali::Vector3 *)jarg3;
24243   if (!arg3) {
24244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
24245     return ;
24246   }
24247   {
24248     try {
24249       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
24250     } CALL_CATCH_EXCEPTION();
24251   }
24252
24253 }
24254
24255
24256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
24257   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24258   Dali::Quaternion *arg2 = 0 ;
24259
24260   if (!jarg1) {
24261     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24262     return ;
24263   }
24264
24265   arg1 = (Dali::Actor *)jarg1;
24266   arg2 = (Dali::Quaternion *)jarg2;
24267   if (!arg2) {
24268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
24269     return ;
24270   }
24271   {
24272     try {
24273       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
24274     } CALL_CATCH_EXCEPTION();
24275   }
24276
24277 }
24278
24279
24280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
24281   void * jresult ;
24282   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24283   Dali::Quaternion result;
24284
24285   if (!jarg1) {
24286     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24287     return 0;
24288   }
24289
24290   arg1 = (Dali::Actor *)jarg1;
24291   {
24292     try {
24293       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION );
24294     } CALL_CATCH_EXCEPTION(0);
24295   }
24296
24297   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
24298   return jresult;
24299 }
24300
24301
24302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, bool jarg2) {
24303   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24304   bool arg2 ;
24305
24306   if (!jarg1) {
24307     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24308     return ;
24309   }
24310
24311   arg1 = (Dali::Actor *)jarg1;
24312   arg2 = jarg2 ? true : false;
24313   {
24314     try {
24315       (arg1)->SetProperty( Actor::Property::INHERIT_ORIENTATION,arg2);
24316     } CALL_CATCH_EXCEPTION();
24317   }
24318
24319 }
24320
24321
24322 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
24323   bool jresult ;
24324   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24325   bool result;
24326
24327   if (!jarg1) {
24328     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24329     return 0;
24330   }
24331
24332   arg1 = (Dali::Actor *)jarg1;
24333   {
24334     try {
24335       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION );
24336     } CALL_CATCH_EXCEPTION(0);
24337   }
24338
24339   jresult = result;
24340   return jresult;
24341 }
24342
24343
24344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
24345   void * jresult ;
24346   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24347   Dali::Quaternion result;
24348
24349   if (!jarg1) {
24350     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24351     return 0;
24352   }
24353
24354   arg1 = (Dali::Actor *)jarg1;
24355   {
24356     try {
24357       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION );
24358     } CALL_CATCH_EXCEPTION(0);
24359   }
24360
24361   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
24362   return jresult;
24363 }
24364
24365
24366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
24367   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24368   float arg2 ;
24369
24370   if (!jarg1) {
24371     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24372     return ;
24373   }
24374
24375   arg1 = (Dali::Actor *)jarg1;
24376   arg2 = (float)jarg2;
24377   {
24378     try {
24379       (arg1)->SetProperty( Actor::Property::SCALE, arg2);
24380     } CALL_CATCH_EXCEPTION();
24381   }
24382
24383 }
24384
24385
24386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
24387   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24388   float arg2 ;
24389   float arg3 ;
24390   float arg4 ;
24391
24392   if (!jarg1) {
24393     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24394     return ;
24395   }
24396
24397   arg1 = (Dali::Actor *)jarg1;
24398   arg2 = (float)jarg2;
24399   arg3 = (float)jarg3;
24400   arg4 = (float)jarg4;
24401   {
24402     try {
24403       (arg1)->SetProperty( Actor::Property::SCALE, Vector3( arg2, arg3, arg4 ) );
24404     } CALL_CATCH_EXCEPTION();
24405   }
24406
24407 }
24408
24409
24410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
24411   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24412   Dali::Vector3 *arg2 = 0 ;
24413
24414   if (!jarg1) {
24415     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24416     return ;
24417   }
24418
24419   arg1 = (Dali::Actor *)jarg1;
24420   arg2 = (Dali::Vector3 *)jarg2;
24421   if (!arg2) {
24422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
24423     return ;
24424   }
24425   {
24426     try {
24427       (arg1)->SetProperty( Actor::Property::SCALE, (Dali::Vector3 const &)*arg2 );
24428     } CALL_CATCH_EXCEPTION();
24429   }
24430
24431 }
24432
24433
24434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
24435   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24436   Dali::Vector3 *arg2 = 0 ;
24437
24438   if (!jarg1) {
24439     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24440     return ;
24441   }
24442
24443   arg1 = (Dali::Actor *)jarg1;
24444   arg2 = (Dali::Vector3 *)jarg2;
24445   if (!arg2) {
24446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
24447     return ;
24448   }
24449   {
24450     try {
24451       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
24452     } CALL_CATCH_EXCEPTION();
24453   }
24454
24455 }
24456
24457
24458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
24459   void * jresult ;
24460   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24461   Dali::Vector3 result;
24462
24463   if (!jarg1) {
24464     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24465     return 0;
24466   }
24467
24468   arg1 = (Dali::Actor *)jarg1;
24469   {
24470     try {
24471       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
24472     } CALL_CATCH_EXCEPTION(0);
24473   }
24474
24475   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
24476   return jresult;
24477 }
24478
24479
24480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
24481   void * jresult ;
24482   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24483   Dali::Vector3 result;
24484
24485   if (!jarg1) {
24486     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24487     return 0;
24488   }
24489
24490   arg1 = (Dali::Actor *)jarg1;
24491   {
24492     try {
24493       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE );
24494     } CALL_CATCH_EXCEPTION(0);
24495   }
24496
24497   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
24498   return jresult;
24499 }
24500
24501
24502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, bool jarg2) {
24503   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24504   bool arg2 ;
24505
24506   if (!jarg1) {
24507     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24508     return ;
24509   }
24510
24511   arg1 = (Dali::Actor *)jarg1;
24512   arg2 = jarg2 ? true : false;
24513   {
24514     try {
24515       (arg1)->SetProperty( Actor::Property::INHERIT_SCALE,arg2);
24516     } CALL_CATCH_EXCEPTION();
24517   }
24518
24519 }
24520
24521
24522 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
24523   bool jresult ;
24524   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24525   bool result;
24526
24527   if (!jarg1) {
24528     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24529     return 0;
24530   }
24531
24532   arg1 = (Dali::Actor *)jarg1;
24533   {
24534     try {
24535       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_SCALE );
24536     } CALL_CATCH_EXCEPTION(0);
24537   }
24538
24539   jresult = result;
24540   return jresult;
24541 }
24542
24543
24544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
24545   void * jresult ;
24546   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24547   Dali::Matrix result;
24548
24549   if (!jarg1) {
24550     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24551     return 0;
24552   }
24553
24554   arg1 = (Dali::Actor *)jarg1;
24555   {
24556     try {
24557       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
24558     } CALL_CATCH_EXCEPTION(0);
24559   }
24560
24561   jresult = new Dali::Matrix((const Dali::Matrix &)result);
24562   return jresult;
24563 }
24564
24565
24566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, bool jarg2) {
24567   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24568   bool arg2 ;
24569
24570   if (!jarg1) {
24571     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24572     return ;
24573   }
24574
24575   arg1 = (Dali::Actor *)jarg1;
24576   arg2 = jarg2 ? true : false;
24577   {
24578     try {
24579       (arg1)->SetProperty( Actor::Property::VISIBLE,arg2);
24580     } CALL_CATCH_EXCEPTION();
24581   }
24582
24583 }
24584
24585
24586 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
24587   bool jresult ;
24588   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24589   bool result;
24590
24591   if (!jarg1) {
24592     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24593     return 0;
24594   }
24595
24596   arg1 = (Dali::Actor *)jarg1;
24597   {
24598     try {
24599       result = (bool)((Dali::Actor const *)arg1)->GetCurrentProperty< bool >( Actor::Property::VISIBLE );
24600     } CALL_CATCH_EXCEPTION(0);
24601   }
24602
24603   jresult = result;
24604   return jresult;
24605 }
24606
24607
24608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
24609   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24610   float arg2 ;
24611
24612   if (!jarg1) {
24613     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24614     return ;
24615   }
24616
24617   arg1 = (Dali::Actor *)jarg1;
24618   arg2 = (float)jarg2;
24619   {
24620     try {
24621       (arg1)->SetProperty( Actor::Property::OPACITY,arg2);
24622     } CALL_CATCH_EXCEPTION();
24623   }
24624
24625 }
24626
24627
24628 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
24629   float jresult ;
24630   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24631   float result;
24632
24633   if (!jarg1) {
24634     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24635     return 0;
24636   }
24637
24638   arg1 = (Dali::Actor *)jarg1;
24639   {
24640     try {
24641       result = (float)((Dali::Actor const *)arg1)->GetCurrentProperty< float >( Actor::Property::OPACITY );
24642     } CALL_CATCH_EXCEPTION(0);
24643   }
24644
24645   jresult = result;
24646   return jresult;
24647 }
24648
24649
24650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
24651   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24652   Dali::Vector4 *arg2 = 0 ;
24653
24654   if (!jarg1) {
24655     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24656     return ;
24657   }
24658
24659   arg1 = (Dali::Actor *)jarg1;
24660   arg2 = (Dali::Vector4 *)jarg2;
24661   if (!arg2) {
24662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
24663     return ;
24664   }
24665   {
24666     try {
24667       (arg1)->SetProperty( Actor::Property::COLOR,(Dali::Vector4 const &)*arg2);
24668     } CALL_CATCH_EXCEPTION();
24669   }
24670
24671 }
24672
24673
24674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
24675   void * jresult ;
24676   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24677   Dali::Vector4 result;
24678
24679   if (!jarg1) {
24680     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24681     return 0;
24682   }
24683
24684   arg1 = (Dali::Actor *)jarg1;
24685   {
24686     try {
24687       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::COLOR );
24688     } CALL_CATCH_EXCEPTION(0);
24689   }
24690
24691   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
24692   return jresult;
24693 }
24694
24695
24696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
24697   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24698   Dali::ColorMode arg2 ;
24699
24700   if (!jarg1) {
24701     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24702     return ;
24703   }
24704
24705   arg1 = (Dali::Actor *)jarg1;
24706   arg2 = (Dali::ColorMode)jarg2;
24707   {
24708     try {
24709       (arg1)->SetProperty( Actor::Property::COLOR_MODE,arg2);
24710     } CALL_CATCH_EXCEPTION();
24711   }
24712
24713 }
24714
24715
24716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
24717   int jresult ;
24718   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24719   Dali::ColorMode result;
24720
24721   if (!jarg1) {
24722     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24723     return 0;
24724   }
24725
24726   arg1 = (Dali::Actor *)jarg1;
24727   {
24728     try {
24729       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetProperty< ColorMode >( Actor::Property::COLOR_MODE );
24730     } CALL_CATCH_EXCEPTION(0);
24731   }
24732
24733   jresult = (int)result;
24734   return jresult;
24735 }
24736
24737
24738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
24739   void * jresult ;
24740   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24741   Dali::Vector4 result;
24742
24743   if (!jarg1) {
24744     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24745     return 0;
24746   }
24747
24748   arg1 = (Dali::Actor *)jarg1;
24749   {
24750     try {
24751       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR );
24752     } CALL_CATCH_EXCEPTION(0);
24753   }
24754
24755   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
24756   return jresult;
24757 }
24758
24759
24760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
24761   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24762   Dali::DrawMode::Type arg2 ;
24763
24764   if (!jarg1) {
24765     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24766     return ;
24767   }
24768
24769   arg1 = (Dali::Actor *)jarg1;
24770   arg2 = (Dali::DrawMode::Type)jarg2;
24771   {
24772     try {
24773       (arg1)->SetProperty( Actor::Property::DRAW_MODE,arg2);
24774     } CALL_CATCH_EXCEPTION();
24775   }
24776
24777 }
24778
24779
24780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
24781   int jresult ;
24782   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24783   Dali::DrawMode::Type result;
24784
24785   if (!jarg1) {
24786     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24787     return 0;
24788   }
24789
24790   arg1 = (Dali::Actor *)jarg1;
24791   {
24792     try {
24793       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE );
24794     } CALL_CATCH_EXCEPTION(0);
24795   }
24796
24797   jresult = (int)result;
24798   return jresult;
24799 }
24800
24801
24802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, bool jarg2) {
24803   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24804   bool arg2 ;
24805
24806   if (!jarg1) {
24807     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24808     return ;
24809   }
24810
24811   arg1 = (Dali::Actor *)jarg1;
24812   arg2 = jarg2 ? true : false;
24813   {
24814     try {
24815       (arg1)->SetProperty( Actor::Property::SENSITIVE,arg2);
24816     } CALL_CATCH_EXCEPTION();
24817   }
24818
24819 }
24820
24821
24822 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
24823   bool jresult ;
24824   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24825   bool result;
24826
24827   if (!jarg1) {
24828     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24829     return 0;
24830   }
24831
24832   arg1 = (Dali::Actor *)jarg1;
24833   {
24834     try {
24835       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::SENSITIVE );
24836     } CALL_CATCH_EXCEPTION(0);
24837   }
24838
24839   jresult = result;
24840   return jresult;
24841 }
24842
24843
24844 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
24845   bool jresult ;
24846   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24847   float *arg2 = 0 ;
24848   float *arg3 = 0 ;
24849   float arg4 ;
24850   float arg5 ;
24851   bool result;
24852
24853   if (!jarg1) {
24854     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24855     return 0;
24856   }
24857
24858   arg1 = (Dali::Actor *)jarg1;
24859   arg2 = (float *)jarg2;
24860   arg3 = (float *)jarg3;
24861   arg4 = (float)jarg4;
24862   arg5 = (float)jarg5;
24863   {
24864     try {
24865       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
24866     } CALL_CATCH_EXCEPTION(0);
24867   }
24868
24869   jresult = result;
24870   return jresult;
24871 }
24872
24873
24874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, bool jarg2) {
24875   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24876   bool arg2 ;
24877
24878   if (!jarg1) {
24879     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24880     return ;
24881   }
24882
24883   arg1 = (Dali::Actor *)jarg1;
24884   arg2 = jarg2 ? true : false;
24885   {
24886     try {
24887       (arg1)->SetProperty( Actor::Property::LEAVE_REQUIRED,arg2);
24888     } CALL_CATCH_EXCEPTION();
24889   }
24890
24891 }
24892
24893
24894 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
24895   bool jresult ;
24896   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24897   bool result;
24898
24899   if (!jarg1) {
24900     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24901     return 0;
24902   }
24903
24904   arg1 = (Dali::Actor *)jarg1;
24905   {
24906     try {
24907       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::LEAVE_REQUIRED );
24908     } CALL_CATCH_EXCEPTION(0);
24909   }
24910
24911   jresult = result;
24912   return jresult;
24913 }
24914
24915
24916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, bool jarg2) {
24917   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24918   bool arg2 ;
24919
24920   if (!jarg1) {
24921     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24922     return ;
24923   }
24924
24925   arg1 = (Dali::Actor *)jarg1;
24926   arg2 = jarg2 ? true : false;
24927   {
24928     try {
24929       (arg1)->SetProperty( Actor::Property::KEYBOARD_FOCUSABLE, arg2 );
24930     } CALL_CATCH_EXCEPTION();
24931   }
24932
24933 }
24934
24935
24936 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
24937   bool jresult ;
24938   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24939   bool result;
24940
24941   if (!jarg1) {
24942     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24943     return 0;
24944   }
24945
24946   arg1 = (Dali::Actor *)jarg1;
24947   {
24948     try {
24949       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE );
24950     } CALL_CATCH_EXCEPTION(0);
24951   }
24952
24953   jresult = result;
24954   return jresult;
24955 }
24956
24957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusableChildren(void * actor, bool keyboardFocusableChildren) {
24958   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24959
24960   if (!actor) {
24961     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!");
24962     return ;
24963   }
24964
24965   arg1 = (Dali::Actor *)actor;
24966   {
24967     try {
24968       (arg1)->SetProperty( DevelActor::Property::KEYBOARD_FOCUSABLE_CHILDREN, keyboardFocusableChildren );
24969     } CALL_CATCH_EXCEPTION();
24970   }
24971 }
24972
24973
24974 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_AreChildrenKeyBoardFocusable(void * actor) {
24975   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24976   bool result;
24977
24978   if (!actor) {
24979     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!");
24980     return 0;
24981   }
24982
24983   arg1 = (Dali::Actor *)actor;
24984   {
24985     try {
24986       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( DevelActor::Property::KEYBOARD_FOCUSABLE_CHILDREN );
24987     } CALL_CATCH_EXCEPTION(0);
24988   }
24989   return result;
24990 }
24991
24992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetTouchFocusable(void * jarg1, bool jarg2) {
24993   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24994   bool arg2 ;
24995
24996   if (!jarg1) {
24997     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
24998     return ;
24999   }
25000
25001   arg1 = (Dali::Actor *)jarg1;
25002   arg2 = jarg2 ? true : false;
25003   {
25004     try {
25005       (arg1)->SetProperty( DevelActor::Property::TOUCH_FOCUSABLE, arg2 );
25006     } CALL_CATCH_EXCEPTION();
25007   }
25008
25009 }
25010
25011
25012 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsTouchFocusable(void * jarg1) {
25013   bool jresult ;
25014   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25015   bool result;
25016
25017   if (!jarg1) {
25018     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25019     return 0;
25020   }
25021
25022   arg1 = (Dali::Actor *)jarg1;
25023   {
25024     try {
25025       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( DevelActor::Property::TOUCH_FOCUSABLE );
25026     } CALL_CATCH_EXCEPTION(0);
25027   }
25028
25029   jresult = result;
25030   return jresult;
25031 }
25032
25033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
25034   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25035   Dali::ResizePolicy::Type arg2 ;
25036   Dali::Dimension::Type arg3 ;
25037
25038   if (!jarg1) {
25039     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25040     return ;
25041   }
25042
25043   arg1 = (Dali::Actor *)jarg1;
25044   arg2 = (Dali::ResizePolicy::Type)jarg2;
25045   arg3 = (Dali::Dimension::Type)jarg3;
25046   {
25047     try {
25048       (arg1)->SetResizePolicy(arg2,arg3);
25049     } CALL_CATCH_EXCEPTION();
25050   }
25051
25052 }
25053
25054
25055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
25056   int jresult ;
25057   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25058   Dali::Dimension::Type arg2 ;
25059   Dali::ResizePolicy::Type result;
25060
25061   if (!jarg1) {
25062     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25063     return 0;
25064   }
25065
25066   arg1 = (Dali::Actor *)jarg1;
25067   arg2 = (Dali::Dimension::Type)jarg2;
25068   {
25069     try {
25070       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
25071     } CALL_CATCH_EXCEPTION(0);
25072   }
25073
25074   jresult = (int)result;
25075   return jresult;
25076 }
25077
25078
25079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
25080   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25081   Dali::SizeScalePolicy::Type arg2 ;
25082
25083   if (!jarg1) {
25084     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25085     return ;
25086   }
25087
25088   arg1 = (Dali::Actor *)jarg1;
25089   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
25090   {
25091     try {
25092       (arg1)->SetProperty( Actor::Property::SIZE_SCALE_POLICY,arg2);
25093     } CALL_CATCH_EXCEPTION();
25094   }
25095
25096 }
25097
25098
25099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
25100   int jresult ;
25101   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25102   Dali::SizeScalePolicy::Type result;
25103
25104   if (!jarg1) {
25105     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25106     return 0;
25107   }
25108
25109   arg1 = (Dali::Actor *)jarg1;
25110   {
25111     try {
25112       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY );
25113     } CALL_CATCH_EXCEPTION(0);
25114   }
25115
25116   jresult = (int)result;
25117   return jresult;
25118 }
25119
25120
25121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
25122   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25123   Dali::Vector3 *arg2 = 0 ;
25124
25125   if (!jarg1) {
25126     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25127     return ;
25128   }
25129
25130   arg1 = (Dali::Actor *)jarg1;
25131   arg2 = (Dali::Vector3 *)jarg2;
25132   if (!arg2) {
25133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25134     return ;
25135   }
25136   {
25137     try {
25138       (arg1)->SetProperty( Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const &)*arg2);
25139     } CALL_CATCH_EXCEPTION();
25140   }
25141
25142 }
25143
25144
25145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
25146   void * jresult ;
25147   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25148   Dali::Vector3 result;
25149
25150   if (!jarg1) {
25151     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25152     return 0;
25153   }
25154
25155   arg1 = (Dali::Actor *)jarg1;
25156   {
25157     try {
25158       result = ((Dali::Actor const *)arg1)->GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR );
25159     } CALL_CATCH_EXCEPTION(0);
25160   }
25161
25162   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
25163   return jresult;
25164 }
25165
25166
25167 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
25168   float jresult ;
25169   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25170   float arg2 ;
25171   float result;
25172
25173   if (!jarg1) {
25174     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25175     return 0;
25176   }
25177
25178   arg1 = (Dali::Actor *)jarg1;
25179   arg2 = (float)jarg2;
25180   {
25181     try {
25182       result = (float)(arg1)->GetHeightForWidth(arg2);
25183     } CALL_CATCH_EXCEPTION(0);
25184   }
25185
25186   jresult = result;
25187   return jresult;
25188 }
25189
25190
25191 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
25192   float jresult ;
25193   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25194   float arg2 ;
25195   float result;
25196
25197   if (!jarg1) {
25198     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25199     return 0;
25200   }
25201
25202   arg1 = (Dali::Actor *)jarg1;
25203   arg2 = (float)jarg2;
25204   {
25205     try {
25206       result = (float)(arg1)->GetWidthForHeight(arg2);
25207     } CALL_CATCH_EXCEPTION(0);
25208   }
25209
25210   jresult = result;
25211   return jresult;
25212 }
25213
25214
25215 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
25216   float jresult ;
25217   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25218   Dali::Dimension::Type arg2 ;
25219   float result;
25220
25221   if (!jarg1) {
25222     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25223     return 0;
25224   }
25225
25226   arg1 = (Dali::Actor *)jarg1;
25227   arg2 = (Dali::Dimension::Type)jarg2;
25228   {
25229     try {
25230       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
25231     } CALL_CATCH_EXCEPTION(0);
25232   }
25233
25234   jresult = result;
25235   return jresult;
25236 }
25237
25238
25239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
25240   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25241   Dali::Padding *arg2 = 0 ;
25242
25243   if (!jarg1) {
25244     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25245     return ;
25246   }
25247
25248   arg1 = (Dali::Actor *)jarg1;
25249   arg2 = (Dali::Padding *)jarg2;
25250   if (!arg2) {
25251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
25252     return ;
25253   }
25254   {
25255     try {
25256       (arg1)->SetProperty( Actor::Property::PADDING, (Dali::Padding const &)*arg2);
25257     } CALL_CATCH_EXCEPTION();
25258   }
25259
25260 }
25261
25262
25263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
25264   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25265   Dali::Padding *arg2 = 0 ;
25266
25267   if (!jarg1) {
25268     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25269     return ;
25270   }
25271
25272   arg1 = (Dali::Actor *)jarg1;
25273   arg2 = (Dali::Padding *)jarg2;
25274   if (!arg2) {
25275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
25276     return ;
25277   }
25278   {
25279     try {
25280       *arg2 = ((Dali::Actor const *)arg1)->GetProperty<Vector4>( Actor::Property::PADDING );
25281     } CALL_CATCH_EXCEPTION();
25282   }
25283
25284 }
25285
25286
25287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
25288   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25289   Dali::Vector2 *arg2 = 0 ;
25290
25291   if (!jarg1) {
25292     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25293     return ;
25294   }
25295
25296   arg1 = (Dali::Actor *)jarg1;
25297   arg2 = (Dali::Vector2 *)jarg2;
25298   if (!arg2) {
25299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
25300     return ;
25301   }
25302   {
25303     try {
25304       (arg1)->SetProperty( Actor::Property::MINIMUM_SIZE,(Dali::Vector2 const &)*arg2);
25305     } CALL_CATCH_EXCEPTION();
25306   }
25307
25308 }
25309
25310
25311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
25312   void * jresult ;
25313   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25314   Dali::Vector2 result;
25315
25316   if (!jarg1) {
25317     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25318     return 0;
25319   }
25320
25321   arg1 = (Dali::Actor *)jarg1;
25322   {
25323     try {
25324       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
25325     } CALL_CATCH_EXCEPTION(0);
25326   }
25327
25328   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25329   return jresult;
25330 }
25331
25332
25333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
25334   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25335   Dali::Vector2 *arg2 = 0 ;
25336
25337   if (!jarg1) {
25338     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25339     return ;
25340   }
25341
25342   arg1 = (Dali::Actor *)jarg1;
25343   arg2 = (Dali::Vector2 *)jarg2;
25344   if (!arg2) {
25345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
25346     return ;
25347   }
25348   {
25349     try {
25350       (arg1)->SetProperty( Actor::Property::MAXIMUM_SIZE,(Dali::Vector2 const &)*arg2);
25351     } CALL_CATCH_EXCEPTION();
25352   }
25353
25354 }
25355
25356
25357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
25358   void * jresult ;
25359   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25360   Dali::Vector2 result;
25361
25362   if (!jarg1) {
25363     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25364     return 0;
25365   }
25366
25367   arg1 = (Dali::Actor *)jarg1;
25368   {
25369     try {
25370       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
25371     } CALL_CATCH_EXCEPTION(0);
25372   }
25373
25374   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25375   return jresult;
25376 }
25377
25378
25379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
25380   int jresult ;
25381   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25382   int result;
25383
25384   if (!jarg1) {
25385     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25386     return 0;
25387   }
25388
25389   arg1 = (Dali::Actor *)jarg1;
25390   {
25391     try {
25392       result = (int)(arg1)->GetProperty< int >( Actor::Property::HIERARCHY_DEPTH );
25393       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
25394     } CALL_CATCH_EXCEPTION(0);
25395   }
25396
25397   jresult = result;
25398   return jresult;
25399 }
25400
25401
25402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
25403   unsigned int jresult ;
25404   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25405   Dali::Renderer *arg2 = 0 ;
25406   unsigned int result;
25407
25408   if (!jarg1) {
25409     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25410     return 0;
25411   }
25412
25413   arg1 = (Dali::Actor *)jarg1;
25414   arg2 = (Dali::Renderer *)jarg2;
25415   if (!arg2) {
25416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
25417     return 0;
25418   }
25419   {
25420     try {
25421       result = (unsigned int)(arg1)->AddRenderer(*arg2);
25422     } CALL_CATCH_EXCEPTION(0);
25423   }
25424
25425   jresult = result;
25426   return jresult;
25427 }
25428
25429
25430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
25431   unsigned int jresult ;
25432   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25433   unsigned int result;
25434
25435   if (!jarg1) {
25436     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25437     return 0;
25438   }
25439
25440   arg1 = (Dali::Actor *)jarg1;
25441   {
25442     try {
25443       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
25444     } CALL_CATCH_EXCEPTION(0);
25445   }
25446
25447   jresult = result;
25448   return jresult;
25449 }
25450
25451
25452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
25453   void * jresult ;
25454   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25455   unsigned int arg2 ;
25456   Dali::Renderer result;
25457
25458   if (!jarg1) {
25459     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25460     return 0;
25461   }
25462
25463   arg1 = (Dali::Actor *)jarg1;
25464   arg2 = (unsigned int)jarg2;
25465   {
25466     try {
25467       result = (arg1)->GetRendererAt(arg2);
25468     } CALL_CATCH_EXCEPTION(0);
25469   }
25470
25471   jresult = new Dali::Renderer((const Dali::Renderer &)result);
25472   return jresult;
25473 }
25474
25475
25476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
25477   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25478   Dali::Renderer *arg2 = 0 ;
25479
25480   if (!jarg1) {
25481     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25482     return ;
25483   }
25484
25485   arg1 = (Dali::Actor *)jarg1;
25486   arg2 = (Dali::Renderer *)jarg2;
25487   if (!arg2) {
25488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
25489     return ;
25490   }
25491   {
25492     try {
25493       (arg1)->RemoveRenderer(*arg2);
25494     } CALL_CATCH_EXCEPTION();
25495   }
25496
25497 }
25498
25499
25500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
25501   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25502   unsigned int arg2 ;
25503
25504   if (!jarg1) {
25505     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25506     return ;
25507   }
25508
25509   arg1 = (Dali::Actor *)jarg1;
25510   arg2 = (unsigned int)jarg2;
25511   {
25512     try {
25513       (arg1)->RemoveRenderer(arg2);
25514     } CALL_CATCH_EXCEPTION();
25515   }
25516
25517 }
25518
25519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HitTestResultSignal(void * jarg1) {
25520   void * jresult ;
25521   Dali::Actor arg1 ;
25522   Dali::Actor *argp1 = (Dali::Actor *) 0 ;
25523   Dali::Actor::TouchEventSignalType *result = 0 ;
25524
25525
25526   argp1 = (Dali::Actor *)jarg1;
25527   if (!argp1) {
25528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25529     return 0;
25530   }
25531   arg1 = *argp1;
25532   {
25533     try {
25534       result = (Dali::Actor::TouchEventSignalType *) &Dali::DevelActor::HitTestResultSignal(arg1);
25535     } CALL_CATCH_EXCEPTION(0);
25536   }
25537
25538   jresult = (void *)result;
25539   return jresult;
25540 }
25541
25542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_InterceptTouchSignal(void * jarg1) {
25543   void * jresult ;
25544   Dali::Actor arg1 ;
25545   Dali::Actor *argp1 = (Dali::Actor *) 0 ;
25546   Dali::Actor::TouchEventSignalType *result = 0 ;
25547
25548
25549   argp1 = (Dali::Actor *)jarg1;
25550   if (!argp1) {
25551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25552     return 0;
25553   }
25554   arg1 = *argp1;
25555   {
25556     try {
25557       result = (Dali::Actor::TouchEventSignalType *) &Dali::DevelActor::InterceptTouchedSignal(arg1);
25558     } CALL_CATCH_EXCEPTION(0);
25559   }
25560
25561   jresult = (void *)result;
25562   return jresult;
25563 }
25564
25565
25566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
25567   void * jresult ;
25568   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25569   Dali::Actor::TouchEventSignalType *result = 0 ;
25570
25571   if (!jarg1) {
25572     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25573     return 0;
25574   }
25575
25576   arg1 = (Dali::Actor *)jarg1;
25577   {
25578     try {
25579       result = (Dali::Actor::TouchEventSignalType *) &(arg1)->TouchedSignal();
25580     } CALL_CATCH_EXCEPTION(0);
25581   }
25582
25583   jresult = (void *)result;
25584   return jresult;
25585 }
25586
25587
25588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
25589   void * jresult ;
25590   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25591   Dali::Actor::HoverSignalType *result = 0 ;
25592
25593   if (!jarg1) {
25594     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25595     return 0;
25596   }
25597
25598   arg1 = (Dali::Actor *)jarg1;
25599   {
25600     try {
25601       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
25602     } CALL_CATCH_EXCEPTION(0);
25603   }
25604
25605   jresult = (void *)result;
25606   return jresult;
25607 }
25608
25609
25610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
25611   void * jresult ;
25612   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25613   Dali::Actor::WheelEventSignalType *result = 0 ;
25614
25615   if (!jarg1) {
25616     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25617     return 0;
25618   }
25619
25620   arg1 = (Dali::Actor *)jarg1;
25621   {
25622     try {
25623       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
25624     } CALL_CATCH_EXCEPTION(0);
25625   }
25626
25627   jresult = (void *)result;
25628   return jresult;
25629 }
25630
25631
25632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnSceneSignal(void * jarg1) {
25633   void * jresult ;
25634   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25635   Dali::Actor::OnSceneSignalType *result = 0 ;
25636
25637   if (!jarg1) {
25638     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25639     return 0;
25640   }
25641
25642   arg1 = (Dali::Actor *)jarg1;
25643   {
25644     try {
25645       result = (Dali::Actor::OnSceneSignalType *) &(arg1)->OnSceneSignal();
25646     } CALL_CATCH_EXCEPTION(0);
25647   }
25648
25649   jresult = (void *)result;
25650   return jresult;
25651 }
25652
25653
25654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffSceneSignal(void * jarg1) {
25655   void * jresult ;
25656   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25657   Dali::Actor::OffSceneSignalType *result = 0 ;
25658
25659   if (!jarg1) {
25660     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25661     return 0;
25662   }
25663
25664   arg1 = (Dali::Actor *)jarg1;
25665   {
25666     try {
25667       result = (Dali::Actor::OffSceneSignalType *) &(arg1)->OffSceneSignal();
25668     } CALL_CATCH_EXCEPTION(0);
25669   }
25670
25671   jresult = (void *)result;
25672   return jresult;
25673 }
25674
25675
25676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
25677   void * jresult ;
25678   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25679   Dali::Actor::OnRelayoutSignalType *result = 0 ;
25680
25681   if (!jarg1) {
25682     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
25683     return 0;
25684   }
25685
25686   arg1 = (Dali::Actor *)jarg1;
25687   {
25688     try {
25689       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
25690     } CALL_CATCH_EXCEPTION(0);
25691   }
25692
25693   jresult = (void *)result;
25694   return jresult;
25695 }
25696
25697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetNeedGesturePropagation(void * jarg1, bool jarg2) {
25698   Dali::Actor arg1 ;
25699   bool arg2;
25700   Dali::Actor *argp1 = (Dali::Actor *) 0 ;
25701
25702
25703   argp1 = (Dali::Actor *)jarg1;
25704   if (!argp1) {
25705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25706     return;
25707   }
25708   arg1 = *argp1;
25709   arg2 = jarg2;
25710   {
25711     try {
25712       Dali::DevelActor::SetNeedGesturePropagation(arg1, arg2);
25713     } CALL_CATCH_EXCEPTION();
25714   }
25715   return;
25716 }
25717
25718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_CalculateScreenExtents(void * actor) {
25719   Dali::Actor arg1 ;
25720   Dali::Actor *argp1 = (Dali::Actor *) 0 ;
25721   Dali::Rect<float> result;
25722
25723   argp1 = (Dali::Actor *)actor;
25724   if (!argp1) {
25725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25726     return 0;
25727   }
25728   arg1 = *argp1;
25729   {
25730     try {
25731       result = Dali::DevelActor::CalculateScreenExtents(arg1);
25732     } CALL_CATCH_EXCEPTION(0);
25733   }
25734
25735   // Note: The float type Rectangle class is not ready yet.
25736   //      Therefore, it transmits data in Vector4 class.
25737   //      This type should later be changed to the appropriate data type.
25738   return new Dali::Vector4(result.x, result.y, result.width, result.height);
25739 }
25740
25741
25742 SWIGEXPORT void SWIGSTDCALL CSharp_DevelActor_Property_SetTouchAreaOffset(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
25743   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25744   arg1 = (Dali::Actor *)jarg1;
25745   Rect<int> arg2 = Rect(jarg2, jarg3, jarg4, jarg5);
25746   {
25747     try {
25748       (arg1)->SetProperty( Dali::DevelActor::Property::TOUCH_AREA_OFFSET, arg2 );
25749     } CALL_CATCH_EXCEPTION();
25750   }
25751 }
25752
25753 SWIGEXPORT void SWIGSTDCALL CSharp_DevelActor_Property_GetTouchAreaOffset(void * jarg1, int* jarg2, int* jarg3, int* jarg4, int* jarg5) {
25754   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
25755   arg1 = (Dali::Actor *)jarg1;
25756
25757   Rect<int32_t> result;
25758   {
25759     try {
25760       result = (arg1)->GetProperty<Rect<int32_t>>( Dali::DevelActor::Property::TOUCH_AREA_OFFSET);
25761       *jarg2 = result.left;
25762       *jarg3 = result.right;
25763       *jarg4 = result.bottom;
25764       *jarg5 = result.top;
25765     } CALL_CATCH_EXCEPTION();
25766   }
25767 }
25768
25769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
25770   Dali::Actor *arg1 = 0 ;
25771
25772   arg1 = (Dali::Actor *)jarg1;
25773   if (!arg1) {
25774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
25775     return ;
25776   }
25777   {
25778     try {
25779       Dali::UnparentAndReset(*arg1);
25780     } CALL_CATCH_EXCEPTION();
25781   }
25782
25783 }
25784
25785
25786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
25787   int jresult ;
25788   int result;
25789
25790   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
25791   jresult = (int)result;
25792   return jresult;
25793 }
25794
25795
25796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
25797   int jresult ;
25798   int result;
25799
25800   result = (int)Dali::Layer::Property::CLIPPING_BOX;
25801   jresult = (int)result;
25802   return jresult;
25803 }
25804
25805
25806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
25807   int jresult ;
25808   int result;
25809
25810   result = (int)Dali::Layer::Property::BEHAVIOR;
25811   jresult = (int)result;
25812   return jresult;
25813 }
25814
25815
25816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
25817   void * jresult ;
25818   Dali::Layer::Property *result = 0 ;
25819
25820   {
25821     try {
25822       result = (Dali::Layer::Property *)new Dali::Layer::Property();
25823     } CALL_CATCH_EXCEPTION(0);
25824   }
25825
25826   jresult = (void *)result;
25827   return jresult;
25828 }
25829
25830
25831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
25832   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
25833
25834   arg1 = (Dali::Layer::Property *)jarg1;
25835   {
25836     try {
25837       delete arg1;
25838     } CALL_CATCH_EXCEPTION();
25839   }
25840
25841 }
25842
25843
25844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
25845   void * jresult ;
25846   Dali::Layer *result = 0 ;
25847
25848   {
25849     try {
25850       result = (Dali::Layer *)new Dali::Layer();
25851     } CALL_CATCH_EXCEPTION(0);
25852   }
25853
25854   jresult = (void *)result;
25855   return jresult;
25856 }
25857
25858
25859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
25860   void * jresult ;
25861   Dali::Layer result;
25862
25863   {
25864     try {
25865       result = Dali::Layer::New();
25866     } CALL_CATCH_EXCEPTION(0);
25867   }
25868
25869   jresult = new Dali::Layer((const Dali::Layer &)result);
25870   return jresult;
25871 }
25872
25873
25874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
25875   void * jresult ;
25876   Dali::BaseHandle arg1 ;
25877   Dali::BaseHandle *argp1 ;
25878   Dali::Layer result;
25879
25880   argp1 = (Dali::BaseHandle *)jarg1;
25881   if (!argp1) {
25882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25883     return 0;
25884   }
25885   arg1 = *argp1;
25886   {
25887     try {
25888       result = Dali::Layer::DownCast(arg1);
25889     } CALL_CATCH_EXCEPTION(0);
25890   }
25891
25892   jresult = new Dali::Layer((const Dali::Layer &)result);
25893   return jresult;
25894 }
25895
25896
25897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
25898   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25899
25900   arg1 = (Dali::Layer *)jarg1;
25901   {
25902     try {
25903       delete arg1;
25904     } CALL_CATCH_EXCEPTION();
25905   }
25906
25907 }
25908
25909
25910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
25911   void * jresult ;
25912   Dali::Layer *arg1 = 0 ;
25913   Dali::Layer *result = 0 ;
25914
25915   arg1 = (Dali::Layer *)jarg1;
25916   if (!arg1) {
25917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
25918     return 0;
25919   }
25920   {
25921     try {
25922       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
25923     } CALL_CATCH_EXCEPTION(0);
25924   }
25925
25926   jresult = (void *)result;
25927   return jresult;
25928 }
25929
25930
25931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
25932   void * jresult ;
25933   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25934   Dali::Layer *arg2 = 0 ;
25935   Dali::Layer *result = 0 ;
25936
25937   arg1 = (Dali::Layer *)jarg1;
25938   arg2 = (Dali::Layer *)jarg2;
25939   if (!arg2) {
25940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
25941     return 0;
25942   }
25943   {
25944     try {
25945       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
25946     } CALL_CATCH_EXCEPTION(0);
25947   }
25948
25949   jresult = (void *)result;
25950   return jresult;
25951 }
25952
25953
25954 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
25955   unsigned int jresult ;
25956   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25957   unsigned int result;
25958
25959   arg1 = (Dali::Layer *)jarg1;
25960   {
25961     try {
25962       result = (unsigned int)((Dali::Layer const *)arg1)->GetProperty< int >( Layer::Property::DEPTH );
25963     } CALL_CATCH_EXCEPTION(0);
25964   }
25965
25966   jresult = result;
25967   return jresult;
25968 }
25969
25970
25971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
25972   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25973
25974   arg1 = (Dali::Layer *)jarg1;
25975   {
25976     try {
25977       (arg1)->Raise();
25978     } CALL_CATCH_EXCEPTION();
25979   }
25980
25981 }
25982
25983
25984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
25985   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25986
25987   arg1 = (Dali::Layer *)jarg1;
25988   {
25989     try {
25990       (arg1)->Lower();
25991     } CALL_CATCH_EXCEPTION();
25992   }
25993
25994 }
25995
25996
25997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
25998   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
25999   Dali::Layer arg2 ;
26000   Dali::Layer *argp2 ;
26001
26002   arg1 = (Dali::Layer *)jarg1;
26003   argp2 = (Dali::Layer *)jarg2;
26004   if (!argp2) {
26005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
26006     return ;
26007   }
26008   arg2 = *argp2;
26009   {
26010     try {
26011       (arg1)->RaiseAbove(arg2);
26012     } CALL_CATCH_EXCEPTION();
26013   }
26014
26015 }
26016
26017
26018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
26019   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26020   Dali::Layer arg2 ;
26021   Dali::Layer *argp2 ;
26022
26023   arg1 = (Dali::Layer *)jarg1;
26024   argp2 = (Dali::Layer *)jarg2;
26025   if (!argp2) {
26026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
26027     return ;
26028   }
26029   arg2 = *argp2;
26030   {
26031     try {
26032       (arg1)->LowerBelow(arg2);
26033     } CALL_CATCH_EXCEPTION();
26034   }
26035
26036 }
26037
26038
26039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
26040   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26041
26042   arg1 = (Dali::Layer *)jarg1;
26043   {
26044     try {
26045       (arg1)->RaiseToTop();
26046     } CALL_CATCH_EXCEPTION();
26047   }
26048
26049 }
26050
26051
26052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
26053   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26054
26055   arg1 = (Dali::Layer *)jarg1;
26056   {
26057     try {
26058       (arg1)->LowerToBottom();
26059     } CALL_CATCH_EXCEPTION();
26060   }
26061
26062 }
26063
26064
26065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
26066   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26067   Dali::Layer arg2 ;
26068   Dali::Layer *argp2 ;
26069
26070   arg1 = (Dali::Layer *)jarg1;
26071   argp2 = (Dali::Layer *)jarg2;
26072   if (!argp2) {
26073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
26074     return ;
26075   }
26076   arg2 = *argp2;
26077   {
26078     try {
26079       (arg1)->MoveAbove(arg2);
26080     } CALL_CATCH_EXCEPTION();
26081   }
26082
26083 }
26084
26085
26086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
26087   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26088   Dali::Layer arg2 ;
26089   Dali::Layer *argp2 ;
26090
26091   arg1 = (Dali::Layer *)jarg1;
26092   argp2 = (Dali::Layer *)jarg2;
26093   if (!argp2) {
26094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
26095     return ;
26096   }
26097   arg2 = *argp2;
26098   {
26099     try {
26100       (arg1)->MoveBelow(arg2);
26101     } CALL_CATCH_EXCEPTION();
26102   }
26103
26104 }
26105
26106
26107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
26108   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26109   Dali::Layer::Behavior arg2 ;
26110
26111   arg1 = (Dali::Layer *)jarg1;
26112   arg2 = (Dali::Layer::Behavior)jarg2;
26113   {
26114     try {
26115       (arg1)->SetProperty( Layer::Property::BEHAVIOR, arg2 );
26116     } CALL_CATCH_EXCEPTION();
26117   }
26118
26119 }
26120
26121
26122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
26123   int jresult ;
26124   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26125   Dali::Layer::Behavior result;
26126
26127   arg1 = (Dali::Layer *)jarg1;
26128   {
26129     try {
26130       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetProperty<Dali::Layer::Behavior>( Dali::Layer::Property::BEHAVIOR );
26131     } CALL_CATCH_EXCEPTION(0);
26132   }
26133
26134   jresult = (int)result;
26135   return jresult;
26136 }
26137
26138
26139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, bool jarg2) {
26140   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26141   bool arg2 ;
26142
26143   arg1 = (Dali::Layer *)jarg1;
26144   arg2 = jarg2 ? true : false;
26145   {
26146     try {
26147       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_ENABLE, arg2 );
26148     } CALL_CATCH_EXCEPTION();
26149   }
26150
26151 }
26152
26153
26154 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
26155   bool jresult ;
26156   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26157   bool result;
26158
26159   arg1 = (Dali::Layer *)jarg1;
26160   {
26161     try {
26162       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Dali::Layer::Property::CLIPPING_ENABLE );
26163     } CALL_CATCH_EXCEPTION(0);
26164   }
26165
26166   jresult = result;
26167   return jresult;
26168 }
26169
26170
26171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
26172   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26173   int arg2 ;
26174   int arg3 ;
26175   int arg4 ;
26176   int arg5 ;
26177
26178   arg1 = (Dali::Layer *)jarg1;
26179   arg2 = (int)jarg2;
26180   arg3 = (int)jarg3;
26181   arg4 = (int)jarg4;
26182   arg5 = (int)jarg5;
26183   {
26184     try {
26185       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, Rect<int32_t>( arg2,arg3,arg4,arg5 ) );
26186     } CALL_CATCH_EXCEPTION();
26187   }
26188
26189 }
26190
26191
26192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
26193   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26194   Dali::ClippingBox arg2 ;
26195   Dali::ClippingBox *argp2 ;
26196
26197   arg1 = (Dali::Layer *)jarg1;
26198   argp2 = (Dali::ClippingBox *)jarg2;
26199   if (!argp2) {
26200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
26201     return ;
26202   }
26203   arg2 = *argp2;
26204   {
26205     try {
26206       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, arg2 );
26207     } CALL_CATCH_EXCEPTION();
26208   }
26209
26210 }
26211
26212
26213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
26214   void * jresult ;
26215   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26216   Dali::ClippingBox result;
26217
26218   arg1 = (Dali::Layer *)jarg1;
26219   {
26220     try {
26221       result = ((Dali::Layer const *)arg1)->GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX );
26222     } CALL_CATCH_EXCEPTION(0);
26223   }
26224
26225   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
26226   return jresult;
26227 }
26228
26229
26230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, bool jarg2) {
26231   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26232   bool arg2 ;
26233
26234   arg1 = (Dali::Layer *)jarg1;
26235   arg2 = jarg2 ? true : false;
26236   {
26237     try {
26238       (arg1)->SetProperty( Layer::Property::DEPTH_TEST, !arg2 );
26239     } CALL_CATCH_EXCEPTION();
26240   }
26241
26242 }
26243
26244
26245 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
26246   bool jresult ;
26247   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26248   bool result;
26249
26250   arg1 = (Dali::Layer *)jarg1;
26251   {
26252     try {
26253       result = !(bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::DEPTH_TEST );
26254     } CALL_CATCH_EXCEPTION(0);
26255   }
26256
26257   jresult = result;
26258   return jresult;
26259 }
26260
26261
26262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
26263   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26264   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
26265
26266   arg1 = (Dali::Layer *)jarg1;
26267   arg2 = (Dali::Layer::SortFunctionType)jarg2;
26268   {
26269     try {
26270       (arg1)->SetSortFunction(arg2);
26271     } CALL_CATCH_EXCEPTION();
26272   }
26273
26274 }
26275
26276
26277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, bool jarg2) {
26278   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26279   bool arg2 ;
26280
26281   arg1 = (Dali::Layer *)jarg1;
26282   arg2 = jarg2 ? true : false;
26283   {
26284     try {
26285       (arg1)->SetProperty( Layer::Property::CONSUMES_TOUCH, arg2 );
26286     } CALL_CATCH_EXCEPTION();
26287   }
26288
26289 }
26290
26291
26292 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
26293   bool jresult ;
26294   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26295   bool result;
26296
26297   arg1 = (Dali::Layer *)jarg1;
26298   {
26299     try {
26300       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_TOUCH );
26301     } CALL_CATCH_EXCEPTION(0);
26302   }
26303
26304   jresult = result;
26305   return jresult;
26306 }
26307
26308
26309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, bool jarg2) {
26310   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26311   bool arg2 ;
26312
26313   arg1 = (Dali::Layer *)jarg1;
26314   arg2 = jarg2 ? true : false;
26315   {
26316     try {
26317       (arg1)->SetProperty( Layer::Property::CONSUMES_HOVER, arg2 );
26318     } CALL_CATCH_EXCEPTION();
26319   }
26320
26321 }
26322
26323
26324 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
26325   bool jresult ;
26326   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
26327   bool result;
26328
26329   arg1 = (Dali::Layer *)jarg1;
26330   {
26331     try {
26332       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_HOVER );
26333     } CALL_CATCH_EXCEPTION(0);
26334   }
26335
26336   jresult = result;
26337   return jresult;
26338 }
26339
26340
26341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
26342   void * jresult ;
26343   Dali::Stage result;
26344
26345   {
26346     try {
26347       result = Dali::Stage::GetCurrent();
26348     } CALL_CATCH_EXCEPTION(0);
26349   }
26350
26351   jresult = new Dali::Stage((const Dali::Stage &)result);
26352   return jresult;
26353 }
26354
26355
26356 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
26357   bool jresult ;
26358   bool result;
26359
26360   {
26361     try {
26362       result = (bool)Dali::Stage::IsInstalled();
26363     } CALL_CATCH_EXCEPTION(0);
26364   }
26365
26366   jresult = result;
26367   return jresult;
26368 }
26369
26370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
26371   void * jresult ;
26372   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
26373   Dali::RenderTaskList result;
26374
26375   arg1 = (Dali::Stage *)jarg1;
26376   {
26377     try {
26378       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
26379     } CALL_CATCH_EXCEPTION(0);
26380   }
26381
26382   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
26383   return jresult;
26384 }
26385
26386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
26387   void * jresult ;
26388   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
26389   Dali::Vector2 result;
26390
26391   arg1 = (Dali::Stage *)jarg1;
26392   {
26393     try {
26394       result = ((Dali::Stage const *)arg1)->GetDpi();
26395     } CALL_CATCH_EXCEPTION(0);
26396   }
26397
26398   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
26399   return jresult;
26400 }
26401
26402
26403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
26404   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
26405   float arg2 ;
26406
26407   arg1 = (Dali::Stage *)jarg1;
26408   arg2 = (float)jarg2;
26409   {
26410     try {
26411       (arg1)->KeepRendering(arg2);
26412     } CALL_CATCH_EXCEPTION();
26413   }
26414
26415 }
26416
26417
26418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
26419   void * jresult ;
26420   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
26421   Dali::Stage::KeyEventSignalType *result = 0 ;
26422
26423   arg1 = (Dali::Stage *)jarg1;
26424   {
26425     try {
26426       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
26427     } CALL_CATCH_EXCEPTION(0);
26428   }
26429
26430   jresult = (void *)result;
26431   return jresult;
26432 }
26433
26434
26435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
26436   void * jresult ;
26437   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
26438   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
26439
26440   arg1 = (Dali::Stage *)jarg1;
26441   {
26442     try {
26443       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
26444     } CALL_CATCH_EXCEPTION(0);
26445   }
26446
26447   jresult = (void *)result;
26448   return jresult;
26449 }
26450
26451
26452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
26453   void * jresult ;
26454   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
26455   Dali::Stage::TouchEventSignalType *result = 0 ;
26456
26457   arg1 = (Dali::Stage *)jarg1;
26458   {
26459     try {
26460       result = (Dali::Stage::TouchEventSignalType *) &(arg1)->TouchedSignal();
26461     } CALL_CATCH_EXCEPTION(0);
26462   }
26463
26464   jresult = (void *)result;
26465   return jresult;
26466 }
26467
26468
26469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
26470   void * jresult ;
26471   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
26472   Dali::Stage::WheelEventSignalType *result = 0 ;
26473
26474   arg1 = (Dali::Stage *)jarg1;
26475   {
26476     try {
26477       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
26478     } CALL_CATCH_EXCEPTION(0);
26479   }
26480
26481   jresult = (void *)result;
26482   return jresult;
26483 }
26484
26485
26486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
26487   void * jresult ;
26488   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
26489   Dali::Stage::ContextStatusSignal *result = 0 ;
26490
26491   arg1 = (Dali::Stage *)jarg1;
26492   {
26493     try {
26494       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
26495     } CALL_CATCH_EXCEPTION(0);
26496   }
26497
26498   jresult = (void *)result;
26499   return jresult;
26500 }
26501
26502
26503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
26504   void * jresult ;
26505   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
26506   Dali::Stage::ContextStatusSignal *result = 0 ;
26507
26508   arg1 = (Dali::Stage *)jarg1;
26509   {
26510     try {
26511       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
26512     } CALL_CATCH_EXCEPTION(0);
26513   }
26514
26515   jresult = (void *)result;
26516   return jresult;
26517 }
26518
26519
26520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
26521   void * jresult ;
26522   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
26523   Dali::Stage::SceneCreatedSignalType *result = 0 ;
26524
26525   arg1 = (Dali::Stage *)jarg1;
26526   {
26527     try {
26528       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
26529     } CALL_CATCH_EXCEPTION(0);
26530   }
26531
26532   jresult = (void *)result;
26533   return jresult;
26534 }
26535
26536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
26537   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
26538   Dali::DevelStage::Rendering arg2 ;
26539
26540   arg1 = (Dali::Stage *)jarg1;
26541   arg2 = (Dali::DevelStage::Rendering)jarg2;
26542   {
26543     try {
26544       DevelStage::SetRenderingBehavior(*arg1,arg2);
26545     } CALL_CATCH_EXCEPTION();
26546   }
26547
26548 }
26549
26550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
26551
26552   int jresult ;
26553   int result ;
26554   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
26555
26556   arg1 = (Dali::Stage *)jarg1;
26557   {
26558     try {
26559       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
26560     } CALL_CATCH_EXCEPTION(0);
26561   }
26562
26563   jresult = result;
26564   return jresult;
26565 }
26566
26567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
26568   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
26569
26570   arg1 = (Dali::RelayoutContainer *)jarg1;
26571   {
26572     try {
26573       delete arg1;
26574     } CALL_CATCH_EXCEPTION();
26575   }
26576
26577 }
26578
26579
26580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
26581   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
26582   Dali::Actor *arg2 = 0 ;
26583   Dali::Vector2 *arg3 = 0 ;
26584
26585   arg1 = (Dali::RelayoutContainer *)jarg1;
26586   arg2 = (Dali::Actor *)jarg2;
26587   if (!arg2) {
26588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
26589     return ;
26590   }
26591   arg3 = (Dali::Vector2 *)jarg3;
26592   if (!arg3) {
26593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
26594     return ;
26595   }
26596   {
26597     try {
26598       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
26599     } CALL_CATCH_EXCEPTION();
26600   }
26601
26602 }
26603
26604
26605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
26606   void * jresult ;
26607   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26608   Dali::CustomActor result;
26609
26610   arg1 = (Dali::CustomActorImpl *)jarg1;
26611   {
26612     try {
26613       result = ((Dali::CustomActorImpl const *)arg1)->Self();
26614     } CALL_CATCH_EXCEPTION(0);
26615   }
26616
26617   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
26618   return jresult;
26619 }
26620
26621
26622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneConnection(void * jarg1, int jarg2) {
26623   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26624   int arg2 ;
26625
26626   arg1 = (Dali::CustomActorImpl *)jarg1;
26627   arg2 = (int)jarg2;
26628   {
26629     try {
26630       (arg1)->OnSceneConnection(arg2);
26631     } CALL_CATCH_EXCEPTION();
26632   }
26633
26634 }
26635
26636
26637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneDisconnection(void * jarg1) {
26638   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26639
26640   arg1 = (Dali::CustomActorImpl *)jarg1;
26641   {
26642     try {
26643       (arg1)->OnSceneDisconnection();
26644     } CALL_CATCH_EXCEPTION();
26645   }
26646
26647 }
26648
26649
26650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
26651   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26652   Dali::Actor *arg2 = 0 ;
26653
26654   arg1 = (Dali::CustomActorImpl *)jarg1;
26655   arg2 = (Dali::Actor *)jarg2;
26656   if (!arg2) {
26657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
26658     return ;
26659   }
26660   {
26661     try {
26662       (arg1)->OnChildAdd(*arg2);
26663     } CALL_CATCH_EXCEPTION();
26664   }
26665
26666 }
26667
26668
26669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
26670   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26671   Dali::Actor *arg2 = 0 ;
26672
26673   arg1 = (Dali::CustomActorImpl *)jarg1;
26674   arg2 = (Dali::Actor *)jarg2;
26675   if (!arg2) {
26676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
26677     return ;
26678   }
26679   {
26680     try {
26681       (arg1)->OnChildRemove(*arg2);
26682     } CALL_CATCH_EXCEPTION();
26683   }
26684
26685 }
26686
26687
26688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
26689   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26690   Dali::Property::Index arg2 ;
26691   Dali::Property::Value arg3 ;
26692   Dali::Property::Value *argp3 ;
26693
26694   arg1 = (Dali::CustomActorImpl *)jarg1;
26695   arg2 = (Dali::Property::Index)jarg2;
26696   argp3 = (Dali::Property::Value *)jarg3;
26697   if (!argp3) {
26698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
26699     return ;
26700   }
26701   arg3 = *argp3;
26702   {
26703     try {
26704       (arg1)->OnPropertySet(arg2,arg3);
26705     } CALL_CATCH_EXCEPTION();
26706   }
26707
26708 }
26709
26710
26711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
26712   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26713   Dali::Vector3 *arg2 = 0 ;
26714
26715   arg1 = (Dali::CustomActorImpl *)jarg1;
26716   arg2 = (Dali::Vector3 *)jarg2;
26717   if (!arg2) {
26718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
26719     return ;
26720   }
26721   {
26722     try {
26723       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
26724     } CALL_CATCH_EXCEPTION();
26725   }
26726
26727 }
26728
26729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
26730   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26731   Dali::Animation *arg2 = 0 ;
26732   Dali::Vector3 *arg3 = 0 ;
26733
26734   arg1 = (Dali::CustomActorImpl *)jarg1;
26735   arg2 = (Dali::Animation *)jarg2;
26736   if (!arg2) {
26737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
26738     return ;
26739   }
26740   arg3 = (Dali::Vector3 *)jarg3;
26741   if (!arg3) {
26742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
26743     return ;
26744   }
26745   {
26746     try {
26747       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
26748     } CALL_CATCH_EXCEPTION();
26749   }
26750 }
26751
26752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
26753   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26754   Dali::Vector2 *arg2 = 0 ;
26755   Dali::RelayoutContainer *arg3 = 0 ;
26756
26757   arg1 = (Dali::CustomActorImpl *)jarg1;
26758   arg2 = (Dali::Vector2 *)jarg2;
26759   if (!arg2) {
26760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
26761     return ;
26762   }
26763   arg3 = (Dali::RelayoutContainer *)jarg3;
26764   if (!arg3) {
26765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
26766     return ;
26767   }
26768   {
26769     try {
26770       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
26771     } CALL_CATCH_EXCEPTION();
26772   }
26773
26774 }
26775
26776
26777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
26778   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26779   Dali::ResizePolicy::Type arg2 ;
26780   Dali::Dimension::Type arg3 ;
26781
26782   arg1 = (Dali::CustomActorImpl *)jarg1;
26783   arg2 = (Dali::ResizePolicy::Type)jarg2;
26784   arg3 = (Dali::Dimension::Type)jarg3;
26785   {
26786     try {
26787       (arg1)->OnSetResizePolicy(arg2,arg3);
26788     } CALL_CATCH_EXCEPTION();
26789   }
26790
26791 }
26792
26793
26794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
26795   void * jresult ;
26796   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26797   Dali::Vector3 result;
26798
26799   arg1 = (Dali::CustomActorImpl *)jarg1;
26800   {
26801     try {
26802       result = (arg1)->GetNaturalSize();
26803     } CALL_CATCH_EXCEPTION(0);
26804   }
26805
26806   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
26807   return jresult;
26808 }
26809
26810
26811 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
26812   float jresult ;
26813   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26814   Dali::Actor *arg2 = 0 ;
26815   Dali::Dimension::Type arg3 ;
26816   float result;
26817
26818   arg1 = (Dali::CustomActorImpl *)jarg1;
26819   arg2 = (Dali::Actor *)jarg2;
26820   if (!arg2) {
26821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
26822     return 0;
26823   }
26824   arg3 = (Dali::Dimension::Type)jarg3;
26825   {
26826     try {
26827       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
26828     } CALL_CATCH_EXCEPTION(0);
26829   }
26830
26831   jresult = result;
26832   return jresult;
26833 }
26834
26835
26836 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
26837   float jresult ;
26838   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26839   float arg2 ;
26840   float result;
26841
26842   arg1 = (Dali::CustomActorImpl *)jarg1;
26843   arg2 = (float)jarg2;
26844   {
26845     try {
26846       result = (float)(arg1)->GetHeightForWidth(arg2);
26847     } CALL_CATCH_EXCEPTION(0);
26848   }
26849
26850   jresult = result;
26851   return jresult;
26852 }
26853
26854
26855 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
26856   float jresult ;
26857   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26858   float arg2 ;
26859   float result;
26860
26861   arg1 = (Dali::CustomActorImpl *)jarg1;
26862   arg2 = (float)jarg2;
26863   {
26864     try {
26865       result = (float)(arg1)->GetWidthForHeight(arg2);
26866     } CALL_CATCH_EXCEPTION(0);
26867   }
26868
26869   jresult = result;
26870   return jresult;
26871 }
26872
26873
26874 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
26875   bool jresult ;
26876   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26877   Dali::Dimension::Type arg2 ;
26878   bool result;
26879
26880   arg1 = (Dali::CustomActorImpl *)jarg1;
26881   arg2 = (Dali::Dimension::Type)jarg2;
26882   {
26883     try {
26884       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
26885     } CALL_CATCH_EXCEPTION(0);
26886   }
26887
26888   jresult = result;
26889   return jresult;
26890 }
26891
26892
26893 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
26894   bool jresult ;
26895   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26896   bool result;
26897
26898   arg1 = (Dali::CustomActorImpl *)jarg1;
26899   {
26900     try {
26901       result = (bool)(arg1)->RelayoutDependentOnChildren();
26902     } CALL_CATCH_EXCEPTION(0);
26903   }
26904
26905   jresult = result;
26906   return jresult;
26907 }
26908
26909
26910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
26911   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26912   Dali::Dimension::Type arg2 ;
26913
26914   arg1 = (Dali::CustomActorImpl *)jarg1;
26915   arg2 = (Dali::Dimension::Type)jarg2;
26916   {
26917     try {
26918       (arg1)->OnCalculateRelayoutSize(arg2);
26919     } CALL_CATCH_EXCEPTION();
26920   }
26921
26922 }
26923
26924
26925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
26926   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26927   float arg2 ;
26928   Dali::Dimension::Type arg3 ;
26929
26930   arg1 = (Dali::CustomActorImpl *)jarg1;
26931   arg2 = (float)jarg2;
26932   arg3 = (Dali::Dimension::Type)jarg3;
26933   {
26934     try {
26935       (arg1)->OnLayoutNegotiated(arg2,arg3);
26936     } CALL_CATCH_EXCEPTION();
26937   }
26938
26939 }
26940
26941 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
26942   bool jresult ;
26943   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
26944   bool result;
26945
26946   arg1 = (Dali::CustomActorImpl *)jarg1;
26947   {
26948     try {
26949       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
26950     } CALL_CATCH_EXCEPTION(0);
26951   }
26952
26953   jresult = result;
26954   return jresult;
26955 }
26956
26957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
26958   void * jresult ;
26959   Dali::CustomActor *result = 0 ;
26960
26961   {
26962     try {
26963       result = (Dali::CustomActor *)new Dali::CustomActor();
26964     } CALL_CATCH_EXCEPTION(0);
26965   }
26966
26967   jresult = (void *)result;
26968   return jresult;
26969 }
26970
26971
26972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
26973   void * jresult ;
26974   Dali::BaseHandle arg1 ;
26975   Dali::BaseHandle *argp1 ;
26976   Dali::CustomActor result;
26977
26978   argp1 = (Dali::BaseHandle *)jarg1;
26979   if (!argp1) {
26980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26981     return 0;
26982   }
26983   arg1 = *argp1;
26984   {
26985     try {
26986       result = Dali::CustomActor::DownCast(arg1);
26987     } CALL_CATCH_EXCEPTION(0);
26988   }
26989
26990   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
26991   return jresult;
26992 }
26993
26994
26995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
26996   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
26997
26998   arg1 = (Dali::CustomActor *)jarg1;
26999   {
27000     try {
27001       delete arg1;
27002     } CALL_CATCH_EXCEPTION();
27003   }
27004
27005 }
27006
27007
27008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
27009   void * jresult ;
27010   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
27011   Dali::CustomActorImpl *result = 0 ;
27012
27013   arg1 = (Dali::CustomActor *)jarg1;
27014   {
27015     try {
27016       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
27017     } CALL_CATCH_EXCEPTION(0);
27018   }
27019
27020   jresult = (void *)result;
27021   return jresult;
27022 }
27023
27024
27025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
27026   void * jresult ;
27027   Dali::CustomActorImpl *arg1 = 0 ;
27028   Dali::CustomActor *result = 0 ;
27029
27030   arg1 = (Dali::CustomActorImpl *)jarg1;
27031   if (!arg1) {
27032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
27033     return 0;
27034   }
27035   {
27036     try {
27037       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
27038     } CALL_CATCH_EXCEPTION(0);
27039   }
27040
27041   jresult = (void *)result;
27042   return jresult;
27043 }
27044
27045
27046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
27047   void * jresult ;
27048   Dali::CustomActor *arg1 = 0 ;
27049   Dali::CustomActor *result = 0 ;
27050
27051   arg1 = (Dali::CustomActor *)jarg1;
27052   if (!arg1) {
27053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
27054     return 0;
27055   }
27056   {
27057     try {
27058       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
27059     } CALL_CATCH_EXCEPTION(0);
27060   }
27061
27062   jresult = (void *)result;
27063   return jresult;
27064 }
27065
27066
27067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
27068   void * jresult ;
27069   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
27070   Dali::CustomActor *arg2 = 0 ;
27071   Dali::CustomActor *result = 0 ;
27072
27073   arg1 = (Dali::CustomActor *)jarg1;
27074   arg2 = (Dali::CustomActor *)jarg2;
27075   if (!arg2) {
27076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
27077     return 0;
27078   }
27079   {
27080     try {
27081       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
27082     } CALL_CATCH_EXCEPTION(0);
27083   }
27084
27085   jresult = (void *)result;
27086   return jresult;
27087 }
27088
27089
27090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
27091   int jresult ;
27092   int result;
27093
27094   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
27095   jresult = (int)result;
27096   return jresult;
27097 }
27098
27099
27100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
27101   int jresult ;
27102   int result;
27103
27104   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
27105   jresult = (int)result;
27106   return jresult;
27107 }
27108
27109
27110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
27111   int jresult ;
27112   int result;
27113
27114   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
27115   jresult = (int)result;
27116   return jresult;
27117 }
27118
27119
27120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
27121   int jresult ;
27122   int result;
27123
27124   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
27125   jresult = (int)result;
27126   return jresult;
27127 }
27128
27129
27130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
27131   int jresult ;
27132   int result;
27133
27134   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
27135   jresult = (int)result;
27136   return jresult;
27137 }
27138
27139
27140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
27141   int jresult ;
27142   int result;
27143
27144   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
27145   jresult = (int)result;
27146   return jresult;
27147 }
27148
27149
27150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
27151   int jresult ;
27152   int result;
27153
27154   result = (int)Dali::PanGestureDetector::Property::PANNING;
27155   jresult = (int)result;
27156   return jresult;
27157 }
27158
27159
27160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
27161   void * jresult ;
27162   Dali::PanGestureDetector::Property *result = 0 ;
27163
27164   {
27165     try {
27166       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
27167     } CALL_CATCH_EXCEPTION(0);
27168   }
27169
27170   jresult = (void *)result;
27171   return jresult;
27172 }
27173
27174
27175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
27176   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
27177
27178   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
27179   {
27180     try {
27181       delete arg1;
27182     } CALL_CATCH_EXCEPTION();
27183   }
27184
27185 }
27186
27187
27188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
27189   void * jresult ;
27190   Dali::Radian *result = 0 ;
27191
27192   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
27193   jresult = (void *)result;
27194   return jresult;
27195 }
27196
27197
27198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
27199   void * jresult ;
27200   Dali::Radian *result = 0 ;
27201
27202   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
27203   jresult = (void *)result;
27204   return jresult;
27205 }
27206
27207
27208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
27209   void * jresult ;
27210   Dali::Radian *result = 0 ;
27211
27212   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
27213   jresult = (void *)result;
27214   return jresult;
27215 }
27216
27217
27218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
27219   void * jresult ;
27220   Dali::Radian *result = 0 ;
27221
27222   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
27223   jresult = (void *)result;
27224   return jresult;
27225 }
27226
27227
27228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
27229   void * jresult ;
27230   Dali::Radian *result = 0 ;
27231
27232   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
27233   jresult = (void *)result;
27234   return jresult;
27235 }
27236
27237
27238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
27239   void * jresult ;
27240   Dali::Radian *result = 0 ;
27241
27242   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
27243   jresult = (void *)result;
27244   return jresult;
27245 }
27246
27247
27248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
27249   void * jresult ;
27250   Dali::Radian *result = 0 ;
27251
27252   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
27253   jresult = (void *)result;
27254   return jresult;
27255 }
27256
27257
27258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
27259   void * jresult ;
27260   Dali::PanGestureDetector *result = 0 ;
27261
27262   {
27263     try {
27264       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
27265     } CALL_CATCH_EXCEPTION(0);
27266   }
27267
27268   jresult = (void *)result;
27269   return jresult;
27270 }
27271
27272
27273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
27274   void * jresult ;
27275   Dali::PanGestureDetector result;
27276
27277   {
27278     try {
27279       result = Dali::PanGestureDetector::New();
27280     } CALL_CATCH_EXCEPTION(0);
27281   }
27282
27283   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
27284   return jresult;
27285 }
27286
27287
27288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
27289   void * jresult ;
27290   Dali::BaseHandle arg1 ;
27291   Dali::BaseHandle *argp1 ;
27292   Dali::PanGestureDetector result;
27293
27294   argp1 = (Dali::BaseHandle *)jarg1;
27295   if (!argp1) {
27296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27297     return 0;
27298   }
27299   arg1 = *argp1;
27300   {
27301     try {
27302       result = Dali::PanGestureDetector::DownCast(arg1);
27303     } CALL_CATCH_EXCEPTION(0);
27304   }
27305
27306   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
27307   return jresult;
27308 }
27309
27310
27311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
27312   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27313
27314   arg1 = (Dali::PanGestureDetector *)jarg1;
27315   {
27316     try {
27317       delete arg1;
27318     } CALL_CATCH_EXCEPTION();
27319   }
27320
27321 }
27322
27323
27324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
27325   void * jresult ;
27326   Dali::PanGestureDetector *arg1 = 0 ;
27327   Dali::PanGestureDetector *result = 0 ;
27328
27329   arg1 = (Dali::PanGestureDetector *)jarg1;
27330   if (!arg1) {
27331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
27332     return 0;
27333   }
27334   {
27335     try {
27336       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
27337     } CALL_CATCH_EXCEPTION(0);
27338   }
27339
27340   jresult = (void *)result;
27341   return jresult;
27342 }
27343
27344
27345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
27346   void * jresult ;
27347   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27348   Dali::PanGestureDetector *arg2 = 0 ;
27349   Dali::PanGestureDetector *result = 0 ;
27350
27351   arg1 = (Dali::PanGestureDetector *)jarg1;
27352   arg2 = (Dali::PanGestureDetector *)jarg2;
27353   if (!arg2) {
27354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
27355     return 0;
27356   }
27357   {
27358     try {
27359       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
27360     } CALL_CATCH_EXCEPTION(0);
27361   }
27362
27363   jresult = (void *)result;
27364   return jresult;
27365 }
27366
27367
27368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
27369   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27370   unsigned int arg2 ;
27371
27372   arg1 = (Dali::PanGestureDetector *)jarg1;
27373   arg2 = (unsigned int)jarg2;
27374   {
27375     try {
27376       (arg1)->SetMinimumTouchesRequired(arg2);
27377     } CALL_CATCH_EXCEPTION();
27378   }
27379
27380 }
27381
27382
27383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
27384   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27385   unsigned int arg2 ;
27386
27387   arg1 = (Dali::PanGestureDetector *)jarg1;
27388   arg2 = (unsigned int)jarg2;
27389   {
27390     try {
27391       (arg1)->SetMaximumTouchesRequired(arg2);
27392     } CALL_CATCH_EXCEPTION();
27393   }
27394
27395 }
27396
27397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumMotionEventAge(void * jarg1, unsigned int jarg2) {
27398   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27399   uint32_t arg2 ;
27400
27401   arg1 = (Dali::PanGestureDetector *)jarg1;
27402   arg2 = (uint32_t)jarg2;
27403   {
27404     try {
27405       (arg1)->SetMaximumMotionEventAge(arg2);
27406     } CALL_CATCH_EXCEPTION();
27407   }
27408
27409 }
27410
27411
27412 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
27413   unsigned int jresult ;
27414   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27415   unsigned int result;
27416
27417   arg1 = (Dali::PanGestureDetector *)jarg1;
27418   {
27419     try {
27420       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
27421     } CALL_CATCH_EXCEPTION(0);
27422   }
27423
27424   jresult = result;
27425   return jresult;
27426 }
27427
27428
27429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
27430   unsigned int jresult ;
27431   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27432   unsigned int result;
27433
27434   arg1 = (Dali::PanGestureDetector *)jarg1;
27435   {
27436     try {
27437       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
27438     } CALL_CATCH_EXCEPTION(0);
27439   }
27440
27441   jresult = result;
27442   return jresult;
27443 }
27444
27445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumMotionEventAge(void * jarg1) {
27446   unsigned int jresult ;
27447   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27448   uint32_t result;
27449
27450   arg1 = (Dali::PanGestureDetector *)jarg1;
27451   {
27452     try {
27453       result = (uint32_t)((Dali::PanGestureDetector const *)arg1)->GetMaximumMotionEventAge();
27454     } CALL_CATCH_EXCEPTION(0);
27455   }
27456
27457   jresult = result;
27458   return jresult;
27459 }
27460
27461
27462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
27463   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27464   Dali::Radian arg2 ;
27465   Dali::Radian arg3 ;
27466   Dali::Radian *argp2 ;
27467   Dali::Radian *argp3 ;
27468
27469   arg1 = (Dali::PanGestureDetector *)jarg1;
27470   argp2 = (Dali::Radian *)jarg2;
27471   if (!argp2) {
27472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
27473     return ;
27474   }
27475   arg2 = *argp2;
27476   argp3 = (Dali::Radian *)jarg3;
27477   if (!argp3) {
27478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
27479     return ;
27480   }
27481   arg3 = *argp3;
27482   {
27483     try {
27484       (arg1)->AddAngle(arg2,arg3);
27485     } CALL_CATCH_EXCEPTION();
27486   }
27487
27488 }
27489
27490
27491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
27492   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27493   Dali::Radian arg2 ;
27494   Dali::Radian *argp2 ;
27495
27496   arg1 = (Dali::PanGestureDetector *)jarg1;
27497   argp2 = (Dali::Radian *)jarg2;
27498   if (!argp2) {
27499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
27500     return ;
27501   }
27502   arg2 = *argp2;
27503   {
27504     try {
27505       (arg1)->AddAngle(arg2);
27506     } CALL_CATCH_EXCEPTION();
27507   }
27508
27509 }
27510
27511
27512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
27513   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27514   Dali::Radian arg2 ;
27515   Dali::Radian arg3 ;
27516   Dali::Radian *argp2 ;
27517   Dali::Radian *argp3 ;
27518
27519   arg1 = (Dali::PanGestureDetector *)jarg1;
27520   argp2 = (Dali::Radian *)jarg2;
27521   if (!argp2) {
27522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
27523     return ;
27524   }
27525   arg2 = *argp2;
27526   argp3 = (Dali::Radian *)jarg3;
27527   if (!argp3) {
27528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
27529     return ;
27530   }
27531   arg3 = *argp3;
27532   {
27533     try {
27534       (arg1)->AddDirection(arg2,arg3);
27535     } CALL_CATCH_EXCEPTION();
27536   }
27537
27538 }
27539
27540
27541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
27542   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27543   Dali::Radian arg2 ;
27544   Dali::Radian *argp2 ;
27545
27546   arg1 = (Dali::PanGestureDetector *)jarg1;
27547   argp2 = (Dali::Radian *)jarg2;
27548   if (!argp2) {
27549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
27550     return ;
27551   }
27552   arg2 = *argp2;
27553   {
27554     try {
27555       (arg1)->AddDirection(arg2);
27556     } CALL_CATCH_EXCEPTION();
27557   }
27558
27559 }
27560
27561
27562 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
27563   unsigned long jresult ;
27564   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27565   size_t result;
27566
27567   arg1 = (Dali::PanGestureDetector *)jarg1;
27568   {
27569     try {
27570       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
27571     } CALL_CATCH_EXCEPTION(0);
27572   }
27573
27574   jresult = (unsigned long)result;
27575   return jresult;
27576 }
27577
27578
27579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
27580   void * jresult ;
27581   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27582   size_t arg2 ;
27583   Dali::PanGestureDetector::AngleThresholdPair result;
27584
27585   arg1 = (Dali::PanGestureDetector *)jarg1;
27586   arg2 = (size_t)jarg2;
27587   {
27588     try {
27589       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
27590     } CALL_CATCH_EXCEPTION(0);
27591   }
27592
27593   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
27594   return jresult;
27595 }
27596
27597
27598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
27599   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27600
27601   arg1 = (Dali::PanGestureDetector *)jarg1;
27602   {
27603     try {
27604       (arg1)->ClearAngles();
27605     } CALL_CATCH_EXCEPTION();
27606   }
27607
27608 }
27609
27610
27611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
27612   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27613   Dali::Radian arg2 ;
27614   Dali::Radian *argp2 ;
27615
27616   arg1 = (Dali::PanGestureDetector *)jarg1;
27617   argp2 = (Dali::Radian *)jarg2;
27618   if (!argp2) {
27619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
27620     return ;
27621   }
27622   arg2 = *argp2;
27623   {
27624     try {
27625       (arg1)->RemoveAngle(arg2);
27626     } CALL_CATCH_EXCEPTION();
27627   }
27628
27629 }
27630
27631
27632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
27633   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27634   Dali::Radian arg2 ;
27635   Dali::Radian *argp2 ;
27636
27637   arg1 = (Dali::PanGestureDetector *)jarg1;
27638   argp2 = (Dali::Radian *)jarg2;
27639   if (!argp2) {
27640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
27641     return ;
27642   }
27643   arg2 = *argp2;
27644   {
27645     try {
27646       (arg1)->RemoveDirection(arg2);
27647     } CALL_CATCH_EXCEPTION();
27648   }
27649
27650 }
27651
27652
27653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
27654   void * jresult ;
27655   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
27656   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
27657
27658   arg1 = (Dali::PanGestureDetector *)jarg1;
27659   {
27660     try {
27661       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27662     } CALL_CATCH_EXCEPTION(0);
27663   }
27664
27665   jresult = (void *)result;
27666   return jresult;
27667 }
27668
27669
27670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
27671   Dali::PanGesture *arg1 = 0 ;
27672
27673   arg1 = (Dali::PanGesture *)jarg1;
27674   if (!arg1) {
27675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
27676     return ;
27677   }
27678   {
27679     try {
27680       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
27681     } CALL_CATCH_EXCEPTION();
27682   }
27683
27684 }
27685
27686
27687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
27688   void * jresult ;
27689   Dali::PanGesture *result = 0 ;
27690
27691   {
27692     try {
27693       result = (Dali::PanGesture *)new Dali::PanGesture();
27694     } CALL_CATCH_EXCEPTION(0);
27695   }
27696
27697   jresult = (void *)result;
27698   return jresult;
27699 }
27700
27701
27702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_New(int jarg1) {
27703   void * jresult ;
27704   Dali::GestureState arg1 ;
27705   Dali::PanGesture result;
27706
27707   arg1 = (Dali::GestureState)jarg1;
27708   {
27709     try {
27710       result = DevelPanGesture::New(arg1);
27711     } CALL_CATCH_EXCEPTION(0);
27712   }
27713
27714   jresult = new Dali::PanGesture((const Dali::PanGesture &)result);
27715   return jresult;
27716 }
27717
27718
27719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
27720   void * jresult ;
27721   Dali::PanGesture *arg1 = 0 ;
27722   Dali::PanGesture *result = 0 ;
27723
27724   arg1 = (Dali::PanGesture *)jarg1;
27725   if (!arg1) {
27726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
27727     return 0;
27728   }
27729   {
27730     try {
27731       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
27732     } CALL_CATCH_EXCEPTION(0);
27733   }
27734
27735   jresult = (void *)result;
27736   return jresult;
27737 }
27738
27739
27740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
27741   void * jresult ;
27742   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27743   Dali::PanGesture *arg2 = 0 ;
27744   Dali::PanGesture *result = 0 ;
27745
27746   arg1 = (Dali::PanGesture *)jarg1;
27747   arg2 = (Dali::PanGesture *)jarg2;
27748   if (!arg2) {
27749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
27750     return 0;
27751   }
27752   {
27753     try {
27754       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
27755     } CALL_CATCH_EXCEPTION(0);
27756   }
27757
27758   jresult = (void *)result;
27759   return jresult;
27760 }
27761
27762
27763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
27764   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27765
27766   arg1 = (Dali::PanGesture *)jarg1;
27767   {
27768     try {
27769       delete arg1;
27770     } CALL_CATCH_EXCEPTION();
27771   }
27772
27773 }
27774
27775
27776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
27777   void * jresult ;
27778   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27779   Dali::Vector2 result;
27780
27781   arg1 = (Dali::PanGesture *)jarg1;
27782   {
27783     try {
27784       result = ((Dali::PanGesture const *)arg1)->GetVelocity();
27785     } catch (std::out_of_range& e) {
27786       {
27787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27788       };
27789     } catch (std::exception& e) {
27790       {
27791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27792       };
27793     } catch (Dali::DaliException e) {
27794       {
27795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27796       };
27797     } catch (...) {
27798       {
27799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27800       };
27801     }
27802   }
27803   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
27804   return jresult;
27805 }
27806
27807
27808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
27809   void * jresult ;
27810   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27811   Dali::Vector2 result;
27812
27813   arg1 = (Dali::PanGesture *)jarg1;
27814   {
27815     try {
27816       result = ((Dali::PanGesture const *)arg1)->GetDisplacement();
27817     } catch (std::out_of_range& e) {
27818       {
27819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27820       };
27821     } catch (std::exception& e) {
27822       {
27823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27824       };
27825     } catch (Dali::DaliException e) {
27826       {
27827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27828       };
27829     } catch (...) {
27830       {
27831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27832       };
27833     }
27834   }
27835   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
27836   return jresult;
27837 }
27838
27839
27840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
27841   void * jresult ;
27842   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27843   Dali::Vector2 result;
27844
27845   arg1 = (Dali::PanGesture *)jarg1;
27846   {
27847     try {
27848       result = ((Dali::PanGesture const *)arg1)->GetPosition();
27849     } catch (std::out_of_range& e) {
27850       {
27851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27852       };
27853     } catch (std::exception& e) {
27854       {
27855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27856       };
27857     } catch (Dali::DaliException e) {
27858       {
27859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27860       };
27861     } catch (...) {
27862       {
27863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27864       };
27865     }
27866   }
27867   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
27868   return jresult;
27869 }
27870
27871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
27872   void * jresult ;
27873   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27874   Dali::Vector2 result;
27875
27876   arg1 = (Dali::PanGesture *)jarg1;
27877   {
27878     try {
27879       result = ((Dali::PanGesture const *)arg1)->GetScreenVelocity();
27880     } catch (std::out_of_range& e) {
27881       {
27882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27883       };
27884     } catch (std::exception& e) {
27885       {
27886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27887       };
27888     } catch (Dali::DaliException e) {
27889       {
27890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27891       };
27892     } catch (...) {
27893       {
27894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27895       };
27896     }
27897   }
27898   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
27899   return jresult;
27900 }
27901
27902
27903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
27904   void * jresult ;
27905   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27906   Dali::Vector2 result;
27907
27908   arg1 = (Dali::PanGesture *)jarg1;
27909   {
27910     try {
27911       result = ((Dali::PanGesture const *)arg1)->GetScreenDisplacement();
27912     } catch (std::out_of_range& e) {
27913       {
27914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27915       };
27916     } catch (std::exception& e) {
27917       {
27918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27919       };
27920     } catch (Dali::DaliException e) {
27921       {
27922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27923       };
27924     } catch (...) {
27925       {
27926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27927       };
27928     }
27929   }
27930   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
27931   return jresult;
27932 }
27933
27934
27935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
27936   void * jresult ;
27937   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27938   Dali::Vector2 result;
27939
27940   arg1 = (Dali::PanGesture *)jarg1;
27941   {
27942     try {
27943       result = ((Dali::PanGesture const *)arg1)->GetScreenPosition();
27944     } catch (std::out_of_range& e) {
27945       {
27946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27947       };
27948     } catch (std::exception& e) {
27949       {
27950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27951       };
27952     } catch (Dali::DaliException e) {
27953       {
27954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27955       };
27956     } catch (...) {
27957       {
27958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27959       };
27960     }
27961   }
27962   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
27963   return jresult;
27964 }
27965
27966
27967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
27968   unsigned int jresult ;
27969   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27970   unsigned int result;
27971
27972   arg1 = (Dali::PanGesture *)jarg1;
27973   result = (unsigned int) ((arg1)->GetNumberOfTouches());
27974   jresult = result;
27975   return jresult;
27976 }
27977
27978
27979 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
27980   float jresult ;
27981   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27982   float result;
27983
27984   arg1 = (Dali::PanGesture *)jarg1;
27985   {
27986     try {
27987       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
27988     } CALL_CATCH_EXCEPTION(0);
27989   }
27990
27991   jresult = result;
27992   return jresult;
27993 }
27994
27995
27996 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
27997   float jresult ;
27998   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
27999   float result;
28000
28001   arg1 = (Dali::PanGesture *)jarg1;
28002   {
28003     try {
28004       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
28005     } CALL_CATCH_EXCEPTION(0);
28006   }
28007
28008   jresult = result;
28009   return jresult;
28010 }
28011
28012
28013 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
28014   float jresult ;
28015   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
28016   float result;
28017
28018   arg1 = (Dali::PanGesture *)jarg1;
28019   {
28020     try {
28021       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
28022     } CALL_CATCH_EXCEPTION(0);
28023   }
28024
28025   jresult = result;
28026   return jresult;
28027 }
28028
28029
28030 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
28031   float jresult ;
28032   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
28033   float result;
28034
28035   arg1 = (Dali::PanGesture *)jarg1;
28036   {
28037     try {
28038       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
28039     } CALL_CATCH_EXCEPTION(0);
28040   }
28041
28042   jresult = result;
28043   return jresult;
28044 }
28045
28046
28047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
28048   void * jresult ;
28049   Dali::PinchGestureDetector *result = 0 ;
28050
28051   {
28052     try {
28053       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
28054     } CALL_CATCH_EXCEPTION(0);
28055   }
28056
28057   jresult = (void *)result;
28058   return jresult;
28059 }
28060
28061
28062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
28063   void * jresult ;
28064   Dali::PinchGestureDetector result;
28065
28066   {
28067     try {
28068       result = Dali::PinchGestureDetector::New();
28069     } CALL_CATCH_EXCEPTION(0);
28070   }
28071
28072   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
28073   return jresult;
28074 }
28075
28076
28077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
28078   void * jresult ;
28079   Dali::BaseHandle arg1 ;
28080   Dali::BaseHandle *argp1 ;
28081   Dali::PinchGestureDetector result;
28082
28083   argp1 = (Dali::BaseHandle *)jarg1;
28084   if (!argp1) {
28085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28086     return 0;
28087   }
28088   arg1 = *argp1;
28089   {
28090     try {
28091       result = Dali::PinchGestureDetector::DownCast(arg1);
28092     } CALL_CATCH_EXCEPTION(0);
28093   }
28094
28095   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
28096   return jresult;
28097 }
28098
28099
28100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
28101   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
28102
28103   arg1 = (Dali::PinchGestureDetector *)jarg1;
28104   {
28105     try {
28106       delete arg1;
28107     } CALL_CATCH_EXCEPTION();
28108   }
28109
28110 }
28111
28112
28113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
28114   void * jresult ;
28115   Dali::PinchGestureDetector *arg1 = 0 ;
28116   Dali::PinchGestureDetector *result = 0 ;
28117
28118   arg1 = (Dali::PinchGestureDetector *)jarg1;
28119   if (!arg1) {
28120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
28121     return 0;
28122   }
28123   {
28124     try {
28125       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
28126     } CALL_CATCH_EXCEPTION(0);
28127   }
28128
28129   jresult = (void *)result;
28130   return jresult;
28131 }
28132
28133
28134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
28135   void * jresult ;
28136   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
28137   Dali::PinchGestureDetector *arg2 = 0 ;
28138   Dali::PinchGestureDetector *result = 0 ;
28139
28140   arg1 = (Dali::PinchGestureDetector *)jarg1;
28141   arg2 = (Dali::PinchGestureDetector *)jarg2;
28142   if (!arg2) {
28143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
28144     return 0;
28145   }
28146   {
28147     try {
28148       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
28149     } CALL_CATCH_EXCEPTION(0);
28150   }
28151
28152   jresult = (void *)result;
28153   return jresult;
28154 }
28155
28156
28157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
28158   void * jresult ;
28159   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
28160   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
28161
28162   arg1 = (Dali::PinchGestureDetector *)jarg1;
28163   {
28164     try {
28165       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
28166     } CALL_CATCH_EXCEPTION(0);
28167   }
28168
28169   jresult = (void *)result;
28170   return jresult;
28171 }
28172
28173
28174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0() {
28175   void * jresult ;
28176   Dali::PinchGesture *result = 0 ;
28177
28178   {
28179     try {
28180       result = (Dali::PinchGesture *)new Dali::PinchGesture();
28181     } CALL_CATCH_EXCEPTION(0);
28182   }
28183
28184   jresult = (void *)result;
28185   return jresult;
28186 }
28187
28188
28189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_New(int jarg1) {
28190   void * jresult ;
28191   Dali::GestureState arg1 ;
28192   Dali::PinchGesture result;
28193
28194   arg1 = (Dali::GestureState)jarg1;
28195   {
28196     try {
28197       result = DevelPinchGesture::New(arg1);
28198     } CALL_CATCH_EXCEPTION(0);
28199   }
28200
28201   jresult = new Dali::PinchGesture((const Dali::PinchGesture &)result);
28202   return jresult;
28203 }
28204
28205
28206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
28207   void * jresult ;
28208   Dali::PinchGesture *arg1 = 0 ;
28209   Dali::PinchGesture *result = 0 ;
28210
28211   arg1 = (Dali::PinchGesture *)jarg1;
28212   if (!arg1) {
28213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
28214     return 0;
28215   }
28216   {
28217     try {
28218       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
28219     } CALL_CATCH_EXCEPTION(0);
28220   }
28221
28222   jresult = (void *)result;
28223   return jresult;
28224 }
28225
28226
28227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
28228   void * jresult ;
28229   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
28230   Dali::PinchGesture *arg2 = 0 ;
28231   Dali::PinchGesture *result = 0 ;
28232
28233   arg1 = (Dali::PinchGesture *)jarg1;
28234   arg2 = (Dali::PinchGesture *)jarg2;
28235   if (!arg2) {
28236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
28237     return 0;
28238   }
28239   {
28240     try {
28241       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
28242     } CALL_CATCH_EXCEPTION(0);
28243   }
28244
28245   jresult = (void *)result;
28246   return jresult;
28247 }
28248
28249
28250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
28251   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
28252
28253   arg1 = (Dali::PinchGesture *)jarg1;
28254   {
28255     try {
28256       delete arg1;
28257     } CALL_CATCH_EXCEPTION();
28258   }
28259
28260 }
28261
28262
28263 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
28264   float jresult ;
28265   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
28266   float result;
28267
28268   arg1 = (Dali::PinchGesture *)jarg1;
28269   result = (float) ((arg1)->GetScale());
28270   jresult = result;
28271   return jresult;
28272 }
28273
28274
28275 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
28276   float jresult ;
28277   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
28278   float result;
28279
28280   arg1 = (Dali::PinchGesture *)jarg1;
28281   result = (float) ((arg1)->GetSpeed());
28282   jresult = result;
28283   return jresult;
28284 }
28285
28286
28287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
28288   void * jresult ;
28289   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
28290   Dali::Vector2 result;
28291
28292   arg1 = (Dali::PinchGesture *)jarg1;
28293   {
28294     try {
28295       result = ((Dali::PinchGesture const *)arg1)->GetScreenCenterPoint();
28296     } catch (std::out_of_range& e) {
28297       {
28298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28299       };
28300     } catch (std::exception& e) {
28301       {
28302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28303       };
28304     } catch (Dali::DaliException e) {
28305       {
28306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28307       };
28308     } catch (...) {
28309       {
28310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28311       };
28312     }
28313   }
28314   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28315   return jresult;
28316 }
28317
28318
28319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
28320   void * jresult ;
28321   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
28322   Dali::Vector2 result;
28323
28324   arg1 = (Dali::PinchGesture *)jarg1;
28325   {
28326     try {
28327       result = ((Dali::PinchGesture const *)arg1)->GetLocalCenterPoint();
28328     } catch (std::out_of_range& e) {
28329       {
28330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28331       };
28332     } catch (std::exception& e) {
28333       {
28334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28335       };
28336     } catch (Dali::DaliException e) {
28337       {
28338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28339       };
28340     } catch (...) {
28341       {
28342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28343       };
28344     }
28345   }
28346   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28347   return jresult;
28348 }
28349
28350
28351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
28352   void * jresult ;
28353   Dali::TapGestureDetector *result = 0 ;
28354
28355   {
28356     try {
28357       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
28358     } CALL_CATCH_EXCEPTION(0);
28359   }
28360
28361   jresult = (void *)result;
28362   return jresult;
28363 }
28364
28365
28366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
28367   void * jresult ;
28368   Dali::TapGestureDetector result;
28369
28370   {
28371     try {
28372       result = Dali::TapGestureDetector::New();
28373     } CALL_CATCH_EXCEPTION(0);
28374   }
28375
28376   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
28377   return jresult;
28378 }
28379
28380
28381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
28382   void * jresult ;
28383   unsigned int arg1 ;
28384   Dali::TapGestureDetector result;
28385
28386   arg1 = (unsigned int)jarg1;
28387   {
28388     try {
28389       result = Dali::TapGestureDetector::New(arg1);
28390     } CALL_CATCH_EXCEPTION(0);
28391   }
28392
28393   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
28394   return jresult;
28395 }
28396
28397
28398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
28399   void * jresult ;
28400   Dali::BaseHandle arg1 ;
28401   Dali::BaseHandle *argp1 ;
28402   Dali::TapGestureDetector result;
28403
28404   argp1 = (Dali::BaseHandle *)jarg1;
28405   if (!argp1) {
28406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28407     return 0;
28408   }
28409   arg1 = *argp1;
28410   {
28411     try {
28412       result = Dali::TapGestureDetector::DownCast(arg1);
28413     } CALL_CATCH_EXCEPTION(0);
28414   }
28415
28416   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
28417   return jresult;
28418 }
28419
28420
28421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
28422   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
28423
28424   arg1 = (Dali::TapGestureDetector *)jarg1;
28425   {
28426     try {
28427       delete arg1;
28428     } CALL_CATCH_EXCEPTION();
28429   }
28430
28431 }
28432
28433
28434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
28435   void * jresult ;
28436   Dali::TapGestureDetector *arg1 = 0 ;
28437   Dali::TapGestureDetector *result = 0 ;
28438
28439   arg1 = (Dali::TapGestureDetector *)jarg1;
28440   if (!arg1) {
28441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
28442     return 0;
28443   }
28444   {
28445     try {
28446       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
28447     } CALL_CATCH_EXCEPTION(0);
28448   }
28449
28450   jresult = (void *)result;
28451   return jresult;
28452 }
28453
28454
28455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
28456   void * jresult ;
28457   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
28458   Dali::TapGestureDetector *arg2 = 0 ;
28459   Dali::TapGestureDetector *result = 0 ;
28460
28461   arg1 = (Dali::TapGestureDetector *)jarg1;
28462   arg2 = (Dali::TapGestureDetector *)jarg2;
28463   if (!arg2) {
28464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
28465     return 0;
28466   }
28467   {
28468     try {
28469       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
28470     } CALL_CATCH_EXCEPTION(0);
28471   }
28472
28473   jresult = (void *)result;
28474   return jresult;
28475 }
28476
28477
28478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
28479   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
28480   unsigned int arg2 ;
28481
28482   arg1 = (Dali::TapGestureDetector *)jarg1;
28483   arg2 = (unsigned int)jarg2;
28484   {
28485     try {
28486       (arg1)->SetMinimumTapsRequired(arg2);
28487     } CALL_CATCH_EXCEPTION();
28488   }
28489
28490 }
28491
28492
28493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
28494   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
28495   unsigned int arg2 ;
28496
28497   arg1 = (Dali::TapGestureDetector *)jarg1;
28498   arg2 = (unsigned int)jarg2;
28499   {
28500     try {
28501       (arg1)->SetMaximumTapsRequired(arg2);
28502     } CALL_CATCH_EXCEPTION();
28503   }
28504
28505 }
28506
28507
28508 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
28509   unsigned int jresult ;
28510   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
28511   unsigned int result;
28512
28513   arg1 = (Dali::TapGestureDetector *)jarg1;
28514   {
28515     try {
28516       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
28517     } CALL_CATCH_EXCEPTION(0);
28518   }
28519
28520   jresult = result;
28521   return jresult;
28522 }
28523
28524
28525 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
28526   unsigned int jresult ;
28527   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
28528   unsigned int result;
28529
28530   arg1 = (Dali::TapGestureDetector *)jarg1;
28531   {
28532     try {
28533       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
28534     } CALL_CATCH_EXCEPTION(0);
28535   }
28536
28537   jresult = result;
28538   return jresult;
28539 }
28540
28541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_ReceiveAllTapEvents(void * tapGestureDetector, bool isReceive) {
28542   Dali::TapGestureDetector *detector = (Dali::TapGestureDetector *) 0 ;
28543
28544   detector = (Dali::TapGestureDetector *)tapGestureDetector;
28545   if (!detector) {
28546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
28547     return;
28548   }
28549   {
28550     try {
28551       (detector)->ReceiveAllTapEvents(isReceive);
28552     } CALL_CATCH_EXCEPTION();
28553   }
28554
28555 }
28556
28557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
28558   void * jresult ;
28559   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
28560   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
28561
28562   arg1 = (Dali::TapGestureDetector *)jarg1;
28563   {
28564     try {
28565       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
28566     } CALL_CATCH_EXCEPTION(0);
28567   }
28568
28569   jresult = (void *)result;
28570   return jresult;
28571 }
28572
28573
28574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
28575   void * jresult ;
28576   Dali::TapGesture *result = 0 ;
28577
28578   {
28579     try {
28580       result = (Dali::TapGesture *)new Dali::TapGesture();
28581     } CALL_CATCH_EXCEPTION(0);
28582   }
28583
28584   jresult = (void *)result;
28585   return jresult;
28586 }
28587
28588
28589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_New(int jarg1) {
28590   void * jresult ;
28591   Dali::GestureState arg1 ;
28592   Dali::TapGesture result;
28593
28594   arg1 = (Dali::GestureState)jarg1;
28595   {
28596     try {
28597       result = DevelTapGesture::New(arg1);
28598     } CALL_CATCH_EXCEPTION(0);
28599   }
28600
28601   jresult = new Dali::TapGesture((const Dali::TapGesture &)result);
28602   return jresult;
28603 }
28604
28605
28606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
28607   void * jresult ;
28608   Dali::TapGesture *arg1 = 0 ;
28609   Dali::TapGesture *result = 0 ;
28610
28611   arg1 = (Dali::TapGesture *)jarg1;
28612   if (!arg1) {
28613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
28614     return 0;
28615   }
28616   {
28617     try {
28618       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
28619     } CALL_CATCH_EXCEPTION(0);
28620   }
28621
28622   jresult = (void *)result;
28623   return jresult;
28624 }
28625
28626
28627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
28628   void * jresult ;
28629   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
28630   Dali::TapGesture *arg2 = 0 ;
28631   Dali::TapGesture *result = 0 ;
28632
28633   arg1 = (Dali::TapGesture *)jarg1;
28634   arg2 = (Dali::TapGesture *)jarg2;
28635   if (!arg2) {
28636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
28637     return 0;
28638   }
28639   {
28640     try {
28641       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
28642     } CALL_CATCH_EXCEPTION(0);
28643   }
28644
28645   jresult = (void *)result;
28646   return jresult;
28647 }
28648
28649
28650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
28651   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
28652
28653   arg1 = (Dali::TapGesture *)jarg1;
28654   {
28655     try {
28656       delete arg1;
28657     } CALL_CATCH_EXCEPTION();
28658   }
28659
28660 }
28661
28662
28663 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
28664   unsigned int jresult ;
28665   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
28666   unsigned int result;
28667
28668   arg1 = (Dali::TapGesture *)jarg1;
28669   result = (unsigned int) ((arg1)->GetNumberOfTaps());
28670   jresult = result;
28671   return jresult;
28672 }
28673
28674 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
28675   unsigned int jresult ;
28676   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
28677   unsigned int result;
28678
28679   arg1 = (Dali::TapGesture *)jarg1;
28680   result = (unsigned int) ((arg1)->GetNumberOfTouches());
28681   jresult = result;
28682   return jresult;
28683 }
28684
28685
28686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
28687   void * jresult ;
28688   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
28689   Dali::Vector2 result;
28690
28691   arg1 = (Dali::TapGesture *)jarg1;
28692   {
28693     try {
28694       result = ((Dali::TapGesture const *)arg1)->GetScreenPoint();
28695     } catch (std::out_of_range& e) {
28696       {
28697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28698       };
28699     } catch (std::exception& e) {
28700       {
28701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28702       };
28703     } catch (Dali::DaliException e) {
28704       {
28705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28706       };
28707     } catch (...) {
28708       {
28709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28710       };
28711     }
28712   }
28713   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28714   return jresult;
28715 }
28716
28717
28718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
28719   void * jresult ;
28720   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
28721   Dali::Vector2 result;
28722
28723   arg1 = (Dali::TapGesture *)jarg1;
28724   {
28725     try {
28726       result = ((Dali::TapGesture const *)arg1)->GetLocalPoint();
28727     } catch (std::out_of_range& e) {
28728       {
28729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28730       };
28731     } catch (std::exception& e) {
28732       {
28733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28734       };
28735     } catch (Dali::DaliException e) {
28736       {
28737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28738       };
28739     } catch (...) {
28740       {
28741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28742       };
28743     }
28744   }
28745   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28746   return jresult;
28747 }
28748
28749
28750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
28751   void * jresult ;
28752   Dali::AlphaFunction *result = 0 ;
28753
28754   {
28755     try {
28756       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
28757     } CALL_CATCH_EXCEPTION(0);
28758   }
28759
28760   jresult = (void *)result;
28761   return jresult;
28762 }
28763
28764
28765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
28766   void * jresult ;
28767   Dali::AlphaFunction::BuiltinFunction arg1 ;
28768   Dali::AlphaFunction *result = 0 ;
28769
28770   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
28771   {
28772     try {
28773       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
28774     } CALL_CATCH_EXCEPTION(0);
28775   }
28776
28777   jresult = (void *)result;
28778   return jresult;
28779 }
28780
28781
28782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
28783   void * jresult ;
28784   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
28785   Dali::AlphaFunction *result = 0 ;
28786
28787   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
28788   {
28789     try {
28790       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
28791     } CALL_CATCH_EXCEPTION(0);
28792   }
28793
28794   jresult = (void *)result;
28795   return jresult;
28796 }
28797
28798
28799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
28800   void * jresult ;
28801   Dali::Vector2 *arg1 = 0 ;
28802   Dali::Vector2 *arg2 = 0 ;
28803   Dali::AlphaFunction *result = 0 ;
28804
28805   arg1 = (Dali::Vector2 *)jarg1;
28806   if (!arg1) {
28807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
28808     return 0;
28809   }
28810   arg2 = (Dali::Vector2 *)jarg2;
28811   if (!arg2) {
28812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
28813     return 0;
28814   }
28815   {
28816     try {
28817       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
28818     } CALL_CATCH_EXCEPTION(0);
28819   }
28820
28821   jresult = (void *)result;
28822   return jresult;
28823 }
28824
28825
28826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
28827   void * jresult ;
28828   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
28829   Dali::Vector4 result;
28830
28831   arg1 = (Dali::AlphaFunction *)jarg1;
28832   {
28833     try {
28834       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
28835     } CALL_CATCH_EXCEPTION(0);
28836   }
28837
28838   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
28839   return jresult;
28840 }
28841
28842
28843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
28844   void * jresult ;
28845   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
28846   Dali::AlphaFunctionPrototype result;
28847
28848   arg1 = (Dali::AlphaFunction *)jarg1;
28849   {
28850     try {
28851       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
28852     } CALL_CATCH_EXCEPTION(0);
28853   }
28854
28855   jresult = (void *)result;
28856   return jresult;
28857 }
28858
28859
28860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
28861   int jresult ;
28862   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
28863   Dali::AlphaFunction::BuiltinFunction result;
28864
28865   arg1 = (Dali::AlphaFunction *)jarg1;
28866   {
28867     try {
28868       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
28869     } CALL_CATCH_EXCEPTION(0);
28870   }
28871
28872   jresult = (int)result;
28873   return jresult;
28874 }
28875
28876
28877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
28878   int jresult ;
28879   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
28880   Dali::AlphaFunction::Mode result;
28881
28882   arg1 = (Dali::AlphaFunction *)jarg1;
28883   {
28884     try {
28885       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
28886     } CALL_CATCH_EXCEPTION(0);
28887   }
28888
28889   jresult = (int)result;
28890   return jresult;
28891 }
28892
28893
28894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
28895   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
28896
28897   arg1 = (Dali::AlphaFunction *)jarg1;
28898   {
28899     try {
28900       delete arg1;
28901     } CALL_CATCH_EXCEPTION();
28902   }
28903
28904 }
28905
28906
28907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
28908   void * jresult ;
28909   Dali::KeyFrames result;
28910
28911   {
28912     try {
28913       result = Dali::KeyFrames::New();
28914     } CALL_CATCH_EXCEPTION(0);
28915   }
28916
28917   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
28918   return jresult;
28919 }
28920
28921
28922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
28923   void * jresult ;
28924   Dali::BaseHandle arg1 ;
28925   Dali::BaseHandle *argp1 ;
28926   Dali::KeyFrames result;
28927
28928   argp1 = (Dali::BaseHandle *)jarg1;
28929   if (!argp1) {
28930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28931     return 0;
28932   }
28933   arg1 = *argp1;
28934   {
28935     try {
28936       result = Dali::KeyFrames::DownCast(arg1);
28937     } CALL_CATCH_EXCEPTION(0);
28938   }
28939
28940   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
28941   return jresult;
28942 }
28943
28944
28945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
28946   void * jresult ;
28947   Dali::KeyFrames *result = 0 ;
28948
28949   {
28950     try {
28951       result = (Dali::KeyFrames *)new Dali::KeyFrames();
28952     } CALL_CATCH_EXCEPTION(0);
28953   }
28954
28955   jresult = (void *)result;
28956   return jresult;
28957 }
28958
28959
28960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
28961   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
28962
28963   arg1 = (Dali::KeyFrames *)jarg1;
28964   {
28965     try {
28966       delete arg1;
28967     } CALL_CATCH_EXCEPTION();
28968   }
28969
28970 }
28971
28972
28973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
28974   void * jresult ;
28975   Dali::KeyFrames *arg1 = 0 ;
28976   Dali::KeyFrames *result = 0 ;
28977
28978   arg1 = (Dali::KeyFrames *)jarg1;
28979   if (!arg1) {
28980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
28981     return 0;
28982   }
28983   {
28984     try {
28985       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
28986     } CALL_CATCH_EXCEPTION(0);
28987   }
28988
28989   jresult = (void *)result;
28990   return jresult;
28991 }
28992
28993
28994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
28995   void * jresult ;
28996   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
28997   Dali::KeyFrames *arg2 = 0 ;
28998   Dali::KeyFrames *result = 0 ;
28999
29000   arg1 = (Dali::KeyFrames *)jarg1;
29001   arg2 = (Dali::KeyFrames *)jarg2;
29002   if (!arg2) {
29003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
29004     return 0;
29005   }
29006   {
29007     try {
29008       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
29009     } CALL_CATCH_EXCEPTION(0);
29010   }
29011
29012   jresult = (void *)result;
29013   return jresult;
29014 }
29015
29016
29017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
29018   int jresult ;
29019   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
29020   Dali::Property::Type result;
29021
29022   arg1 = (Dali::KeyFrames *)jarg1;
29023   {
29024     try {
29025       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
29026     } CALL_CATCH_EXCEPTION(0);
29027   }
29028
29029   jresult = (int)result;
29030   return jresult;
29031 }
29032
29033
29034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
29035   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
29036   float arg2 ;
29037   Dali::Property::Value arg3 ;
29038   Dali::Property::Value *argp3 ;
29039
29040   arg1 = (Dali::KeyFrames *)jarg1;
29041   arg2 = (float)jarg2;
29042   argp3 = (Dali::Property::Value *)jarg3;
29043   if (!argp3) {
29044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
29045     return ;
29046   }
29047   arg3 = *argp3;
29048   {
29049     try {
29050       (arg1)->Add(arg2,arg3);
29051     } CALL_CATCH_EXCEPTION();
29052   }
29053
29054 }
29055
29056
29057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
29058   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
29059   float arg2 ;
29060   Dali::Property::Value arg3 ;
29061   Dali::AlphaFunction arg4 ;
29062   Dali::Property::Value *argp3 ;
29063   Dali::AlphaFunction *argp4 ;
29064
29065   arg1 = (Dali::KeyFrames *)jarg1;
29066   arg2 = (float)jarg2;
29067   argp3 = (Dali::Property::Value *)jarg3;
29068   if (!argp3) {
29069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
29070     return ;
29071   }
29072   arg3 = *argp3;
29073   argp4 = (Dali::AlphaFunction *)jarg4;
29074   if (!argp4) {
29075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
29076     return ;
29077   }
29078   arg4 = *argp4;
29079   {
29080     try {
29081       (arg1)->Add(arg2,arg3,arg4);
29082     } CALL_CATCH_EXCEPTION();
29083   }
29084
29085 }
29086
29087 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyFrames_GetKeyFrameCount(void* keyFrames)
29088 {
29089   unsigned int jresult;
29090   {
29091     try {
29092       jresult = Dali::DevelKeyFrames::GetKeyFrameCount(*((Dali::KeyFrames*)keyFrames));
29093     } CALL_CATCH_EXCEPTION(0);
29094   }
29095   return jresult;
29096 }
29097
29098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_GetKeyFrame(void* keyFrames, unsigned int index, float* time, void* value)
29099 {
29100   if (!value) {
29101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
29102     return ;
29103   }
29104   try {
29105     Dali::DevelKeyFrames::GetKeyFrame(*((Dali::KeyFrames*)keyFrames), (size_t)index, *time, *((Property::Value*)value));
29106   } CALL_CATCH_EXCEPTION();
29107 }
29108
29109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_SetKeyFrameValue(void* keyFrames, unsigned int index, void* value)
29110 {
29111   if (!value) {
29112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
29113     return ;
29114   }
29115   try {
29116     Dali::DevelKeyFrames::SetKeyFrameValue(*((Dali::KeyFrames*)keyFrames), (size_t)index, *((const Property::Value*)value));
29117   } CALL_CATCH_EXCEPTION();
29118 }
29119
29120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
29121   int jresult ;
29122   int result;
29123
29124   result = (int)Dali::Path::Property::POINTS;
29125   jresult = (int)result;
29126   return jresult;
29127 }
29128
29129
29130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
29131   int jresult ;
29132   int result;
29133
29134   result = (int)Dali::Path::Property::CONTROL_POINTS;
29135   jresult = (int)result;
29136   return jresult;
29137 }
29138
29139
29140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
29141   void * jresult ;
29142   Dali::Path::Property *result = 0 ;
29143
29144   {
29145     try {
29146       result = (Dali::Path::Property *)new Dali::Path::Property();
29147     } CALL_CATCH_EXCEPTION(0);
29148   }
29149
29150   jresult = (void *)result;
29151   return jresult;
29152 }
29153
29154
29155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
29156   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
29157
29158   arg1 = (Dali::Path::Property *)jarg1;
29159   {
29160     try {
29161       delete arg1;
29162     } CALL_CATCH_EXCEPTION();
29163   }
29164
29165 }
29166
29167
29168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
29169   void * jresult ;
29170   Dali::Path result;
29171
29172   {
29173     try {
29174       result = Dali::Path::New();
29175     } CALL_CATCH_EXCEPTION(0);
29176   }
29177
29178   jresult = new Dali::Path((const Dali::Path &)result);
29179   return jresult;
29180 }
29181
29182
29183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
29184   void * jresult ;
29185   Dali::BaseHandle arg1 ;
29186   Dali::BaseHandle *argp1 ;
29187   Dali::Path result;
29188
29189   argp1 = (Dali::BaseHandle *)jarg1;
29190   if (!argp1) {
29191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29192     return 0;
29193   }
29194   arg1 = *argp1;
29195   {
29196     try {
29197       result = Dali::Path::DownCast(arg1);
29198     } CALL_CATCH_EXCEPTION(0);
29199   }
29200
29201   jresult = new Dali::Path((const Dali::Path &)result);
29202   return jresult;
29203 }
29204
29205
29206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
29207   void * jresult ;
29208   Dali::Path *result = 0 ;
29209
29210   {
29211     try {
29212       result = (Dali::Path *)new Dali::Path();
29213     } CALL_CATCH_EXCEPTION(0);
29214   }
29215
29216   jresult = (void *)result;
29217   return jresult;
29218 }
29219
29220
29221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
29222   Dali::Path *arg1 = (Dali::Path *) 0 ;
29223
29224   arg1 = (Dali::Path *)jarg1;
29225   {
29226     try {
29227       delete arg1;
29228     } CALL_CATCH_EXCEPTION();
29229   }
29230
29231 }
29232
29233
29234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
29235   void * jresult ;
29236   Dali::Path *arg1 = 0 ;
29237   Dali::Path *result = 0 ;
29238
29239   arg1 = (Dali::Path *)jarg1;
29240   if (!arg1) {
29241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
29242     return 0;
29243   }
29244   {
29245     try {
29246       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
29247     } CALL_CATCH_EXCEPTION(0);
29248   }
29249
29250   jresult = (void *)result;
29251   return jresult;
29252 }
29253
29254
29255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
29256   void * jresult ;
29257   Dali::Path *arg1 = (Dali::Path *) 0 ;
29258   Dali::Path *arg2 = 0 ;
29259   Dali::Path *result = 0 ;
29260
29261   arg1 = (Dali::Path *)jarg1;
29262   arg2 = (Dali::Path *)jarg2;
29263   if (!arg2) {
29264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
29265     return 0;
29266   }
29267   {
29268     try {
29269       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
29270     } CALL_CATCH_EXCEPTION(0);
29271   }
29272
29273   jresult = (void *)result;
29274   return jresult;
29275 }
29276
29277
29278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
29279   Dali::Path *arg1 = (Dali::Path *) 0 ;
29280   Dali::Vector3 *arg2 = 0 ;
29281
29282   arg1 = (Dali::Path *)jarg1;
29283   arg2 = (Dali::Vector3 *)jarg2;
29284   if (!arg2) {
29285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29286     return ;
29287   }
29288   {
29289     try {
29290       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
29291     } CALL_CATCH_EXCEPTION();
29292   }
29293
29294 }
29295
29296
29297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
29298   Dali::Path *arg1 = (Dali::Path *) 0 ;
29299   Dali::Vector3 *arg2 = 0 ;
29300
29301   arg1 = (Dali::Path *)jarg1;
29302   arg2 = (Dali::Vector3 *)jarg2;
29303   if (!arg2) {
29304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29305     return ;
29306   }
29307   {
29308     try {
29309       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
29310     } CALL_CATCH_EXCEPTION();
29311   }
29312
29313 }
29314
29315
29316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
29317   Dali::Path *arg1 = (Dali::Path *) 0 ;
29318   float arg2 ;
29319
29320   arg1 = (Dali::Path *)jarg1;
29321   arg2 = (float)jarg2;
29322   {
29323     try {
29324       (arg1)->GenerateControlPoints(arg2);
29325     } CALL_CATCH_EXCEPTION();
29326   }
29327
29328 }
29329
29330
29331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
29332   Dali::Path *arg1 = (Dali::Path *) 0 ;
29333   float arg2 ;
29334   Dali::Vector3 *arg3 = 0 ;
29335   Dali::Vector3 *arg4 = 0 ;
29336
29337   arg1 = (Dali::Path *)jarg1;
29338   arg2 = (float)jarg2;
29339   arg3 = (Dali::Vector3 *)jarg3;
29340   if (!arg3) {
29341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
29342     return ;
29343   }
29344   arg4 = (Dali::Vector3 *)jarg4;
29345   if (!arg4) {
29346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
29347     return ;
29348   }
29349   {
29350     try {
29351       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
29352     } CALL_CATCH_EXCEPTION();
29353   }
29354
29355 }
29356
29357
29358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
29359   void * jresult ;
29360   Dali::Path *arg1 = (Dali::Path *) 0 ;
29361   size_t arg2 ;
29362   Dali::Vector3 *result = 0 ;
29363
29364   arg1 = (Dali::Path *)jarg1;
29365   arg2 = (size_t)jarg2;
29366   {
29367     try {
29368       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
29369     } CALL_CATCH_EXCEPTION(0);
29370   }
29371
29372   jresult = (void *)result;
29373   return jresult;
29374 }
29375
29376
29377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
29378   void * jresult ;
29379   Dali::Path *arg1 = (Dali::Path *) 0 ;
29380   size_t arg2 ;
29381   Dali::Vector3 *result = 0 ;
29382
29383   arg1 = (Dali::Path *)jarg1;
29384   arg2 = (size_t)jarg2;
29385   {
29386     try {
29387       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
29388     } CALL_CATCH_EXCEPTION(0);
29389   }
29390
29391   jresult = (void *)result;
29392   return jresult;
29393 }
29394
29395
29396 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
29397   unsigned long jresult ;
29398   Dali::Path *arg1 = (Dali::Path *) 0 ;
29399   size_t result;
29400
29401   arg1 = (Dali::Path *)jarg1;
29402   {
29403     try {
29404       result = ((Dali::Path const *)arg1)->GetPointCount();
29405     } CALL_CATCH_EXCEPTION(0);
29406   }
29407
29408   jresult = (unsigned long)result;
29409   return jresult;
29410 }
29411
29412
29413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
29414   void * jresult ;
29415   float arg1 ;
29416   Dali::TimePeriod *result = 0 ;
29417
29418   arg1 = (float)jarg1;
29419   {
29420     try {
29421       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
29422     } CALL_CATCH_EXCEPTION(0);
29423   }
29424
29425   jresult = (void *)result;
29426   return jresult;
29427 }
29428
29429
29430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
29431   void * jresult ;
29432   float arg1 ;
29433   float arg2 ;
29434   Dali::TimePeriod *result = 0 ;
29435
29436   arg1 = (float)jarg1;
29437   arg2 = (float)jarg2;
29438   {
29439     try {
29440       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
29441     } CALL_CATCH_EXCEPTION(0);
29442   }
29443
29444   jresult = (void *)result;
29445   return jresult;
29446 }
29447
29448
29449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
29450   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
29451
29452   arg1 = (Dali::TimePeriod *)jarg1;
29453   {
29454     try {
29455       delete arg1;
29456     } CALL_CATCH_EXCEPTION();
29457   }
29458
29459 }
29460
29461
29462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
29463   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
29464   float arg2 ;
29465
29466   arg1 = (Dali::TimePeriod *)jarg1;
29467   arg2 = (float)jarg2;
29468   if (arg1) (arg1)->delaySeconds = arg2;
29469 }
29470
29471
29472 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
29473   float jresult ;
29474   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
29475   float result;
29476
29477   arg1 = (Dali::TimePeriod *)jarg1;
29478   result = (float) ((arg1)->delaySeconds);
29479   jresult = result;
29480   return jresult;
29481 }
29482
29483
29484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
29485   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
29486   float arg2 ;
29487
29488   arg1 = (Dali::TimePeriod *)jarg1;
29489   arg2 = (float)jarg2;
29490   if (arg1) (arg1)->durationSeconds = arg2;
29491 }
29492
29493
29494 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
29495   float jresult ;
29496   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
29497   float result;
29498
29499   arg1 = (Dali::TimePeriod *)jarg1;
29500   result = (float) ((arg1)->durationSeconds);
29501   jresult = result;
29502   return jresult;
29503 }
29504
29505 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
29506   int jresult ;
29507   int result;
29508
29509   result = (int)Dali::LinearConstrainer::Property::VALUE;
29510   jresult = (int)result;
29511   return jresult;
29512 }
29513
29514
29515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
29516   int jresult ;
29517   int result;
29518
29519   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
29520   jresult = (int)result;
29521   return jresult;
29522 }
29523
29524
29525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
29526   void * jresult ;
29527   Dali::LinearConstrainer::Property *result = 0 ;
29528
29529   {
29530     try {
29531       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
29532     } CALL_CATCH_EXCEPTION(0);
29533   }
29534
29535   jresult = (void *)result;
29536   return jresult;
29537 }
29538
29539
29540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
29541   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
29542
29543   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
29544   {
29545     try {
29546       delete arg1;
29547     } CALL_CATCH_EXCEPTION();
29548   }
29549
29550 }
29551
29552
29553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
29554   void * jresult ;
29555   Dali::LinearConstrainer result;
29556
29557   {
29558     try {
29559       result = Dali::LinearConstrainer::New();
29560     } CALL_CATCH_EXCEPTION(0);
29561   }
29562
29563   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
29564   return jresult;
29565 }
29566
29567
29568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
29569   void * jresult ;
29570   Dali::BaseHandle arg1 ;
29571   Dali::BaseHandle *argp1 ;
29572   Dali::LinearConstrainer result;
29573
29574   argp1 = (Dali::BaseHandle *)jarg1;
29575   if (!argp1) {
29576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29577     return 0;
29578   }
29579   arg1 = *argp1;
29580   {
29581     try {
29582       result = Dali::LinearConstrainer::DownCast(arg1);
29583     } CALL_CATCH_EXCEPTION(0);
29584   }
29585
29586   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
29587   return jresult;
29588 }
29589
29590
29591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
29592   void * jresult ;
29593   Dali::LinearConstrainer *result = 0 ;
29594
29595   {
29596     try {
29597       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
29598     } CALL_CATCH_EXCEPTION(0);
29599   }
29600
29601   jresult = (void *)result;
29602   return jresult;
29603 }
29604
29605
29606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
29607   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
29608
29609   arg1 = (Dali::LinearConstrainer *)jarg1;
29610   {
29611     try {
29612       delete arg1;
29613     } CALL_CATCH_EXCEPTION();
29614   }
29615
29616 }
29617
29618
29619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
29620   void * jresult ;
29621   Dali::LinearConstrainer *arg1 = 0 ;
29622   Dali::LinearConstrainer *result = 0 ;
29623
29624   arg1 = (Dali::LinearConstrainer *)jarg1;
29625   if (!arg1) {
29626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
29627     return 0;
29628   }
29629   {
29630     try {
29631       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
29632     } CALL_CATCH_EXCEPTION(0);
29633   }
29634
29635   jresult = (void *)result;
29636   return jresult;
29637 }
29638
29639
29640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
29641   void * jresult ;
29642   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
29643   Dali::LinearConstrainer *arg2 = 0 ;
29644   Dali::LinearConstrainer *result = 0 ;
29645
29646   arg1 = (Dali::LinearConstrainer *)jarg1;
29647   arg2 = (Dali::LinearConstrainer *)jarg2;
29648   if (!arg2) {
29649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
29650     return 0;
29651   }
29652   {
29653     try {
29654       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
29655     } CALL_CATCH_EXCEPTION(0);
29656   }
29657
29658   jresult = (void *)result;
29659   return jresult;
29660 }
29661
29662
29663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
29664   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
29665   SwigValueWrapper< Dali::Property > arg2 ;
29666   SwigValueWrapper< Dali::Property > arg3 ;
29667   Dali::Vector2 *arg4 = 0 ;
29668   Dali::Vector2 *arg5 = 0 ;
29669   Dali::Property *argp2 ;
29670   Dali::Property *argp3 ;
29671
29672   arg1 = (Dali::LinearConstrainer *)jarg1;
29673   argp2 = (Dali::Property *)jarg2;
29674   if (!argp2) {
29675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
29676     return ;
29677   }
29678   arg2 = *argp2;
29679   argp3 = (Dali::Property *)jarg3;
29680   if (!argp3) {
29681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
29682     return ;
29683   }
29684   arg3 = *argp3;
29685   arg4 = (Dali::Vector2 *)jarg4;
29686   if (!arg4) {
29687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29688     return ;
29689   }
29690   arg5 = (Dali::Vector2 *)jarg5;
29691   if (!arg5) {
29692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29693     return ;
29694   }
29695   {
29696     try {
29697       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
29698     } CALL_CATCH_EXCEPTION();
29699   }
29700
29701 }
29702
29703
29704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
29705   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
29706   SwigValueWrapper< Dali::Property > arg2 ;
29707   SwigValueWrapper< Dali::Property > arg3 ;
29708   Dali::Vector2 *arg4 = 0 ;
29709   Dali::Property *argp2 ;
29710   Dali::Property *argp3 ;
29711
29712   arg1 = (Dali::LinearConstrainer *)jarg1;
29713   argp2 = (Dali::Property *)jarg2;
29714   if (!argp2) {
29715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
29716     return ;
29717   }
29718   arg2 = *argp2;
29719   argp3 = (Dali::Property *)jarg3;
29720   if (!argp3) {
29721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
29722     return ;
29723   }
29724   arg3 = *argp3;
29725   arg4 = (Dali::Vector2 *)jarg4;
29726   if (!arg4) {
29727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29728     return ;
29729   }
29730   {
29731     try {
29732       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
29733     } CALL_CATCH_EXCEPTION();
29734   }
29735
29736 }
29737
29738
29739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
29740   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
29741   Dali::Handle *arg2 = 0 ;
29742
29743   arg1 = (Dali::LinearConstrainer *)jarg1;
29744   arg2 = (Dali::Handle *)jarg2;
29745   if (!arg2) {
29746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
29747     return ;
29748   }
29749   {
29750     try {
29751       (arg1)->Remove(*arg2);
29752     } CALL_CATCH_EXCEPTION();
29753   }
29754
29755 }
29756
29757
29758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
29759   int jresult ;
29760   int result;
29761
29762   result = (int)Dali::PathConstrainer::Property::FORWARD;
29763   jresult = (int)result;
29764   return jresult;
29765 }
29766
29767
29768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
29769   int jresult ;
29770   int result;
29771
29772   result = (int)Dali::PathConstrainer::Property::POINTS;
29773   jresult = (int)result;
29774   return jresult;
29775 }
29776
29777
29778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
29779   int jresult ;
29780   int result;
29781
29782   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
29783   jresult = (int)result;
29784   return jresult;
29785 }
29786
29787
29788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
29789   void * jresult ;
29790   Dali::PathConstrainer::Property *result = 0 ;
29791
29792   {
29793     try {
29794       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
29795     } CALL_CATCH_EXCEPTION(0);
29796   }
29797
29798   jresult = (void *)result;
29799   return jresult;
29800 }
29801
29802
29803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
29804   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
29805
29806   arg1 = (Dali::PathConstrainer::Property *)jarg1;
29807   {
29808     try {
29809       delete arg1;
29810     } CALL_CATCH_EXCEPTION();
29811   }
29812
29813 }
29814
29815
29816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
29817   void * jresult ;
29818   Dali::PathConstrainer result;
29819
29820   {
29821     try {
29822       result = Dali::PathConstrainer::New();
29823     } CALL_CATCH_EXCEPTION(0);
29824   }
29825
29826   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
29827   return jresult;
29828 }
29829
29830
29831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
29832   void * jresult ;
29833   Dali::BaseHandle arg1 ;
29834   Dali::BaseHandle *argp1 ;
29835   Dali::PathConstrainer result;
29836
29837   argp1 = (Dali::BaseHandle *)jarg1;
29838   if (!argp1) {
29839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29840     return 0;
29841   }
29842   arg1 = *argp1;
29843   {
29844     try {
29845       result = Dali::PathConstrainer::DownCast(arg1);
29846     } CALL_CATCH_EXCEPTION(0);
29847   }
29848
29849   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
29850   return jresult;
29851 }
29852
29853
29854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
29855   void * jresult ;
29856   Dali::PathConstrainer *result = 0 ;
29857
29858   {
29859     try {
29860       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
29861     } CALL_CATCH_EXCEPTION(0);
29862   }
29863
29864   jresult = (void *)result;
29865   return jresult;
29866 }
29867
29868
29869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
29870   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
29871
29872   arg1 = (Dali::PathConstrainer *)jarg1;
29873   {
29874     try {
29875       delete arg1;
29876     } CALL_CATCH_EXCEPTION();
29877   }
29878
29879 }
29880
29881
29882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
29883   void * jresult ;
29884   Dali::PathConstrainer *arg1 = 0 ;
29885   Dali::PathConstrainer *result = 0 ;
29886
29887   arg1 = (Dali::PathConstrainer *)jarg1;
29888   if (!arg1) {
29889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
29890     return 0;
29891   }
29892   {
29893     try {
29894       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
29895     } CALL_CATCH_EXCEPTION(0);
29896   }
29897
29898   jresult = (void *)result;
29899   return jresult;
29900 }
29901
29902
29903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
29904   void * jresult ;
29905   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
29906   Dali::PathConstrainer *arg2 = 0 ;
29907   Dali::PathConstrainer *result = 0 ;
29908
29909   arg1 = (Dali::PathConstrainer *)jarg1;
29910   arg2 = (Dali::PathConstrainer *)jarg2;
29911   if (!arg2) {
29912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
29913     return 0;
29914   }
29915   {
29916     try {
29917       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
29918     } CALL_CATCH_EXCEPTION(0);
29919   }
29920
29921   jresult = (void *)result;
29922   return jresult;
29923 }
29924
29925
29926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
29927   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
29928   SwigValueWrapper< Dali::Property > arg2 ;
29929   SwigValueWrapper< Dali::Property > arg3 ;
29930   Dali::Vector2 *arg4 = 0 ;
29931   Dali::Vector2 *arg5 = 0 ;
29932   Dali::Property *argp2 ;
29933   Dali::Property *argp3 ;
29934
29935   arg1 = (Dali::PathConstrainer *)jarg1;
29936   argp2 = (Dali::Property *)jarg2;
29937   if (!argp2) {
29938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
29939     return ;
29940   }
29941   arg2 = *argp2;
29942   argp3 = (Dali::Property *)jarg3;
29943   if (!argp3) {
29944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
29945     return ;
29946   }
29947   arg3 = *argp3;
29948   arg4 = (Dali::Vector2 *)jarg4;
29949   if (!arg4) {
29950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29951     return ;
29952   }
29953   arg5 = (Dali::Vector2 *)jarg5;
29954   if (!arg5) {
29955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29956     return ;
29957   }
29958   {
29959     try {
29960       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
29961     } CALL_CATCH_EXCEPTION();
29962   }
29963
29964 }
29965
29966
29967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
29968   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
29969   SwigValueWrapper< Dali::Property > arg2 ;
29970   SwigValueWrapper< Dali::Property > arg3 ;
29971   Dali::Vector2 *arg4 = 0 ;
29972   Dali::Property *argp2 ;
29973   Dali::Property *argp3 ;
29974
29975   arg1 = (Dali::PathConstrainer *)jarg1;
29976   argp2 = (Dali::Property *)jarg2;
29977   if (!argp2) {
29978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
29979     return ;
29980   }
29981   arg2 = *argp2;
29982   argp3 = (Dali::Property *)jarg3;
29983   if (!argp3) {
29984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
29985     return ;
29986   }
29987   arg3 = *argp3;
29988   arg4 = (Dali::Vector2 *)jarg4;
29989   if (!arg4) {
29990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29991     return ;
29992   }
29993   {
29994     try {
29995       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
29996     } CALL_CATCH_EXCEPTION();
29997   }
29998
29999 }
30000
30001
30002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
30003   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
30004   Dali::Handle *arg2 = 0 ;
30005
30006   arg1 = (Dali::PathConstrainer *)jarg1;
30007   arg2 = (Dali::Handle *)jarg2;
30008   if (!arg2) {
30009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
30010     return ;
30011   }
30012   {
30013     try {
30014       (arg1)->Remove(*arg2);
30015     } CALL_CATCH_EXCEPTION();
30016   }
30017
30018 }
30019
30020
30021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
30022   int jresult ;
30023   Dali::FittingMode::Type result;
30024
30025   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
30026   jresult = (int)result;
30027   return jresult;
30028 }
30029
30030
30031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
30032   int jresult ;
30033   Dali::SamplingMode::Type result;
30034
30035   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
30036   jresult = (int)result;
30037   return jresult;
30038 }
30039
30040
30041 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageInterface_CreateResource(void * jarg1) {
30042   bool jresult ;
30043   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
30044   bool result;
30045
30046   arg1 = (Dali::NativeImageInterface *)jarg1;
30047   {
30048     try {
30049       result = (bool)(arg1)->CreateResource();
30050     } CALL_CATCH_EXCEPTION(0);
30051   }
30052
30053   jresult = result;
30054   return jresult;
30055 }
30056
30057
30058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_DestroyResource(void * jarg1) {
30059   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
30060
30061   arg1 = (Dali::NativeImageInterface *)jarg1;
30062   {
30063     try {
30064       (arg1)->DestroyResource();
30065     } CALL_CATCH_EXCEPTION();
30066   }
30067
30068 }
30069
30070
30071 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
30072   unsigned int jresult ;
30073   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
30074   unsigned int result;
30075
30076   arg1 = (Dali::NativeImageInterface *)jarg1;
30077   {
30078     try {
30079       result = (unsigned int)(arg1)->TargetTexture();
30080     } CALL_CATCH_EXCEPTION(0);
30081   }
30082
30083   jresult = result;
30084   return jresult;
30085 }
30086
30087
30088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
30089   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
30090
30091   arg1 = (Dali::NativeImageInterface *)jarg1;
30092   {
30093     try {
30094       (arg1)->PrepareTexture();
30095     } CALL_CATCH_EXCEPTION();
30096   }
30097
30098 }
30099
30100
30101 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
30102   unsigned int jresult ;
30103   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
30104   unsigned int result;
30105
30106   arg1 = (Dali::NativeImageInterface *)jarg1;
30107   {
30108     try {
30109       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
30110     } CALL_CATCH_EXCEPTION(0);
30111   }
30112
30113   jresult = result;
30114   return jresult;
30115 }
30116
30117
30118 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
30119   unsigned int jresult ;
30120   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
30121   unsigned int result;
30122
30123   arg1 = (Dali::NativeImageInterface *)jarg1;
30124   {
30125     try {
30126       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
30127     } CALL_CATCH_EXCEPTION(0);
30128   }
30129
30130   jresult = result;
30131   return jresult;
30132 }
30133
30134
30135 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
30136   bool jresult ;
30137   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
30138   bool result;
30139
30140   arg1 = (Dali::NativeImageInterface *)jarg1;
30141   {
30142     try {
30143       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
30144     } CALL_CATCH_EXCEPTION(0);
30145   }
30146
30147   jresult = result;
30148   return jresult;
30149 }
30150
30151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
30152   int jresult ;
30153   int result;
30154
30155   result = (int)Dali::CameraActor::Property::TYPE;
30156   jresult = (int)result;
30157   return jresult;
30158 }
30159
30160
30161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
30162   int jresult ;
30163   int result;
30164
30165   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
30166   jresult = (int)result;
30167   return jresult;
30168 }
30169
30170
30171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
30172   int jresult ;
30173   int result;
30174
30175   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
30176   jresult = (int)result;
30177   return jresult;
30178 }
30179
30180
30181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
30182   int jresult ;
30183   int result;
30184
30185   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
30186   jresult = (int)result;
30187   return jresult;
30188 }
30189
30190
30191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
30192   int jresult ;
30193   int result;
30194
30195   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
30196   jresult = (int)result;
30197   return jresult;
30198 }
30199
30200
30201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
30202   int jresult ;
30203   int result;
30204
30205   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
30206   jresult = (int)result;
30207   return jresult;
30208 }
30209
30210
30211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
30212   int jresult ;
30213   int result;
30214
30215   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
30216   jresult = (int)result;
30217   return jresult;
30218 }
30219
30220
30221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
30222   int jresult ;
30223   int result;
30224
30225   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
30226   jresult = (int)result;
30227   return jresult;
30228 }
30229
30230
30231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
30232   int jresult ;
30233   int result;
30234
30235   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
30236   jresult = (int)result;
30237   return jresult;
30238 }
30239
30240
30241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
30242   int jresult ;
30243   int result;
30244
30245   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
30246   jresult = (int)result;
30247   return jresult;
30248 }
30249
30250
30251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
30252   int jresult ;
30253   int result;
30254
30255   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
30256   jresult = (int)result;
30257   return jresult;
30258 }
30259
30260
30261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
30262   int jresult ;
30263   int result;
30264
30265   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
30266   jresult = (int)result;
30267   return jresult;
30268 }
30269
30270
30271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
30272   int jresult ;
30273   int result;
30274
30275   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
30276   jresult = (int)result;
30277   return jresult;
30278 }
30279
30280
30281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
30282   int jresult ;
30283   int result;
30284
30285   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
30286   jresult = (int)result;
30287   return jresult;
30288 }
30289
30290
30291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ORTHOGRAPHIC_SIZE_get() {
30292   int jresult ;
30293   int result;
30294
30295   result = (int)Dali::DevelCameraActor::Property::ORTHOGRAPHIC_SIZE;
30296   jresult = (int)result;
30297   return jresult;
30298 }
30299
30300
30301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_DIRECTION_get() {
30302   int jresult ;
30303   int result;
30304
30305   result = (int)Dali::DevelCameraActor::Property::PROJECTION_DIRECTION;
30306   jresult = (int)result;
30307   return jresult;
30308 }
30309
30310
30311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
30312   void * jresult ;
30313   Dali::CameraActor::Property *result = 0 ;
30314
30315   {
30316     try {
30317       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
30318     } CALL_CATCH_EXCEPTION(0);
30319   }
30320
30321   jresult = (void *)result;
30322   return jresult;
30323 }
30324
30325
30326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
30327   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
30328
30329   arg1 = (Dali::CameraActor::Property *)jarg1;
30330   {
30331     try {
30332       delete arg1;
30333     } CALL_CATCH_EXCEPTION();
30334   }
30335
30336 }
30337
30338
30339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
30340   void * jresult ;
30341   Dali::CameraActor *result = 0 ;
30342
30343   {
30344     try {
30345       result = (Dali::CameraActor *)new Dali::CameraActor();
30346     } CALL_CATCH_EXCEPTION(0);
30347   }
30348
30349   jresult = (void *)result;
30350   return jresult;
30351 }
30352
30353
30354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
30355   void * jresult ;
30356   Dali::CameraActor result;
30357
30358   {
30359     try {
30360       result = Dali::CameraActor::New();
30361     } CALL_CATCH_EXCEPTION(0);
30362   }
30363
30364   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
30365   return jresult;
30366 }
30367
30368
30369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
30370   void * jresult ;
30371   Dali::Size *arg1 = 0 ;
30372   Dali::CameraActor result;
30373
30374   arg1 = (Dali::Size *)jarg1;
30375   if (!arg1) {
30376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
30377     return 0;
30378   }
30379   {
30380     try {
30381       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
30382     } CALL_CATCH_EXCEPTION(0);
30383   }
30384
30385   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
30386   return jresult;
30387 }
30388
30389
30390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New3DCamera() {
30391   void * jresult ;
30392   Dali::CameraActor result;
30393
30394   {
30395     try {
30396       result = Dali::CameraActor::New3DCamera();
30397     } CALL_CATCH_EXCEPTION(0);
30398   }
30399
30400   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
30401   return jresult;
30402 }
30403
30404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
30405   void * jresult ;
30406   Dali::BaseHandle arg1 ;
30407   Dali::BaseHandle *argp1 ;
30408   Dali::CameraActor result;
30409
30410   argp1 = (Dali::BaseHandle *)jarg1;
30411   if (!argp1) {
30412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30413     return 0;
30414   }
30415   arg1 = *argp1;
30416   {
30417     try {
30418       result = Dali::CameraActor::DownCast(arg1);
30419     } CALL_CATCH_EXCEPTION(0);
30420   }
30421
30422   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
30423   return jresult;
30424 }
30425
30426
30427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
30428   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30429
30430   arg1 = (Dali::CameraActor *)jarg1;
30431   {
30432     try {
30433       delete arg1;
30434     } CALL_CATCH_EXCEPTION();
30435   }
30436
30437 }
30438
30439
30440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
30441   void * jresult ;
30442   Dali::CameraActor *arg1 = 0 ;
30443   Dali::CameraActor *result = 0 ;
30444
30445   arg1 = (Dali::CameraActor *)jarg1;
30446   if (!arg1) {
30447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
30448     return 0;
30449   }
30450   {
30451     try {
30452       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
30453     } CALL_CATCH_EXCEPTION(0);
30454   }
30455
30456   jresult = (void *)result;
30457   return jresult;
30458 }
30459
30460
30461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
30462   void * jresult ;
30463   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30464   Dali::CameraActor *arg2 = 0 ;
30465   Dali::CameraActor *result = 0 ;
30466
30467   arg1 = (Dali::CameraActor *)jarg1;
30468   arg2 = (Dali::CameraActor *)jarg2;
30469   if (!arg2) {
30470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
30471     return 0;
30472   }
30473   {
30474     try {
30475       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
30476     } CALL_CATCH_EXCEPTION(0);
30477   }
30478
30479   jresult = (void *)result;
30480   return jresult;
30481 }
30482
30483
30484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
30485   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30486   Dali::Camera::Type arg2 ;
30487
30488   arg1 = (Dali::CameraActor *)jarg1;
30489   arg2 = (Dali::Camera::Type)jarg2;
30490   {
30491     try {
30492       (arg1)->SetType(arg2);
30493     } CALL_CATCH_EXCEPTION();
30494   }
30495
30496 }
30497
30498
30499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
30500   int jresult ;
30501   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30502   Dali::Camera::Type result;
30503
30504   arg1 = (Dali::CameraActor *)jarg1;
30505   {
30506     try {
30507       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
30508     } CALL_CATCH_EXCEPTION(0);
30509   }
30510
30511   jresult = (int)result;
30512   return jresult;
30513 }
30514
30515
30516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
30517   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30518   Dali::Camera::ProjectionMode arg2 ;
30519
30520   arg1 = (Dali::CameraActor *)jarg1;
30521   arg2 = (Dali::Camera::ProjectionMode)jarg2;
30522   {
30523     try {
30524       (arg1)->SetProjectionMode(arg2);
30525     } CALL_CATCH_EXCEPTION();
30526   }
30527
30528 }
30529
30530
30531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
30532   int jresult ;
30533   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30534   Dali::Camera::ProjectionMode result;
30535
30536   arg1 = (Dali::CameraActor *)jarg1;
30537   {
30538     try {
30539       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
30540     } CALL_CATCH_EXCEPTION(0);
30541   }
30542
30543   jresult = (int)result;
30544   return jresult;
30545 }
30546
30547
30548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
30549   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30550   float arg2 ;
30551
30552   arg1 = (Dali::CameraActor *)jarg1;
30553   arg2 = (float)jarg2;
30554   {
30555     try {
30556       (arg1)->SetFieldOfView(arg2);
30557     } CALL_CATCH_EXCEPTION();
30558   }
30559
30560 }
30561
30562
30563 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
30564   float jresult ;
30565   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30566   float result;
30567
30568   arg1 = (Dali::CameraActor *)jarg1;
30569   {
30570     try {
30571       result = (float)(arg1)->GetFieldOfView();
30572     } CALL_CATCH_EXCEPTION(0);
30573   }
30574
30575   jresult = result;
30576   return jresult;
30577 }
30578
30579
30580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
30581   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30582   float arg2 ;
30583
30584   arg1 = (Dali::CameraActor *)jarg1;
30585   arg2 = (float)jarg2;
30586   {
30587     try {
30588       (arg1)->SetAspectRatio(arg2);
30589     } CALL_CATCH_EXCEPTION();
30590   }
30591
30592 }
30593
30594
30595 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
30596   float jresult ;
30597   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30598   float result;
30599
30600   arg1 = (Dali::CameraActor *)jarg1;
30601   {
30602     try {
30603       result = (float)(arg1)->GetAspectRatio();
30604     } CALL_CATCH_EXCEPTION(0);
30605   }
30606
30607   jresult = result;
30608   return jresult;
30609 }
30610
30611
30612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
30613   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30614   float arg2 ;
30615
30616   arg1 = (Dali::CameraActor *)jarg1;
30617   arg2 = (float)jarg2;
30618   {
30619     try {
30620       (arg1)->SetNearClippingPlane(arg2);
30621     } CALL_CATCH_EXCEPTION();
30622   }
30623
30624 }
30625
30626
30627 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
30628   float jresult ;
30629   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30630   float result;
30631
30632   arg1 = (Dali::CameraActor *)jarg1;
30633   {
30634     try {
30635       result = (float)(arg1)->GetNearClippingPlane();
30636     } CALL_CATCH_EXCEPTION(0);
30637   }
30638
30639   jresult = result;
30640   return jresult;
30641 }
30642
30643
30644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
30645   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30646   float arg2 ;
30647
30648   arg1 = (Dali::CameraActor *)jarg1;
30649   arg2 = (float)jarg2;
30650   {
30651     try {
30652       (arg1)->SetFarClippingPlane(arg2);
30653     } CALL_CATCH_EXCEPTION();
30654   }
30655
30656 }
30657
30658
30659 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
30660   float jresult ;
30661   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30662   float result;
30663
30664   arg1 = (Dali::CameraActor *)jarg1;
30665   {
30666     try {
30667       result = (float)(arg1)->GetFarClippingPlane();
30668     } CALL_CATCH_EXCEPTION(0);
30669   }
30670
30671   jresult = result;
30672   return jresult;
30673 }
30674
30675
30676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
30677   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30678   Dali::Vector3 *arg2 = 0 ;
30679
30680   arg1 = (Dali::CameraActor *)jarg1;
30681   arg2 = (Dali::Vector3 *)jarg2;
30682   if (!arg2) {
30683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30684     return ;
30685   }
30686   {
30687     try {
30688       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
30689     } CALL_CATCH_EXCEPTION();
30690   }
30691
30692 }
30693
30694
30695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
30696   void * jresult ;
30697   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30698   Dali::Vector3 result;
30699
30700   arg1 = (Dali::CameraActor *)jarg1;
30701   {
30702     try {
30703       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
30704     } CALL_CATCH_EXCEPTION(0);
30705   }
30706
30707   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30708   return jresult;
30709 }
30710
30711
30712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, bool jarg2) {
30713   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30714   bool arg2 ;
30715
30716   arg1 = (Dali::CameraActor *)jarg1;
30717   arg2 = jarg2 ? true : false;
30718   {
30719     try {
30720       (arg1)->SetInvertYAxis(arg2);
30721     } CALL_CATCH_EXCEPTION();
30722   }
30723
30724 }
30725
30726
30727 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
30728   bool jresult ;
30729   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30730   bool result;
30731
30732   arg1 = (Dali::CameraActor *)jarg1;
30733   {
30734     try {
30735       result = (bool)(arg1)->GetInvertYAxis();
30736     } CALL_CATCH_EXCEPTION(0);
30737   }
30738
30739   jresult = result;
30740   return jresult;
30741 }
30742
30743
30744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
30745   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30746   Dali::Size *arg2 = 0 ;
30747
30748   arg1 = (Dali::CameraActor *)jarg1;
30749   arg2 = (Dali::Size *)jarg2;
30750   if (!arg2) {
30751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
30752     return ;
30753   }
30754   {
30755     try {
30756       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
30757     } CALL_CATCH_EXCEPTION();
30758   }
30759
30760 }
30761
30762
30763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
30764   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
30765   Dali::Size *arg2 = 0 ;
30766
30767   arg1 = (Dali::CameraActor *)jarg1;
30768   arg2 = (Dali::Size *)jarg2;
30769   if (!arg2) {
30770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
30771     return ;
30772   }
30773   {
30774     try {
30775       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
30776     } CALL_CATCH_EXCEPTION();
30777   }
30778
30779 }
30780
30781
30782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
30783   void * jresult ;
30784   std::pair< std::string,Dali::Property::Value > *result = 0 ;
30785
30786   {
30787     try {
30788       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
30789     } CALL_CATCH_EXCEPTION(0);
30790   }
30791
30792   jresult = (void *)result;
30793   return jresult;
30794 }
30795
30796
30797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
30798   void * jresult ;
30799   std::string arg1 ;
30800   Dali::Property::Value arg2 ;
30801   Dali::Property::Value *argp2 ;
30802   std::pair< std::string,Dali::Property::Value > *result = 0 ;
30803
30804   if (!jarg1) {
30805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30806     return 0;
30807   }
30808   (&arg1)->assign(jarg1);
30809   argp2 = (Dali::Property::Value *)jarg2;
30810   if (!argp2) {
30811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
30812     return 0;
30813   }
30814   arg2 = *argp2;
30815   {
30816     try {
30817       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
30818     } CALL_CATCH_EXCEPTION(0);
30819   }
30820
30821   jresult = (void *)result;
30822   return jresult;
30823 }
30824
30825
30826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
30827   void * jresult ;
30828   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
30829   std::pair< std::string,Dali::Property::Value > *result = 0 ;
30830
30831   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
30832   if (!arg1) {
30833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
30834     return 0;
30835   }
30836   {
30837     try {
30838       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);
30839     } CALL_CATCH_EXCEPTION(0);
30840   }
30841
30842   jresult = (void *)result;
30843   return jresult;
30844 }
30845
30846
30847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
30848   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
30849   std::string *arg2 = 0 ;
30850
30851   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
30852   if (!jarg2) {
30853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30854     return ;
30855   }
30856   std::string arg2_str(jarg2);
30857   arg2 = &arg2_str;
30858   if (arg1) (arg1)->first = *arg2;
30859
30860   //argout typemap for const std::string&
30861
30862 }
30863
30864
30865 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
30866   char * jresult ;
30867   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
30868   std::string *result = 0 ;
30869
30870   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
30871   result = (std::string *) & ((arg1)->first);
30872   jresult = SWIG_csharp_string_callback(result->c_str());
30873   return jresult;
30874 }
30875
30876
30877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
30878   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
30879   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
30880
30881   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
30882   arg2 = (Dali::Property::Value *)jarg2;
30883   if (arg1) (arg1)->second = *arg2;
30884 }
30885
30886
30887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
30888   void * jresult ;
30889   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
30890   Dali::Property::Value *result = 0 ;
30891
30892   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
30893   result = (Dali::Property::Value *)& ((arg1)->second);
30894   jresult = (void *)result;
30895   return jresult;
30896 }
30897
30898
30899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
30900   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
30901
30902   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
30903   {
30904     try {
30905       delete arg1;
30906     } CALL_CATCH_EXCEPTION();
30907   }
30908
30909 }
30910
30911
30912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
30913   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30914
30915   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30916   {
30917     try {
30918       (arg1)->clear();
30919     } CALL_CATCH_EXCEPTION();
30920   }
30921
30922 }
30923
30924
30925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
30926   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30927   Dali::TouchPoint *arg2 = 0 ;
30928
30929   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30930   arg2 = (Dali::TouchPoint *)jarg2;
30931   if (!arg2) {
30932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
30933     return ;
30934   }
30935   {
30936     try {
30937       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
30938     } CALL_CATCH_EXCEPTION();
30939   }
30940
30941 }
30942
30943
30944 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
30945   unsigned long jresult ;
30946   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30947   std::vector< Dali::TouchPoint >::size_type result;
30948
30949   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30950   {
30951     try {
30952       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
30953     } CALL_CATCH_EXCEPTION(0);
30954   }
30955
30956   jresult = (unsigned long)result;
30957   return jresult;
30958 }
30959
30960
30961 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
30962   unsigned long jresult ;
30963   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30964   std::vector< Dali::TouchPoint >::size_type result;
30965
30966   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30967   {
30968     try {
30969       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
30970     } CALL_CATCH_EXCEPTION(0);
30971   }
30972
30973   jresult = (unsigned long)result;
30974   return jresult;
30975 }
30976
30977
30978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
30979   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
30980   std::vector< Dali::TouchPoint >::size_type arg2 ;
30981
30982   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
30983   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
30984   {
30985     try {
30986       (arg1)->reserve(arg2);
30987     } CALL_CATCH_EXCEPTION();
30988   }
30989
30990 }
30991
30992
30993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
30994   void * jresult ;
30995   std::vector< Dali::TouchPoint > *result = 0 ;
30996
30997   {
30998     try {
30999       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
31000     } CALL_CATCH_EXCEPTION(0);
31001   }
31002
31003   jresult = (void *)result;
31004   return jresult;
31005 }
31006
31007
31008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
31009   void * jresult ;
31010   std::vector< Dali::TouchPoint > *arg1 = 0 ;
31011   std::vector< Dali::TouchPoint > *result = 0 ;
31012
31013   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
31014   if (!arg1) {
31015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
31016     return 0;
31017   }
31018   {
31019     try {
31020       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
31021     } CALL_CATCH_EXCEPTION(0);
31022   }
31023
31024   jresult = (void *)result;
31025   return jresult;
31026 }
31027
31028
31029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
31030   void * jresult ;
31031   int arg1 ;
31032   std::vector< Dali::TouchPoint > *result = 0 ;
31033
31034   arg1 = (int)jarg1;
31035   {
31036     try {
31037       try {
31038         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
31039       }
31040       catch(std::out_of_range &_e) {
31041         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
31042         return 0;
31043       }
31044
31045     } CALL_CATCH_EXCEPTION(0);
31046   }
31047
31048   jresult = (void *)result;
31049   return jresult;
31050 }
31051
31052
31053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
31054   void * jresult ;
31055   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
31056   int arg2 ;
31057   SwigValueWrapper< Dali::TouchPoint > result;
31058
31059   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
31060   arg2 = (int)jarg2;
31061   {
31062     try {
31063       try {
31064         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
31065       }
31066       catch(std::out_of_range &_e) {
31067         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
31068         return 0;
31069       }
31070
31071     } CALL_CATCH_EXCEPTION(0);
31072   }
31073
31074   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
31075   return jresult;
31076 }
31077
31078
31079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
31080   void * jresult ;
31081   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
31082   int arg2 ;
31083   Dali::TouchPoint *result = 0 ;
31084
31085   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
31086   arg2 = (int)jarg2;
31087   {
31088     try {
31089       try {
31090         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
31091       }
31092       catch(std::out_of_range &_e) {
31093         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
31094         return 0;
31095       }
31096
31097     } CALL_CATCH_EXCEPTION(0);
31098   }
31099
31100   jresult = (void *)result;
31101   return jresult;
31102 }
31103
31104
31105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
31106   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
31107   int arg2 ;
31108   Dali::TouchPoint *arg3 = 0 ;
31109
31110   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
31111   arg2 = (int)jarg2;
31112   arg3 = (Dali::TouchPoint *)jarg3;
31113   if (!arg3) {
31114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
31115     return ;
31116   }
31117   {
31118     try {
31119       try {
31120         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
31121       }
31122       catch(std::out_of_range &_e) {
31123         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
31124         return ;
31125       }
31126
31127     } CALL_CATCH_EXCEPTION();
31128   }
31129
31130 }
31131
31132
31133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
31134   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
31135   std::vector< Dali::TouchPoint > *arg2 = 0 ;
31136
31137   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
31138   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
31139   if (!arg2) {
31140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
31141     return ;
31142   }
31143   {
31144     try {
31145       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
31146     } CALL_CATCH_EXCEPTION();
31147   }
31148
31149 }
31150
31151
31152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
31153   void * jresult ;
31154   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
31155   int arg2 ;
31156   int arg3 ;
31157   std::vector< Dali::TouchPoint > *result = 0 ;
31158
31159   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
31160   arg2 = (int)jarg2;
31161   arg3 = (int)jarg3;
31162   {
31163     try {
31164       try {
31165         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
31166       }
31167       catch(std::out_of_range &_e) {
31168         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
31169         return 0;
31170       }
31171       catch(std::invalid_argument &_e) {
31172         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
31173         return 0;
31174       }
31175
31176     } CALL_CATCH_EXCEPTION(0);
31177   }
31178
31179   jresult = (void *)result;
31180   return jresult;
31181 }
31182
31183
31184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
31185   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
31186   int arg2 ;
31187   Dali::TouchPoint *arg3 = 0 ;
31188
31189   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
31190   arg2 = (int)jarg2;
31191   arg3 = (Dali::TouchPoint *)jarg3;
31192   if (!arg3) {
31193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
31194     return ;
31195   }
31196   {
31197     try {
31198       try {
31199         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
31200       }
31201       catch(std::out_of_range &_e) {
31202         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
31203         return ;
31204       }
31205
31206     } CALL_CATCH_EXCEPTION();
31207   }
31208
31209 }
31210
31211
31212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
31213   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
31214   int arg2 ;
31215   std::vector< Dali::TouchPoint > *arg3 = 0 ;
31216
31217   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
31218   arg2 = (int)jarg2;
31219   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
31220   if (!arg3) {
31221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
31222     return ;
31223   }
31224   {
31225     try {
31226       try {
31227         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
31228       }
31229       catch(std::out_of_range &_e) {
31230         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
31231         return ;
31232       }
31233
31234     } CALL_CATCH_EXCEPTION();
31235   }
31236
31237 }
31238
31239
31240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
31241   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
31242   int arg2 ;
31243
31244   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
31245   arg2 = (int)jarg2;
31246   {
31247     try {
31248       try {
31249         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
31250       }
31251       catch(std::out_of_range &_e) {
31252         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
31253         return ;
31254       }
31255
31256     } CALL_CATCH_EXCEPTION();
31257   }
31258
31259 }
31260
31261
31262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
31263   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
31264   int arg2 ;
31265   int arg3 ;
31266
31267   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
31268   arg2 = (int)jarg2;
31269   arg3 = (int)jarg3;
31270   {
31271     try {
31272       try {
31273         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
31274       }
31275       catch(std::out_of_range &_e) {
31276         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
31277         return ;
31278       }
31279       catch(std::invalid_argument &_e) {
31280         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
31281         return ;
31282       }
31283
31284     } CALL_CATCH_EXCEPTION();
31285   }
31286
31287 }
31288
31289
31290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
31291   void * jresult ;
31292   Dali::TouchPoint *arg1 = 0 ;
31293   int arg2 ;
31294   std::vector< Dali::TouchPoint > *result = 0 ;
31295
31296   arg1 = (Dali::TouchPoint *)jarg1;
31297   if (!arg1) {
31298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
31299     return 0;
31300   }
31301   arg2 = (int)jarg2;
31302   {
31303     try {
31304       try {
31305         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
31306       }
31307       catch(std::out_of_range &_e) {
31308         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
31309         return 0;
31310       }
31311
31312     } CALL_CATCH_EXCEPTION(0);
31313   }
31314
31315   jresult = (void *)result;
31316   return jresult;
31317 }
31318
31319
31320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
31321   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
31322
31323   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
31324   {
31325     try {
31326       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
31327     } CALL_CATCH_EXCEPTION();
31328   }
31329
31330 }
31331
31332
31333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
31334   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
31335   int arg2 ;
31336   int arg3 ;
31337
31338   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
31339   arg2 = (int)jarg2;
31340   arg3 = (int)jarg3;
31341   {
31342     try {
31343       try {
31344         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
31345       }
31346       catch(std::out_of_range &_e) {
31347         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
31348         return ;
31349       }
31350       catch(std::invalid_argument &_e) {
31351         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
31352         return ;
31353       }
31354
31355     } CALL_CATCH_EXCEPTION();
31356   }
31357
31358 }
31359
31360
31361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
31362   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
31363   int arg2 ;
31364   std::vector< Dali::TouchPoint > *arg3 = 0 ;
31365
31366   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
31367   arg2 = (int)jarg2;
31368   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
31369   if (!arg3) {
31370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
31371     return ;
31372   }
31373   {
31374     try {
31375       try {
31376         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
31377       }
31378       catch(std::out_of_range &_e) {
31379         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
31380         return ;
31381       }
31382
31383     } CALL_CATCH_EXCEPTION();
31384   }
31385
31386 }
31387
31388
31389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
31390   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
31391
31392   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
31393   {
31394     try {
31395       delete arg1;
31396     } CALL_CATCH_EXCEPTION();
31397   }
31398
31399 }
31400
31401
31402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
31403   void * jresult ;
31404   Dali::Rect< int > *result = 0 ;
31405
31406   {
31407     try {
31408       result = (Dali::Rect< int > *)new Dali::Rect< int >();
31409     } CALL_CATCH_EXCEPTION(0);
31410   }
31411
31412   jresult = (void *)result;
31413   return jresult;
31414 }
31415
31416
31417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
31418   void * jresult ;
31419   int arg1 ;
31420   int arg2 ;
31421   int arg3 ;
31422   int arg4 ;
31423   Dali::Rect< int > *result = 0 ;
31424
31425   arg1 = (int)jarg1;
31426   arg2 = (int)jarg2;
31427   arg3 = (int)jarg3;
31428   arg4 = (int)jarg4;
31429   {
31430     try {
31431       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
31432     } CALL_CATCH_EXCEPTION(0);
31433   }
31434
31435   jresult = (void *)result;
31436   return jresult;
31437 }
31438
31439
31440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
31441   void * jresult ;
31442   Dali::Rect< int > *arg1 = 0 ;
31443   Dali::Rect< int > *result = 0 ;
31444
31445   arg1 = (Dali::Rect< int > *)jarg1;
31446   if (!arg1) {
31447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
31448     return 0;
31449   }
31450   {
31451     try {
31452       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
31453     } CALL_CATCH_EXCEPTION(0);
31454   }
31455
31456   jresult = (void *)result;
31457   return jresult;
31458 }
31459
31460
31461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
31462   void * jresult ;
31463   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31464   Dali::Rect< int > *arg2 = 0 ;
31465   Dali::Rect< int > *result = 0 ;
31466
31467   arg1 = (Dali::Rect< int > *)jarg1;
31468   arg2 = (Dali::Rect< int > *)jarg2;
31469   if (!arg2) {
31470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
31471     return 0;
31472   }
31473   {
31474     try {
31475       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
31476     } CALL_CATCH_EXCEPTION(0);
31477   }
31478
31479   jresult = (void *)result;
31480   return jresult;
31481 }
31482
31483
31484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
31485   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31486   int arg2 ;
31487   int arg3 ;
31488   int arg4 ;
31489   int arg5 ;
31490
31491   arg1 = (Dali::Rect< int > *)jarg1;
31492   arg2 = (int)jarg2;
31493   arg3 = (int)jarg3;
31494   arg4 = (int)jarg4;
31495   arg5 = (int)jarg5;
31496   {
31497     try {
31498       (arg1)->Set(arg2,arg3,arg4,arg5);
31499     } CALL_CATCH_EXCEPTION();
31500   }
31501
31502 }
31503
31504
31505 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
31506   bool jresult ;
31507   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31508   bool result;
31509
31510   arg1 = (Dali::Rect< int > *)jarg1;
31511   {
31512     try {
31513       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
31514     } CALL_CATCH_EXCEPTION(0);
31515   }
31516
31517   jresult = result;
31518   return jresult;
31519 }
31520
31521
31522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
31523   int jresult ;
31524   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31525   int result;
31526
31527   arg1 = (Dali::Rect< int > *)jarg1;
31528   {
31529     try {
31530       result = (int)((Dali::Rect< int > const *)arg1)->Left();
31531     } CALL_CATCH_EXCEPTION(0);
31532   }
31533
31534   jresult = result;
31535   return jresult;
31536 }
31537
31538
31539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
31540   int jresult ;
31541   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31542   int result;
31543
31544   arg1 = (Dali::Rect< int > *)jarg1;
31545   {
31546     try {
31547       result = (int)((Dali::Rect< int > const *)arg1)->Right();
31548     } CALL_CATCH_EXCEPTION(0);
31549   }
31550
31551   jresult = result;
31552   return jresult;
31553 }
31554
31555
31556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
31557   int jresult ;
31558   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31559   int result;
31560
31561   arg1 = (Dali::Rect< int > *)jarg1;
31562   {
31563     try {
31564       result = (int)((Dali::Rect< int > const *)arg1)->Top();
31565     } CALL_CATCH_EXCEPTION(0);
31566   }
31567
31568   jresult = result;
31569   return jresult;
31570 }
31571
31572
31573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
31574   int jresult ;
31575   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31576   int result;
31577
31578   arg1 = (Dali::Rect< int > *)jarg1;
31579   {
31580     try {
31581       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
31582     } CALL_CATCH_EXCEPTION(0);
31583   }
31584
31585   jresult = result;
31586   return jresult;
31587 }
31588
31589
31590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
31591   int jresult ;
31592   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31593   int result;
31594
31595   arg1 = (Dali::Rect< int > *)jarg1;
31596   {
31597     try {
31598       result = (int)((Dali::Rect< int > const *)arg1)->Area();
31599     } CALL_CATCH_EXCEPTION(0);
31600   }
31601
31602   jresult = result;
31603   return jresult;
31604 }
31605
31606
31607 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
31608   bool jresult ;
31609   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31610   Dali::Rect< int > *arg2 = 0 ;
31611   bool result;
31612
31613   arg1 = (Dali::Rect< int > *)jarg1;
31614   arg2 = (Dali::Rect< int > *)jarg2;
31615   if (!arg2) {
31616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
31617     return 0;
31618   }
31619   {
31620     try {
31621       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
31622     } CALL_CATCH_EXCEPTION(0);
31623   }
31624
31625   jresult = result;
31626   return jresult;
31627 }
31628
31629
31630 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
31631   bool jresult ;
31632   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31633   Dali::Rect< int > *arg2 = 0 ;
31634   bool result;
31635
31636   arg1 = (Dali::Rect< int > *)jarg1;
31637   arg2 = (Dali::Rect< int > *)jarg2;
31638   if (!arg2) {
31639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
31640     return 0;
31641   }
31642   {
31643     try {
31644       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
31645     } CALL_CATCH_EXCEPTION(0);
31646   }
31647
31648   jresult = result;
31649   return jresult;
31650 }
31651
31652
31653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
31654   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31655   int arg2 ;
31656
31657   arg1 = (Dali::Rect< int > *)jarg1;
31658   arg2 = (int)jarg2;
31659   if (arg1) (arg1)->x = arg2;
31660 }
31661
31662
31663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
31664   int jresult ;
31665   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31666   int result;
31667
31668   arg1 = (Dali::Rect< int > *)jarg1;
31669   result = (int) ((arg1)->x);
31670   jresult = result;
31671   return jresult;
31672 }
31673
31674
31675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
31676   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31677   int arg2 ;
31678
31679   arg1 = (Dali::Rect< int > *)jarg1;
31680   arg2 = (int)jarg2;
31681   if (arg1) (arg1)->left = arg2;
31682 }
31683
31684
31685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
31686   int jresult ;
31687   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31688   int result;
31689
31690   arg1 = (Dali::Rect< int > *)jarg1;
31691   result = (int) ((arg1)->left);
31692   jresult = result;
31693   return jresult;
31694 }
31695
31696
31697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
31698   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31699   int arg2 ;
31700
31701   arg1 = (Dali::Rect< int > *)jarg1;
31702   arg2 = (int)jarg2;
31703   if (arg1) (arg1)->y = arg2;
31704 }
31705
31706
31707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
31708   int jresult ;
31709   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31710   int result;
31711
31712   arg1 = (Dali::Rect< int > *)jarg1;
31713   result = (int) ((arg1)->y);
31714   jresult = result;
31715   return jresult;
31716 }
31717
31718
31719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
31720   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31721   int arg2 ;
31722
31723   arg1 = (Dali::Rect< int > *)jarg1;
31724   arg2 = (int)jarg2;
31725   if (arg1) (arg1)->right = arg2;
31726 }
31727
31728
31729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
31730   int jresult ;
31731   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31732   int result;
31733
31734   arg1 = (Dali::Rect< int > *)jarg1;
31735   result = (int) ((arg1)->right);
31736   jresult = result;
31737   return jresult;
31738 }
31739
31740
31741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
31742   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31743   int arg2 ;
31744
31745   arg1 = (Dali::Rect< int > *)jarg1;
31746   arg2 = (int)jarg2;
31747   if (arg1) (arg1)->width = arg2;
31748 }
31749
31750
31751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
31752   int jresult ;
31753   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31754   int result;
31755
31756   arg1 = (Dali::Rect< int > *)jarg1;
31757   result = (int) ((arg1)->width);
31758   jresult = result;
31759   return jresult;
31760 }
31761
31762
31763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
31764   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31765   int arg2 ;
31766
31767   arg1 = (Dali::Rect< int > *)jarg1;
31768   arg2 = (int)jarg2;
31769   if (arg1) (arg1)->bottom = arg2;
31770 }
31771
31772
31773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
31774   int jresult ;
31775   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31776   int result;
31777
31778   arg1 = (Dali::Rect< int > *)jarg1;
31779   result = (int) ((arg1)->bottom);
31780   jresult = result;
31781   return jresult;
31782 }
31783
31784
31785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
31786   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31787   int arg2 ;
31788
31789   arg1 = (Dali::Rect< int > *)jarg1;
31790   arg2 = (int)jarg2;
31791   if (arg1) (arg1)->height = arg2;
31792 }
31793
31794
31795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
31796   int jresult ;
31797   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31798   int result;
31799
31800   arg1 = (Dali::Rect< int > *)jarg1;
31801   result = (int) ((arg1)->height);
31802   jresult = result;
31803   return jresult;
31804 }
31805
31806
31807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
31808   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31809   int arg2 ;
31810
31811   arg1 = (Dali::Rect< int > *)jarg1;
31812   arg2 = (int)jarg2;
31813   if (arg1) (arg1)->top = arg2;
31814 }
31815
31816
31817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
31818   int jresult ;
31819   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31820   int result;
31821
31822   arg1 = (Dali::Rect< int > *)jarg1;
31823   result = (int) ((arg1)->top);
31824   jresult = result;
31825   return jresult;
31826 }
31827
31828
31829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
31830   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
31831
31832   arg1 = (Dali::Rect< int > *)jarg1;
31833   {
31834     try {
31835       delete arg1;
31836     } CALL_CATCH_EXCEPTION();
31837   }
31838
31839 }
31840
31841
31842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
31843   void * jresult ;
31844   Dali::Rect< float > *result = 0 ;
31845
31846   {
31847     try {
31848       result = (Dali::Rect< float > *)new Dali::Rect< float >();
31849     } CALL_CATCH_EXCEPTION(0);
31850   }
31851
31852   jresult = (void *)result;
31853   return jresult;
31854 }
31855
31856
31857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
31858   void * jresult ;
31859   float arg1 ;
31860   float arg2 ;
31861   float arg3 ;
31862   float arg4 ;
31863   Dali::Rect< float > *result = 0 ;
31864
31865   arg1 = (float)jarg1;
31866   arg2 = (float)jarg2;
31867   arg3 = (float)jarg4;
31868   arg4 = (float)jarg3;
31869   {
31870     try {
31871       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
31872     } CALL_CATCH_EXCEPTION(0);
31873   }
31874
31875   jresult = (void *)result;
31876   return jresult;
31877 }
31878
31879
31880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
31881   void * jresult ;
31882   Dali::Rect< float > *arg1 = 0 ;
31883   Dali::Rect< float > *result = 0 ;
31884
31885   arg1 = (Dali::Rect< float > *)jarg1;
31886   if (!arg1) {
31887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
31888     return 0;
31889   }
31890   {
31891     try {
31892       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
31893     } CALL_CATCH_EXCEPTION(0);
31894   }
31895
31896   jresult = (void *)result;
31897   return jresult;
31898 }
31899
31900
31901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
31902   void * jresult ;
31903   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31904   Dali::Rect< float > *arg2 = 0 ;
31905   Dali::Rect< float > *result = 0 ;
31906
31907   arg1 = (Dali::Rect< float > *)jarg1;
31908   arg2 = (Dali::Rect< float > *)jarg2;
31909   if (!arg2) {
31910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
31911     return 0;
31912   }
31913   {
31914     try {
31915       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
31916     } CALL_CATCH_EXCEPTION(0);
31917   }
31918
31919   jresult = (void *)result;
31920   return jresult;
31921 }
31922
31923
31924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
31925   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31926   float arg2 ;
31927   float arg3 ;
31928   float arg4 ;
31929   float arg5 ;
31930
31931   arg1 = (Dali::Rect< float > *)jarg1;
31932   arg2 = (float)jarg2;
31933   arg3 = (float)jarg3;
31934   arg4 = (float)jarg5;
31935   arg5 = (float)jarg4;
31936   {
31937     try {
31938       (arg1)->Set(arg2,arg3,arg4,arg5);
31939     } CALL_CATCH_EXCEPTION();
31940   }
31941
31942 }
31943
31944
31945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
31946   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31947   float arg2 ;
31948
31949   arg1 = (Dali::Rect< float > *)jarg1;
31950   arg2 = (float)jarg2;
31951   if (arg1) (arg1)->left = arg2;
31952 }
31953
31954
31955 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
31956   float jresult ;
31957   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31958   float result;
31959
31960   arg1 = (Dali::Rect< float > *)jarg1;
31961   result = (float) ((arg1)->left);
31962   jresult = result;
31963   return jresult;
31964 }
31965
31966
31967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
31968   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31969   float arg2 ;
31970
31971   arg1 = (Dali::Rect< float > *)jarg1;
31972   arg2 = (float)jarg2;
31973   if (arg1) (arg1)->left = arg2;
31974 }
31975
31976
31977 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
31978   float jresult ;
31979   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31980   float result;
31981
31982   arg1 = (Dali::Rect< float > *)jarg1;
31983   result = (float) ((arg1)->left);
31984   jresult = result;
31985   return jresult;
31986 }
31987
31988
31989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
31990   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
31991   float arg2 ;
31992
31993   arg1 = (Dali::Rect< float > *)jarg1;
31994   arg2 = (float)jarg2;
31995   if (arg1) (arg1)->right = arg2;
31996 }
31997
31998
31999 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
32000   float jresult ;
32001   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
32002   float result;
32003
32004   arg1 = (Dali::Rect< float > *)jarg1;
32005   result = (float) ((arg1)->right);
32006   jresult = result;
32007   return jresult;
32008 }
32009
32010
32011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
32012   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
32013   float arg2 ;
32014
32015   arg1 = (Dali::Rect< float > *)jarg1;
32016   arg2 = (float)jarg2;
32017   if (arg1) (arg1)->right = arg2;
32018 }
32019
32020
32021 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
32022   float jresult ;
32023   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
32024   float result;
32025
32026   arg1 = (Dali::Rect< float > *)jarg1;
32027   result = (float) ((arg1)->right);
32028   jresult = result;
32029   return jresult;
32030 }
32031
32032
32033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
32034   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
32035   float arg2 ;
32036
32037   arg1 = (Dali::Rect< float > *)jarg1;
32038   arg2 = (float)jarg2;
32039   if (arg1) (arg1)->bottom = arg2;
32040 }
32041
32042
32043 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
32044   float jresult ;
32045   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
32046   float result;
32047
32048   arg1 = (Dali::Rect< float > *)jarg1;
32049   result = (float) ((arg1)->bottom);
32050   jresult = result;
32051   return jresult;
32052 }
32053
32054
32055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
32056   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
32057   float arg2 ;
32058
32059   arg1 = (Dali::Rect< float > *)jarg1;
32060   arg2 = (float)jarg2;
32061   if (arg1) (arg1)->top = arg2;
32062 }
32063
32064
32065 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
32066   float jresult ;
32067   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
32068   float result;
32069
32070   arg1 = (Dali::Rect< float > *)jarg1;
32071   result = (float) ((arg1)->top);
32072   jresult = result;
32073   return jresult;
32074 }
32075
32076
32077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
32078   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
32079
32080   arg1 = (Dali::Rect< float > *)jarg1;
32081   {
32082     try {
32083       delete arg1;
32084     } CALL_CATCH_EXCEPTION();
32085   }
32086
32087 }
32088
32089
32090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
32091   int jresult ;
32092   int result;
32093
32094   result = (int)Dali::Vector< int >::BaseType;
32095   jresult = (int)result;
32096   return jresult;
32097 }
32098
32099
32100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
32101   void * jresult ;
32102   Dali::Vector< int > *result = 0 ;
32103
32104   {
32105     try {
32106       result = (Dali::Vector< int > *)new Dali::Vector< int >();
32107     } CALL_CATCH_EXCEPTION(0);
32108   }
32109
32110   jresult = (void *)result;
32111   return jresult;
32112 }
32113
32114
32115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
32116   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32117
32118   arg1 = (Dali::Vector< int > *)jarg1;
32119   {
32120     try {
32121       delete arg1;
32122     } CALL_CATCH_EXCEPTION();
32123   }
32124
32125 }
32126
32127
32128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
32129   void * jresult ;
32130   Dali::Vector< int > *arg1 = 0 ;
32131   Dali::Vector< int > *result = 0 ;
32132
32133   arg1 = (Dali::Vector< int > *)jarg1;
32134   if (!arg1) {
32135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
32136     return 0;
32137   }
32138   {
32139     try {
32140       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
32141     } CALL_CATCH_EXCEPTION(0);
32142   }
32143
32144   jresult = (void *)result;
32145   return jresult;
32146 }
32147
32148
32149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
32150   void * jresult ;
32151   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32152   Dali::Vector< int > *arg2 = 0 ;
32153   Dali::Vector< int > *result = 0 ;
32154
32155   arg1 = (Dali::Vector< int > *)jarg1;
32156   arg2 = (Dali::Vector< int > *)jarg2;
32157   if (!arg2) {
32158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
32159     return 0;
32160   }
32161   {
32162     try {
32163       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
32164     } CALL_CATCH_EXCEPTION(0);
32165   }
32166
32167   jresult = (void *)result;
32168   return jresult;
32169 }
32170
32171
32172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
32173   void * jresult ;
32174   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32175   Dali::Vector< int >::Iterator result;
32176
32177   arg1 = (Dali::Vector< int > *)jarg1;
32178   {
32179     try {
32180       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
32181     } CALL_CATCH_EXCEPTION(0);
32182   }
32183
32184   jresult = (void *)result;
32185   return jresult;
32186 }
32187
32188
32189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
32190   void * jresult ;
32191   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32192   Dali::Vector< int >::Iterator result;
32193
32194   arg1 = (Dali::Vector< int > *)jarg1;
32195   {
32196     try {
32197       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
32198     } CALL_CATCH_EXCEPTION(0);
32199   }
32200
32201   jresult = (void *)result;
32202   return jresult;
32203 }
32204
32205
32206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
32207   void * jresult ;
32208   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32209   Dali::Vector< int >::SizeType arg2 ;
32210   Dali::Vector< int >::ItemType *result = 0 ;
32211
32212   arg1 = (Dali::Vector< int > *)jarg1;
32213   arg2 = (Dali::Vector< int >::SizeType)jarg2;
32214   {
32215     try {
32216       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
32217     } CALL_CATCH_EXCEPTION(0);
32218   }
32219
32220   jresult = (void *)result;
32221   return jresult;
32222 }
32223
32224
32225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
32226   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32227   Dali::Vector< int >::ItemType *arg2 = 0 ;
32228   Dali::Vector< int >::ItemType temp2 ;
32229
32230   arg1 = (Dali::Vector< int > *)jarg1;
32231   temp2 = (Dali::Vector< int >::ItemType)jarg2;
32232   arg2 = &temp2;
32233   {
32234     try {
32235       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
32236     } CALL_CATCH_EXCEPTION();
32237   }
32238
32239 }
32240
32241
32242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
32243   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32244   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
32245   Dali::Vector< int >::ItemType *arg3 = 0 ;
32246   Dali::Vector< int >::ItemType temp3 ;
32247
32248   arg1 = (Dali::Vector< int > *)jarg1;
32249   arg2 = (Dali::Vector< int >::Iterator)jarg2;
32250   temp3 = (Dali::Vector< int >::ItemType)jarg3;
32251   arg3 = &temp3;
32252   {
32253     try {
32254       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
32255     } CALL_CATCH_EXCEPTION();
32256   }
32257
32258 }
32259
32260
32261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
32262   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32263   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
32264   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
32265   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
32266
32267   arg1 = (Dali::Vector< int > *)jarg1;
32268   arg2 = (Dali::Vector< int >::Iterator)jarg2;
32269   arg3 = (Dali::Vector< int >::Iterator)jarg3;
32270   arg4 = (Dali::Vector< int >::Iterator)jarg4;
32271   {
32272     try {
32273       (arg1)->Insert(arg2,arg3,arg4);
32274     } CALL_CATCH_EXCEPTION();
32275   }
32276
32277 }
32278
32279
32280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
32281   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32282   Dali::Vector< int >::SizeType arg2 ;
32283
32284   arg1 = (Dali::Vector< int > *)jarg1;
32285   arg2 = (Dali::Vector< int >::SizeType)jarg2;
32286   {
32287     try {
32288       (arg1)->Reserve(arg2);
32289     } CALL_CATCH_EXCEPTION();
32290   }
32291
32292 }
32293
32294
32295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
32296   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32297   Dali::Vector< int >::SizeType arg2 ;
32298
32299   arg1 = (Dali::Vector< int > *)jarg1;
32300   arg2 = (Dali::Vector< int >::SizeType)jarg2;
32301   {
32302     try {
32303       (arg1)->Resize(arg2);
32304     } CALL_CATCH_EXCEPTION();
32305   }
32306
32307 }
32308
32309
32310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
32311   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32312   Dali::Vector< int >::SizeType arg2 ;
32313   Dali::Vector< int >::ItemType *arg3 = 0 ;
32314   Dali::Vector< int >::ItemType temp3 ;
32315
32316   arg1 = (Dali::Vector< int > *)jarg1;
32317   arg2 = (Dali::Vector< int >::SizeType)jarg2;
32318   temp3 = (Dali::Vector< int >::ItemType)jarg3;
32319   arg3 = &temp3;
32320   {
32321     try {
32322       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
32323     } CALL_CATCH_EXCEPTION();
32324   }
32325
32326 }
32327
32328
32329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
32330   void * jresult ;
32331   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32332   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
32333   Dali::Vector< int >::Iterator result;
32334
32335   arg1 = (Dali::Vector< int > *)jarg1;
32336   arg2 = (Dali::Vector< int >::Iterator)jarg2;
32337   {
32338     try {
32339       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
32340     } CALL_CATCH_EXCEPTION(0);
32341   }
32342
32343   jresult = (void *)result;
32344   return jresult;
32345 }
32346
32347
32348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
32349   void * jresult ;
32350   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32351   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
32352   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
32353   Dali::Vector< int >::Iterator result;
32354
32355   arg1 = (Dali::Vector< int > *)jarg1;
32356   arg2 = (Dali::Vector< int >::Iterator)jarg2;
32357   arg3 = (Dali::Vector< int >::Iterator)jarg3;
32358   {
32359     try {
32360       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
32361     } CALL_CATCH_EXCEPTION(0);
32362   }
32363
32364   jresult = (void *)result;
32365   return jresult;
32366 }
32367
32368
32369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
32370   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32371   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
32372
32373   arg1 = (Dali::Vector< int > *)jarg1;
32374   arg2 = (Dali::Vector< int >::Iterator)jarg2;
32375   {
32376     try {
32377       (arg1)->Remove(arg2);
32378     } CALL_CATCH_EXCEPTION();
32379   }
32380
32381 }
32382
32383
32384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
32385   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32386   Dali::Vector< int > *arg2 = 0 ;
32387
32388   arg1 = (Dali::Vector< int > *)jarg1;
32389   arg2 = (Dali::Vector< int > *)jarg2;
32390   if (!arg2) {
32391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
32392     return ;
32393   }
32394   {
32395     try {
32396       (arg1)->Swap(*arg2);
32397     } CALL_CATCH_EXCEPTION();
32398   }
32399
32400 }
32401
32402
32403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
32404   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32405
32406   arg1 = (Dali::Vector< int > *)jarg1;
32407   {
32408     try {
32409       (arg1)->Clear();
32410     } CALL_CATCH_EXCEPTION();
32411   }
32412
32413 }
32414
32415
32416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
32417   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
32418
32419   arg1 = (Dali::Vector< int > *)jarg1;
32420   {
32421     try {
32422       (arg1)->Release();
32423     } CALL_CATCH_EXCEPTION();
32424   }
32425
32426 }
32427
32428
32429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
32430   int jresult ;
32431   int result;
32432
32433   result = (int)Dali::Vector< float >::BaseType;
32434   jresult = (int)result;
32435   return jresult;
32436 }
32437
32438
32439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
32440   void * jresult ;
32441   Dali::Vector< float > *result = 0 ;
32442
32443   {
32444     try {
32445       result = (Dali::Vector< float > *)new Dali::Vector< float >();
32446     } CALL_CATCH_EXCEPTION(0);
32447   }
32448
32449   jresult = (void *)result;
32450   return jresult;
32451 }
32452
32453
32454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
32455   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32456
32457   arg1 = (Dali::Vector< float > *)jarg1;
32458   {
32459     try {
32460       delete arg1;
32461     } CALL_CATCH_EXCEPTION();
32462   }
32463
32464 }
32465
32466
32467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
32468   void * jresult ;
32469   Dali::Vector< float > *arg1 = 0 ;
32470   Dali::Vector< float > *result = 0 ;
32471
32472   arg1 = (Dali::Vector< float > *)jarg1;
32473   if (!arg1) {
32474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
32475     return 0;
32476   }
32477   {
32478     try {
32479       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
32480     } CALL_CATCH_EXCEPTION(0);
32481   }
32482
32483   jresult = (void *)result;
32484   return jresult;
32485 }
32486
32487
32488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
32489   void * jresult ;
32490   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32491   Dali::Vector< float > *arg2 = 0 ;
32492   Dali::Vector< float > *result = 0 ;
32493
32494   arg1 = (Dali::Vector< float > *)jarg1;
32495   arg2 = (Dali::Vector< float > *)jarg2;
32496   if (!arg2) {
32497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
32498     return 0;
32499   }
32500   {
32501     try {
32502       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
32503     } CALL_CATCH_EXCEPTION(0);
32504   }
32505
32506   jresult = (void *)result;
32507   return jresult;
32508 }
32509
32510
32511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
32512   void * jresult ;
32513   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32514   Dali::Vector< float >::Iterator result;
32515
32516   arg1 = (Dali::Vector< float > *)jarg1;
32517   {
32518     try {
32519       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
32520     } CALL_CATCH_EXCEPTION(0);
32521   }
32522
32523   jresult = (void *)result;
32524   return jresult;
32525 }
32526
32527
32528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
32529   void * jresult ;
32530   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32531   Dali::Vector< float >::Iterator result;
32532
32533   arg1 = (Dali::Vector< float > *)jarg1;
32534   {
32535     try {
32536       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
32537     } CALL_CATCH_EXCEPTION(0);
32538   }
32539
32540   jresult = (void *)result;
32541   return jresult;
32542 }
32543
32544
32545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
32546   void * jresult ;
32547   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32548   Dali::Vector< float >::SizeType arg2 ;
32549   Dali::Vector< float >::ItemType *result = 0 ;
32550
32551   arg1 = (Dali::Vector< float > *)jarg1;
32552   arg2 = (Dali::Vector< float >::SizeType)jarg2;
32553   {
32554     try {
32555       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
32556     } CALL_CATCH_EXCEPTION(0);
32557   }
32558
32559   jresult = (void *)result;
32560   return jresult;
32561 }
32562
32563
32564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
32565   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32566   Dali::Vector< float >::ItemType *arg2 = 0 ;
32567   Dali::Vector< float >::ItemType temp2 ;
32568
32569   arg1 = (Dali::Vector< float > *)jarg1;
32570   temp2 = (Dali::Vector< float >::ItemType)jarg2;
32571   arg2 = &temp2;
32572   {
32573     try {
32574       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
32575     } CALL_CATCH_EXCEPTION();
32576   }
32577
32578 }
32579
32580
32581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
32582   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32583   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
32584   Dali::Vector< float >::ItemType *arg3 = 0 ;
32585   Dali::Vector< float >::ItemType temp3 ;
32586
32587   arg1 = (Dali::Vector< float > *)jarg1;
32588   arg2 = (Dali::Vector< float >::Iterator)jarg2;
32589   temp3 = (Dali::Vector< float >::ItemType)jarg3;
32590   arg3 = &temp3;
32591   {
32592     try {
32593       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
32594     } CALL_CATCH_EXCEPTION();
32595   }
32596
32597 }
32598
32599
32600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
32601   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32602   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
32603   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
32604   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
32605
32606   arg1 = (Dali::Vector< float > *)jarg1;
32607   arg2 = (Dali::Vector< float >::Iterator)jarg2;
32608   arg3 = (Dali::Vector< float >::Iterator)jarg3;
32609   arg4 = (Dali::Vector< float >::Iterator)jarg4;
32610   {
32611     try {
32612       (arg1)->Insert(arg2,arg3,arg4);
32613     } CALL_CATCH_EXCEPTION();
32614   }
32615
32616 }
32617
32618
32619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
32620   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32621   Dali::Vector< float >::SizeType arg2 ;
32622
32623   arg1 = (Dali::Vector< float > *)jarg1;
32624   arg2 = (Dali::Vector< float >::SizeType)jarg2;
32625   {
32626     try {
32627       (arg1)->Reserve(arg2);
32628     } CALL_CATCH_EXCEPTION();
32629   }
32630
32631 }
32632
32633 //// ========================= end of part 2 =============================
32634
32635 //// ========================== start part 3 ===============================
32636
32637
32638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
32639   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32640   Dali::Vector< float >::SizeType arg2 ;
32641
32642   arg1 = (Dali::Vector< float > *)jarg1;
32643   arg2 = (Dali::Vector< float >::SizeType)jarg2;
32644   {
32645     try {
32646       (arg1)->Resize(arg2);
32647     } CALL_CATCH_EXCEPTION();
32648   }
32649
32650 }
32651
32652
32653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
32654   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32655   Dali::Vector< float >::SizeType arg2 ;
32656   Dali::Vector< float >::ItemType *arg3 = 0 ;
32657   Dali::Vector< float >::ItemType temp3 ;
32658
32659   arg1 = (Dali::Vector< float > *)jarg1;
32660   arg2 = (Dali::Vector< float >::SizeType)jarg2;
32661   temp3 = (Dali::Vector< float >::ItemType)jarg3;
32662   arg3 = &temp3;
32663   {
32664     try {
32665       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
32666     } CALL_CATCH_EXCEPTION();
32667   }
32668
32669 }
32670
32671
32672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
32673   void * jresult ;
32674   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32675   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
32676   Dali::Vector< float >::Iterator result;
32677
32678   arg1 = (Dali::Vector< float > *)jarg1;
32679   arg2 = (Dali::Vector< float >::Iterator)jarg2;
32680   {
32681     try {
32682       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
32683     } CALL_CATCH_EXCEPTION(0);
32684   }
32685
32686   jresult = (void *)result;
32687   return jresult;
32688 }
32689
32690
32691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
32692   void * jresult ;
32693   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32694   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
32695   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
32696   Dali::Vector< float >::Iterator result;
32697
32698   arg1 = (Dali::Vector< float > *)jarg1;
32699   arg2 = (Dali::Vector< float >::Iterator)jarg2;
32700   arg3 = (Dali::Vector< float >::Iterator)jarg3;
32701   {
32702     try {
32703       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
32704     } CALL_CATCH_EXCEPTION(0);
32705   }
32706
32707   jresult = (void *)result;
32708   return jresult;
32709 }
32710
32711
32712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
32713   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32714   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
32715
32716   arg1 = (Dali::Vector< float > *)jarg1;
32717   arg2 = (Dali::Vector< float >::Iterator)jarg2;
32718   {
32719     try {
32720       (arg1)->Remove(arg2);
32721     } CALL_CATCH_EXCEPTION();
32722   }
32723
32724 }
32725
32726
32727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
32728   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32729   Dali::Vector< float > *arg2 = 0 ;
32730
32731   arg1 = (Dali::Vector< float > *)jarg1;
32732   arg2 = (Dali::Vector< float > *)jarg2;
32733   if (!arg2) {
32734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
32735     return ;
32736   }
32737   {
32738     try {
32739       (arg1)->Swap(*arg2);
32740     } CALL_CATCH_EXCEPTION();
32741   }
32742
32743 }
32744
32745
32746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
32747   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32748
32749   arg1 = (Dali::Vector< float > *)jarg1;
32750   {
32751     try {
32752       (arg1)->Clear();
32753     } CALL_CATCH_EXCEPTION();
32754   }
32755
32756 }
32757
32758
32759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
32760   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
32761
32762   arg1 = (Dali::Vector< float > *)jarg1;
32763   {
32764     try {
32765       (arg1)->Release();
32766     } CALL_CATCH_EXCEPTION();
32767   }
32768
32769 }
32770
32771
32772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
32773   int jresult ;
32774   int result;
32775
32776   result = (int)Dali::Vector< unsigned char >::BaseType;
32777   jresult = (int)result;
32778   return jresult;
32779 }
32780
32781
32782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
32783   void * jresult ;
32784   Dali::Vector< unsigned char > *result = 0 ;
32785
32786   {
32787     try {
32788       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
32789     } CALL_CATCH_EXCEPTION(0);
32790   }
32791
32792   jresult = (void *)result;
32793   return jresult;
32794 }
32795
32796
32797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
32798   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32799
32800   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32801   {
32802     try {
32803       delete arg1;
32804     } CALL_CATCH_EXCEPTION();
32805   }
32806
32807 }
32808
32809
32810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
32811   void * jresult ;
32812   Dali::Vector< unsigned char > *arg1 = 0 ;
32813   Dali::Vector< unsigned char > *result = 0 ;
32814
32815   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32816   if (!arg1) {
32817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
32818     return 0;
32819   }
32820   {
32821     try {
32822       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
32823     } CALL_CATCH_EXCEPTION(0);
32824   }
32825
32826   jresult = (void *)result;
32827   return jresult;
32828 }
32829
32830
32831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
32832   void * jresult ;
32833   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32834   Dali::Vector< unsigned char > *arg2 = 0 ;
32835   Dali::Vector< unsigned char > *result = 0 ;
32836
32837   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32838   arg2 = (Dali::Vector< unsigned char > *)jarg2;
32839   if (!arg2) {
32840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
32841     return 0;
32842   }
32843   {
32844     try {
32845       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
32846     } CALL_CATCH_EXCEPTION(0);
32847   }
32848
32849   jresult = (void *)result;
32850   return jresult;
32851 }
32852
32853
32854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
32855   void * jresult ;
32856   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32857   Dali::Vector< unsigned char >::Iterator result;
32858
32859   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32860   {
32861     try {
32862       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
32863     } CALL_CATCH_EXCEPTION(0);
32864   }
32865
32866   jresult = (void *)result;
32867   return jresult;
32868 }
32869
32870
32871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
32872   void * jresult ;
32873   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32874   Dali::Vector< unsigned char >::Iterator result;
32875
32876   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32877   {
32878     try {
32879       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
32880     } CALL_CATCH_EXCEPTION(0);
32881   }
32882
32883   jresult = (void *)result;
32884   return jresult;
32885 }
32886
32887
32888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
32889   void * jresult ;
32890   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32891   Dali::Vector< unsigned char >::SizeType arg2 ;
32892   Dali::Vector< unsigned char >::ItemType *result = 0 ;
32893
32894   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32895   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
32896   {
32897     try {
32898       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
32899     } CALL_CATCH_EXCEPTION(0);
32900   }
32901
32902   jresult = (void *)result;
32903   return jresult;
32904 }
32905
32906
32907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
32908   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32909   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
32910   Dali::Vector< unsigned char >::ItemType temp2 ;
32911
32912   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32913   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
32914   arg2 = &temp2;
32915   {
32916     try {
32917       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
32918     } CALL_CATCH_EXCEPTION();
32919   }
32920
32921 }
32922
32923
32924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
32925   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32926   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
32927   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
32928   Dali::Vector< unsigned char >::ItemType temp3 ;
32929
32930   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32931   arg2 = jarg2;
32932   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
32933   arg3 = &temp3;
32934   {
32935     try {
32936       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
32937     } CALL_CATCH_EXCEPTION();
32938   }
32939
32940
32941
32942 }
32943
32944
32945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
32946   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32947   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
32948   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
32949   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
32950
32951   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32952   arg2 = jarg2;
32953   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
32954   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
32955   {
32956     try {
32957       (arg1)->Insert(arg2,arg3,arg4);
32958     } CALL_CATCH_EXCEPTION();
32959   }
32960
32961
32962
32963 }
32964
32965
32966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
32967   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32968   Dali::Vector< unsigned char >::SizeType arg2 ;
32969
32970   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32971   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
32972   {
32973     try {
32974       (arg1)->Reserve(arg2);
32975     } CALL_CATCH_EXCEPTION();
32976   }
32977
32978 }
32979
32980
32981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
32982   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32983   Dali::Vector< unsigned char >::SizeType arg2 ;
32984
32985   arg1 = (Dali::Vector< unsigned char > *)jarg1;
32986   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
32987   {
32988     try {
32989       (arg1)->Resize(arg2);
32990     } CALL_CATCH_EXCEPTION();
32991   }
32992
32993 }
32994
32995
32996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
32997   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
32998   Dali::Vector< unsigned char >::SizeType arg2 ;
32999   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
33000   Dali::Vector< unsigned char >::ItemType temp3 ;
33001
33002   arg1 = (Dali::Vector< unsigned char > *)jarg1;
33003   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
33004   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
33005   arg3 = &temp3;
33006   {
33007     try {
33008       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
33009     } CALL_CATCH_EXCEPTION();
33010   }
33011
33012 }
33013
33014
33015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
33016   void * jresult ;
33017   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
33018   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
33019   Dali::Vector< unsigned char >::Iterator result;
33020
33021   arg1 = (Dali::Vector< unsigned char > *)jarg1;
33022   arg2 = jarg2;
33023   {
33024     try {
33025       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
33026     } CALL_CATCH_EXCEPTION(0);
33027   }
33028
33029   jresult = (void *)result;
33030
33031
33032   return jresult;
33033 }
33034
33035
33036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
33037   void * jresult ;
33038   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
33039   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
33040   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
33041   Dali::Vector< unsigned char >::Iterator result;
33042
33043   arg1 = (Dali::Vector< unsigned char > *)jarg1;
33044   arg2 = jarg2;
33045   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
33046   {
33047     try {
33048       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
33049     } CALL_CATCH_EXCEPTION(0);
33050   }
33051
33052   jresult = (void *)result;
33053
33054
33055   return jresult;
33056 }
33057
33058
33059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
33060   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
33061   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
33062
33063   arg1 = (Dali::Vector< unsigned char > *)jarg1;
33064   arg2 = jarg2;
33065   {
33066     try {
33067       (arg1)->Remove(arg2);
33068     } CALL_CATCH_EXCEPTION();
33069   }
33070
33071
33072
33073 }
33074
33075
33076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
33077   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
33078   Dali::Vector< unsigned char > *arg2 = 0 ;
33079
33080   arg1 = (Dali::Vector< unsigned char > *)jarg1;
33081   arg2 = (Dali::Vector< unsigned char > *)jarg2;
33082   if (!arg2) {
33083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
33084     return ;
33085   }
33086   {
33087     try {
33088       (arg1)->Swap(*arg2);
33089     } CALL_CATCH_EXCEPTION();
33090   }
33091
33092 }
33093
33094
33095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
33096   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
33097
33098   arg1 = (Dali::Vector< unsigned char > *)jarg1;
33099   {
33100     try {
33101       (arg1)->Clear();
33102     } CALL_CATCH_EXCEPTION();
33103   }
33104
33105 }
33106
33107
33108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
33109   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
33110
33111   arg1 = (Dali::Vector< unsigned char > *)jarg1;
33112   {
33113     try {
33114       (arg1)->Release();
33115     } CALL_CATCH_EXCEPTION();
33116   }
33117
33118 }
33119
33120
33121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
33122   int jresult ;
33123   int result;
33124
33125   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
33126   jresult = (int)result;
33127   return jresult;
33128 }
33129
33130
33131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
33132   void * jresult ;
33133   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
33134
33135   {
33136     try {
33137       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
33138     } CALL_CATCH_EXCEPTION(0);
33139   }
33140
33141   jresult = (void *)result;
33142   return jresult;
33143 }
33144
33145
33146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
33147   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33148
33149   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33150   {
33151     try {
33152       delete arg1;
33153     } CALL_CATCH_EXCEPTION();
33154   }
33155
33156 }
33157
33158
33159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
33160   void * jresult ;
33161   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
33162   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
33163
33164   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33165   if (!arg1) {
33166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
33167     return 0;
33168   }
33169   {
33170     try {
33171       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
33172     } CALL_CATCH_EXCEPTION(0);
33173   }
33174
33175   jresult = (void *)result;
33176   return jresult;
33177 }
33178
33179
33180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
33181   void * jresult ;
33182   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33183   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
33184   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
33185
33186   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33187   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
33188   if (!arg2) {
33189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
33190     return 0;
33191   }
33192   {
33193     try {
33194       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
33195     } CALL_CATCH_EXCEPTION(0);
33196   }
33197
33198   jresult = (void *)result;
33199   return jresult;
33200 }
33201
33202
33203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
33204   void * jresult ;
33205   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33206   Dali::Vector< Dali::Uint16Pair >::Iterator result;
33207
33208   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33209   {
33210     try {
33211       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
33212     } CALL_CATCH_EXCEPTION(0);
33213   }
33214
33215   jresult = (void *)result;
33216   return jresult;
33217 }
33218
33219
33220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
33221   void * jresult ;
33222   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33223   Dali::Vector< Dali::Uint16Pair >::Iterator result;
33224
33225   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33226   {
33227     try {
33228       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
33229     } CALL_CATCH_EXCEPTION(0);
33230   }
33231
33232   jresult = (void *)result;
33233   return jresult;
33234 }
33235
33236
33237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
33238   void * jresult ;
33239   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33240   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
33241   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
33242
33243   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33244   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
33245   {
33246     try {
33247       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
33248     } CALL_CATCH_EXCEPTION(0);
33249   }
33250
33251   jresult = (void *)result;
33252   return jresult;
33253 }
33254
33255
33256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
33257   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33258   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
33259
33260   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33261   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
33262   if (!arg2) {
33263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
33264     return ;
33265   }
33266   {
33267     try {
33268       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
33269     } CALL_CATCH_EXCEPTION();
33270   }
33271
33272 }
33273
33274
33275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
33276   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33277   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
33278   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
33279
33280   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33281   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
33282   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
33283   if (!arg3) {
33284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
33285     return ;
33286   }
33287   {
33288     try {
33289       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
33290     } CALL_CATCH_EXCEPTION();
33291   }
33292
33293 }
33294
33295
33296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
33297   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33298   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
33299   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
33300   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
33301
33302   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33303   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
33304   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
33305   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
33306   {
33307     try {
33308       (arg1)->Insert(arg2,arg3,arg4);
33309     } CALL_CATCH_EXCEPTION();
33310   }
33311
33312 }
33313
33314
33315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
33316   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33317   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
33318
33319   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33320   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
33321   {
33322     try {
33323       (arg1)->Reserve(arg2);
33324     } CALL_CATCH_EXCEPTION();
33325   }
33326
33327 }
33328
33329
33330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
33331   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33332   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
33333
33334   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33335   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
33336   {
33337     try {
33338       (arg1)->Resize(arg2);
33339     } CALL_CATCH_EXCEPTION();
33340   }
33341
33342 }
33343
33344
33345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
33346   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33347   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
33348   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
33349
33350   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33351   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
33352   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
33353   if (!arg3) {
33354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
33355     return ;
33356   }
33357   {
33358     try {
33359       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
33360     } CALL_CATCH_EXCEPTION();
33361   }
33362
33363 }
33364
33365
33366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
33367   void * jresult ;
33368   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33369   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
33370   Dali::Vector< Dali::Uint16Pair >::Iterator result;
33371
33372   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33373   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
33374   {
33375     try {
33376       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
33377     } CALL_CATCH_EXCEPTION(0);
33378   }
33379
33380   jresult = (void *)result;
33381   return jresult;
33382 }
33383
33384
33385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
33386   void * jresult ;
33387   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33388   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
33389   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
33390   Dali::Vector< Dali::Uint16Pair >::Iterator result;
33391
33392   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33393   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
33394   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
33395   {
33396     try {
33397       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
33398     } CALL_CATCH_EXCEPTION(0);
33399   }
33400
33401   jresult = (void *)result;
33402   return jresult;
33403 }
33404
33405
33406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
33407   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33408   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
33409
33410   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33411   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
33412   {
33413     try {
33414       (arg1)->Remove(arg2);
33415     } CALL_CATCH_EXCEPTION();
33416   }
33417
33418 }
33419
33420
33421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
33422   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33423   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
33424
33425   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33426   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
33427   if (!arg2) {
33428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
33429     return ;
33430   }
33431   {
33432     try {
33433       (arg1)->Swap(*arg2);
33434     } CALL_CATCH_EXCEPTION();
33435   }
33436
33437 }
33438
33439
33440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
33441   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33442
33443   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33444   {
33445     try {
33446       (arg1)->Clear();
33447     } CALL_CATCH_EXCEPTION();
33448   }
33449
33450 }
33451
33452
33453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
33454   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
33455
33456   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
33457   {
33458     try {
33459       (arg1)->Release();
33460     } CALL_CATCH_EXCEPTION();
33461   }
33462
33463 }
33464
33465
33466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
33467   void * jresult ;
33468   Dali::Signal< void () > *result = 0 ;
33469
33470   {
33471     try {
33472       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
33473     } CALL_CATCH_EXCEPTION(0);
33474   }
33475
33476   jresult = (void *)result;
33477   return jresult;
33478 }
33479
33480
33481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
33482   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
33483
33484   arg1 = (Dali::Signal< void () > *)jarg1;
33485   {
33486     try {
33487       delete arg1;
33488     } CALL_CATCH_EXCEPTION();
33489   }
33490
33491 }
33492
33493
33494 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
33495   bool jresult ;
33496   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
33497   bool result;
33498
33499   arg1 = (Dali::Signal< void () > *)jarg1;
33500   {
33501     try {
33502       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
33503     } CALL_CATCH_EXCEPTION(0);
33504   }
33505
33506   jresult = result;
33507   return jresult;
33508 }
33509
33510
33511 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
33512   unsigned long jresult ;
33513   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
33514   std::size_t result;
33515
33516   arg1 = (Dali::Signal< void () > *)jarg1;
33517   {
33518     try {
33519       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
33520     } CALL_CATCH_EXCEPTION(0);
33521   }
33522
33523   jresult = (unsigned long)result;
33524   return jresult;
33525 }
33526
33527
33528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
33529   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
33530   void (*arg2)() = (void (*)()) 0 ;
33531
33532   arg1 = (Dali::Signal< void () > *)jarg1;
33533   arg2 = (void (*)())jarg2;
33534   {
33535     try {
33536       (arg1)->Connect(arg2);
33537     } CALL_CATCH_EXCEPTION();
33538   }
33539
33540 }
33541
33542
33543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
33544   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
33545   void (*arg2)() = (void (*)()) 0 ;
33546
33547   arg1 = (Dali::Signal< void () > *)jarg1;
33548   arg2 = (void (*)())jarg2;
33549   {
33550     try {
33551       (arg1)->Disconnect(arg2);
33552     } CALL_CATCH_EXCEPTION();
33553   }
33554
33555 }
33556
33557
33558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
33559   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
33560   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
33561   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
33562
33563   arg1 = (Dali::Signal< void () > *)jarg1;
33564   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
33565   arg3 = (Dali::FunctorDelegate *)jarg3;
33566   {
33567     try {
33568       (arg1)->Connect(arg2,arg3);
33569     } CALL_CATCH_EXCEPTION();
33570   }
33571
33572 }
33573
33574
33575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
33576   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
33577
33578   arg1 = (Dali::Signal< void () > *)jarg1;
33579   {
33580     try {
33581       (arg1)->Emit();
33582     } CALL_CATCH_EXCEPTION();
33583   }
33584
33585 }
33586
33587
33588 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
33589   bool jresult ;
33590   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
33591   bool result;
33592
33593   arg1 = (Dali::Signal< void (float) > *)jarg1;
33594   {
33595     try {
33596       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
33597     } CALL_CATCH_EXCEPTION(0);
33598   }
33599
33600   jresult = result;
33601   return jresult;
33602 }
33603
33604
33605 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
33606   unsigned long jresult ;
33607   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
33608   std::size_t result;
33609
33610   arg1 = (Dali::Signal< void (float) > *)jarg1;
33611   {
33612     try {
33613       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
33614     } CALL_CATCH_EXCEPTION(0);
33615   }
33616
33617   jresult = (unsigned long)result;
33618   return jresult;
33619 }
33620
33621
33622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
33623   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
33624   void (*arg2)(float) = (void (*)(float)) 0 ;
33625
33626   arg1 = (Dali::Signal< void (float) > *)jarg1;
33627   arg2 = (void (*)(float))jarg2;
33628   {
33629     try {
33630       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
33631     } CALL_CATCH_EXCEPTION();
33632   }
33633
33634 }
33635
33636
33637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
33638   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
33639   void (*arg2)(float) = (void (*)(float)) 0 ;
33640
33641   arg1 = (Dali::Signal< void (float) > *)jarg1;
33642   arg2 = (void (*)(float))jarg2;
33643   {
33644     try {
33645       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
33646     } CALL_CATCH_EXCEPTION();
33647   }
33648
33649 }
33650
33651
33652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
33653   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
33654   float arg2 ;
33655
33656   arg1 = (Dali::Signal< void (float) > *)jarg1;
33657   arg2 = (float)jarg2;
33658   {
33659     try {
33660       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
33661     } CALL_CATCH_EXCEPTION();
33662   }
33663
33664 }
33665
33666
33667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
33668   void * jresult ;
33669   Dali::Signal< void (float) > *result = 0 ;
33670
33671   {
33672     try {
33673       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
33674     } CALL_CATCH_EXCEPTION(0);
33675   }
33676
33677   jresult = (void *)result;
33678   return jresult;
33679 }
33680
33681
33682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
33683   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
33684
33685   arg1 = (Dali::Signal< void (float) > *)jarg1;
33686   {
33687     try {
33688       delete arg1;
33689     } CALL_CATCH_EXCEPTION();
33690   }
33691
33692 }
33693
33694
33695 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
33696   bool jresult ;
33697   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
33698   bool result;
33699
33700   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
33701   {
33702     try {
33703       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
33704     } CALL_CATCH_EXCEPTION(0);
33705   }
33706
33707   jresult = result;
33708   return jresult;
33709 }
33710
33711
33712 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
33713   unsigned long jresult ;
33714   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
33715   std::size_t result;
33716
33717   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
33718   {
33719     try {
33720       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
33721     } CALL_CATCH_EXCEPTION(0);
33722   }
33723
33724   jresult = (unsigned long)result;
33725   return jresult;
33726 }
33727
33728
33729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
33730   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
33731   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
33732
33733   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
33734   arg2 = (void (*)(Dali::BaseHandle))jarg2;
33735   {
33736     try {
33737       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
33738     } CALL_CATCH_EXCEPTION();
33739   }
33740
33741 }
33742
33743
33744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
33745   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
33746   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
33747
33748   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
33749   arg2 = (void (*)(Dali::BaseHandle))jarg2;
33750   {
33751     try {
33752       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
33753     } CALL_CATCH_EXCEPTION();
33754   }
33755
33756 }
33757
33758
33759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
33760   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
33761   Dali::BaseHandle arg2 ;
33762   Dali::BaseHandle *argp2 ;
33763
33764   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
33765   argp2 = (Dali::BaseHandle *)jarg2;
33766   if (!argp2) {
33767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33768     return ;
33769   }
33770   arg2 = *argp2;
33771   {
33772     try {
33773       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
33774     } CALL_CATCH_EXCEPTION();
33775   }
33776
33777 }
33778
33779
33780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
33781   void * jresult ;
33782   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
33783
33784   {
33785     try {
33786       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
33787     } CALL_CATCH_EXCEPTION(0);
33788   }
33789
33790   jresult = (void *)result;
33791   return jresult;
33792 }
33793
33794
33795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
33796   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
33797
33798   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
33799   {
33800     try {
33801       delete arg1;
33802     } CALL_CATCH_EXCEPTION();
33803   }
33804
33805 }
33806
33807
33808 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
33809   bool jresult ;
33810   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
33811   bool result;
33812
33813   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
33814   {
33815     try {
33816       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
33817     } CALL_CATCH_EXCEPTION(0);
33818   }
33819
33820   jresult = result;
33821   return jresult;
33822 }
33823
33824
33825 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
33826   unsigned long jresult ;
33827   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
33828   std::size_t result;
33829
33830   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
33831   {
33832     try {
33833       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
33834     } CALL_CATCH_EXCEPTION(0);
33835   }
33836
33837   jresult = (unsigned long)result;
33838   return jresult;
33839 }
33840
33841
33842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
33843   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
33844   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
33845
33846   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
33847   arg2 = (void (*)(Dali::RefObject const *))jarg2;
33848   {
33849     try {
33850       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
33851     } CALL_CATCH_EXCEPTION();
33852   }
33853
33854 }
33855
33856
33857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
33858   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
33859   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
33860
33861   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
33862   arg2 = (void (*)(Dali::RefObject const *))jarg2;
33863   {
33864     try {
33865       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
33866     } CALL_CATCH_EXCEPTION();
33867   }
33868
33869 }
33870
33871
33872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
33873   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
33874   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
33875
33876   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
33877   arg2 = (Dali::RefObject *)jarg2;
33878   {
33879     try {
33880       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
33881     } CALL_CATCH_EXCEPTION();
33882   }
33883
33884 }
33885
33886
33887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
33888   void * jresult ;
33889   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
33890
33891   {
33892     try {
33893       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
33894     } CALL_CATCH_EXCEPTION(0);
33895   }
33896
33897   jresult = (void *)result;
33898   return jresult;
33899 }
33900
33901
33902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
33903   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
33904
33905   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
33906   {
33907     try {
33908       delete arg1;
33909     } CALL_CATCH_EXCEPTION();
33910   }
33911
33912 }
33913
33914
33915 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
33916   bool jresult ;
33917   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
33918   bool result;
33919
33920   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
33921   {
33922     try {
33923       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
33924     } CALL_CATCH_EXCEPTION(0);
33925   }
33926
33927   jresult = result;
33928   return jresult;
33929 }
33930
33931
33932 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
33933   unsigned long jresult ;
33934   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
33935   std::size_t result;
33936
33937   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
33938   {
33939     try {
33940       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
33941     } CALL_CATCH_EXCEPTION(0);
33942   }
33943
33944   jresult = (unsigned long)result;
33945   return jresult;
33946 }
33947
33948
33949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
33950   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
33951   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
33952
33953   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
33954   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
33955   {
33956     try {
33957       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
33958     } CALL_CATCH_EXCEPTION();
33959   }
33960
33961 }
33962
33963
33964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
33965   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
33966   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
33967
33968   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
33969   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
33970   {
33971     try {
33972       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
33973     } CALL_CATCH_EXCEPTION();
33974   }
33975
33976 }
33977
33978
33979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
33980   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
33981   Dali::PropertyNotification *arg2 = 0 ;
33982
33983   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
33984   arg2 = (Dali::PropertyNotification *)jarg2;
33985   if (!arg2) {
33986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
33987     return ;
33988   }
33989   {
33990     try {
33991       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
33992     } CALL_CATCH_EXCEPTION();
33993   }
33994
33995 }
33996
33997
33998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
33999   void * jresult ;
34000   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
34001
34002   {
34003     try {
34004       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
34005     } CALL_CATCH_EXCEPTION(0);
34006   }
34007
34008   jresult = (void *)result;
34009   return jresult;
34010 }
34011
34012
34013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
34014   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
34015
34016   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
34017   {
34018     try {
34019       delete arg1;
34020     } CALL_CATCH_EXCEPTION();
34021   }
34022
34023 }
34024
34025
34026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
34027   void * jresult ;
34028   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
34029
34030   {
34031     try {
34032       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
34033     } CALL_CATCH_EXCEPTION(0);
34034   }
34035
34036   jresult = (void *)result;
34037   return jresult;
34038 }
34039
34040
34041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
34042   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
34043
34044   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
34045   {
34046     try {
34047       delete arg1;
34048     } CALL_CATCH_EXCEPTION();
34049   }
34050
34051 }
34052
34053
34054 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
34055   bool jresult ;
34056   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
34057   bool result;
34058
34059   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
34060   {
34061     try {
34062       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);
34063     } CALL_CATCH_EXCEPTION(0);
34064   }
34065
34066   jresult = result;
34067   return jresult;
34068 }
34069
34070
34071 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
34072   unsigned long jresult ;
34073   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
34074   std::size_t result;
34075
34076   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
34077   {
34078     try {
34079       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);
34080     } CALL_CATCH_EXCEPTION(0);
34081   }
34082
34083   jresult = (unsigned long)result;
34084   return jresult;
34085 }
34086
34087
34088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
34089   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
34090   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
34091
34092   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
34093   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
34094   {
34095     try {
34096       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
34097     } CALL_CATCH_EXCEPTION();
34098   }
34099
34100 }
34101
34102
34103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
34104   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
34105   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
34106
34107   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
34108   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
34109   {
34110     try {
34111       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
34112     } CALL_CATCH_EXCEPTION();
34113   }
34114
34115 }
34116
34117
34118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
34119   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
34120   Dali::Actor arg2 ;
34121   Dali::LongPressGesture *arg3 = 0 ;
34122   Dali::Actor *argp2 ;
34123
34124   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
34125   argp2 = (Dali::Actor *)jarg2;
34126   if (!argp2) {
34127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34128     return ;
34129   }
34130   arg2 = *argp2;
34131   arg3 = (Dali::LongPressGesture *)jarg3;
34132   if (!arg3) {
34133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
34134     return ;
34135   }
34136   {
34137     try {
34138       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
34139     } CALL_CATCH_EXCEPTION();
34140   }
34141
34142 }
34143
34144
34145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
34146   void * jresult ;
34147   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
34148
34149   {
34150     try {
34151       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
34152     } CALL_CATCH_EXCEPTION(0);
34153   }
34154
34155   jresult = (void *)result;
34156   return jresult;
34157 }
34158
34159
34160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
34161   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
34162
34163   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
34164   {
34165     try {
34166       delete arg1;
34167     } CALL_CATCH_EXCEPTION();
34168   }
34169
34170 }
34171
34172
34173 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
34174   bool jresult ;
34175   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
34176   bool result;
34177
34178   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
34179   {
34180     try {
34181       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);
34182     } CALL_CATCH_EXCEPTION(0);
34183   }
34184
34185   jresult = result;
34186   return jresult;
34187 }
34188
34189
34190 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
34191   unsigned long jresult ;
34192   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
34193   std::size_t result;
34194
34195   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
34196   {
34197     try {
34198       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);
34199     } CALL_CATCH_EXCEPTION(0);
34200   }
34201
34202   jresult = (unsigned long)result;
34203   return jresult;
34204 }
34205
34206
34207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
34208   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
34209   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
34210
34211   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
34212   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
34213   {
34214     try {
34215       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
34216     } CALL_CATCH_EXCEPTION();
34217   }
34218
34219 }
34220
34221
34222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
34223   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
34224   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
34225
34226   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
34227   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
34228   {
34229     try {
34230       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
34231     } CALL_CATCH_EXCEPTION();
34232   }
34233
34234 }
34235
34236
34237 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
34238   bool jresult ;
34239   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
34240   Dali::Actor arg2 ;
34241   Dali::TouchEvent *arg3 = 0 ;
34242   Dali::Actor *argp2 ;
34243   bool result;
34244
34245   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
34246   argp2 = (Dali::Actor *)jarg2;
34247   if (!argp2) {
34248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34249     return 0;
34250   }
34251   arg2 = *argp2;
34252   arg3 = (Dali::TouchEvent *)jarg3;
34253   if (!arg3) {
34254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
34255     return 0;
34256   }
34257   {
34258     try {
34259       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchEvent const &)*arg3);
34260     } CALL_CATCH_EXCEPTION(0);
34261   }
34262
34263   jresult = result;
34264   return jresult;
34265 }
34266
34267
34268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
34269   void * jresult ;
34270   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *result = 0 ;
34271
34272   {
34273     try {
34274       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) >();
34275     } CALL_CATCH_EXCEPTION(0);
34276   }
34277
34278   jresult = (void *)result;
34279   return jresult;
34280 }
34281
34282
34283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
34284   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
34285
34286   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
34287   {
34288     try {
34289       delete arg1;
34290     } CALL_CATCH_EXCEPTION();
34291   }
34292
34293 }
34294
34295
34296 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
34297   bool jresult ;
34298   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
34299   bool result;
34300
34301   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
34302   {
34303     try {
34304       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);
34305     } CALL_CATCH_EXCEPTION(0);
34306   }
34307
34308   jresult = result;
34309   return jresult;
34310 }
34311
34312
34313 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
34314   unsigned long jresult ;
34315   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
34316   std::size_t result;
34317
34318   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
34319   {
34320     try {
34321       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);
34322     } CALL_CATCH_EXCEPTION(0);
34323   }
34324
34325   jresult = (unsigned long)result;
34326   return jresult;
34327 }
34328
34329
34330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
34331   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
34332   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
34333
34334   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
34335   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
34336   {
34337     try {
34338       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
34339     } CALL_CATCH_EXCEPTION();
34340   }
34341
34342 }
34343
34344
34345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
34346   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
34347   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
34348
34349   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
34350   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
34351   {
34352     try {
34353       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
34354     } CALL_CATCH_EXCEPTION();
34355   }
34356
34357 }
34358
34359
34360 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
34361   bool jresult ;
34362   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
34363   Dali::Actor arg2 ;
34364   Dali::HoverEvent *arg3 = 0 ;
34365   Dali::Actor *argp2 ;
34366   bool result;
34367
34368   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
34369   argp2 = (Dali::Actor *)jarg2;
34370   if (!argp2) {
34371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34372     return 0;
34373   }
34374   arg2 = *argp2;
34375   arg3 = (Dali::HoverEvent *)jarg3;
34376   if (!arg3) {
34377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
34378     return 0;
34379   }
34380   {
34381     try {
34382       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
34383     } CALL_CATCH_EXCEPTION(0);
34384   }
34385
34386   jresult = result;
34387   return jresult;
34388 }
34389
34390
34391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
34392   void * jresult ;
34393   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
34394
34395   {
34396     try {
34397       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
34398     } CALL_CATCH_EXCEPTION(0);
34399   }
34400
34401   jresult = (void *)result;
34402   return jresult;
34403 }
34404
34405
34406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
34407   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
34408
34409   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
34410   {
34411     try {
34412       delete arg1;
34413     } CALL_CATCH_EXCEPTION();
34414   }
34415
34416 }
34417
34418
34419 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
34420   bool jresult ;
34421   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
34422   bool result;
34423
34424   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
34425   {
34426     try {
34427       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);
34428     } CALL_CATCH_EXCEPTION(0);
34429   }
34430
34431   jresult = result;
34432   return jresult;
34433 }
34434
34435
34436 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
34437   unsigned long jresult ;
34438   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
34439   std::size_t result;
34440
34441   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
34442   {
34443     try {
34444       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);
34445     } CALL_CATCH_EXCEPTION(0);
34446   }
34447
34448   jresult = (unsigned long)result;
34449   return jresult;
34450 }
34451
34452
34453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
34454   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
34455   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
34456
34457   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
34458   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
34459   {
34460     try {
34461       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
34462     } CALL_CATCH_EXCEPTION();
34463   }
34464
34465 }
34466
34467
34468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
34469   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
34470   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
34471
34472   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
34473   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
34474   {
34475     try {
34476       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
34477     } CALL_CATCH_EXCEPTION();
34478   }
34479
34480 }
34481
34482
34483 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
34484   bool jresult ;
34485   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
34486   Dali::Actor arg2 ;
34487   Dali::WheelEvent *arg3 = 0 ;
34488   Dali::Actor *argp2 ;
34489   bool result;
34490
34491   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
34492   argp2 = (Dali::Actor *)jarg2;
34493   if (!argp2) {
34494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34495     return 0;
34496   }
34497   arg2 = *argp2;
34498   arg3 = (Dali::WheelEvent *)jarg3;
34499   if (!arg3) {
34500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34501     return 0;
34502   }
34503   {
34504     try {
34505       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
34506     } CALL_CATCH_EXCEPTION(0);
34507   }
34508
34509   jresult = result;
34510   return jresult;
34511 }
34512
34513
34514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
34515   void * jresult ;
34516   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
34517
34518   {
34519     try {
34520       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
34521     } CALL_CATCH_EXCEPTION(0);
34522   }
34523
34524   jresult = (void *)result;
34525   return jresult;
34526 }
34527
34528
34529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
34530   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
34531
34532   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
34533   {
34534     try {
34535       delete arg1;
34536     } CALL_CATCH_EXCEPTION();
34537   }
34538
34539 }
34540
34541
34542 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
34543   bool jresult ;
34544   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
34545   bool result;
34546
34547   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
34548   {
34549     try {
34550       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
34551     } CALL_CATCH_EXCEPTION(0);
34552   }
34553
34554   jresult = result;
34555   return jresult;
34556 }
34557
34558
34559 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
34560   unsigned long jresult ;
34561   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
34562   std::size_t result;
34563
34564   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
34565   {
34566     try {
34567       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
34568     } CALL_CATCH_EXCEPTION(0);
34569   }
34570
34571   jresult = (unsigned long)result;
34572   return jresult;
34573 }
34574
34575
34576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
34577   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
34578   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
34579
34580   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
34581   arg2 = (void (*)(Dali::Actor))jarg2;
34582   {
34583     try {
34584       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
34585     } CALL_CATCH_EXCEPTION();
34586   }
34587
34588 }
34589
34590
34591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
34592   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
34593   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
34594
34595   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
34596   arg2 = (void (*)(Dali::Actor))jarg2;
34597   {
34598     try {
34599       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
34600     } CALL_CATCH_EXCEPTION();
34601   }
34602
34603 }
34604
34605
34606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
34607   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
34608   Dali::Actor arg2 ;
34609   Dali::Actor *argp2 ;
34610
34611   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
34612   argp2 = (Dali::Actor *)jarg2;
34613   if (!argp2) {
34614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34615     return ;
34616   }
34617   arg2 = *argp2;
34618   {
34619     try {
34620       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
34621     } CALL_CATCH_EXCEPTION();
34622   }
34623
34624 }
34625
34626
34627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
34628   void * jresult ;
34629   Dali::Signal< void (Dali::Actor) > *result = 0 ;
34630
34631   {
34632     try {
34633       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
34634     } CALL_CATCH_EXCEPTION(0);
34635   }
34636
34637   jresult = (void *)result;
34638   return jresult;
34639 }
34640
34641
34642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
34643   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
34644
34645   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
34646   {
34647     try {
34648       delete arg1;
34649     } CALL_CATCH_EXCEPTION();
34650   }
34651
34652 }
34653
34654
34655 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
34656   bool jresult ;
34657   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
34658   bool result;
34659
34660   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
34661   {
34662     try {
34663       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
34664     } CALL_CATCH_EXCEPTION(0);
34665   }
34666
34667   jresult = result;
34668   return jresult;
34669 }
34670
34671
34672 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
34673   unsigned long jresult ;
34674   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
34675   std::size_t result;
34676
34677   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
34678   {
34679     try {
34680       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
34681     } CALL_CATCH_EXCEPTION(0);
34682   }
34683
34684   jresult = (unsigned long)result;
34685   return jresult;
34686 }
34687
34688
34689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
34690   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
34691   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
34692
34693   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
34694   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
34695   {
34696     try {
34697       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
34698     } CALL_CATCH_EXCEPTION();
34699   }
34700
34701 }
34702
34703
34704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
34705   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
34706   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
34707
34708   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
34709   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
34710   {
34711     try {
34712       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
34713     } CALL_CATCH_EXCEPTION();
34714   }
34715
34716 }
34717
34718
34719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
34720   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
34721   Dali::KeyEvent *arg2 = 0 ;
34722
34723   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
34724   arg2 = (Dali::KeyEvent *)jarg2;
34725   if (!arg2) {
34726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
34727     return ;
34728   }
34729   {
34730     try {
34731       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
34732     } CALL_CATCH_EXCEPTION();
34733   }
34734
34735 }
34736
34737
34738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
34739   void * jresult ;
34740   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
34741
34742   {
34743     try {
34744       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
34745     } CALL_CATCH_EXCEPTION(0);
34746   }
34747
34748   jresult = (void *)result;
34749   return jresult;
34750 }
34751
34752
34753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
34754   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
34755
34756   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
34757   {
34758     try {
34759       delete arg1;
34760     } CALL_CATCH_EXCEPTION();
34761   }
34762
34763 }
34764
34765
34766 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
34767   bool jresult ;
34768   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
34769   bool result;
34770
34771   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
34772   {
34773     try {
34774       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
34775     } CALL_CATCH_EXCEPTION(0);
34776   }
34777
34778   jresult = result;
34779   return jresult;
34780 }
34781
34782
34783 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
34784   unsigned long jresult ;
34785   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
34786   std::size_t result;
34787
34788   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
34789   {
34790     try {
34791       result = Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
34792     } CALL_CATCH_EXCEPTION(0);
34793   }
34794
34795   jresult = (unsigned long)result;
34796   return jresult;
34797 }
34798
34799
34800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
34801   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
34802   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
34803
34804   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
34805   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
34806   {
34807     try {
34808       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
34809     } CALL_CATCH_EXCEPTION();
34810   }
34811
34812 }
34813
34814
34815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
34816   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
34817   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
34818
34819   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
34820   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
34821   {
34822     try {
34823       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
34824     } CALL_CATCH_EXCEPTION();
34825   }
34826
34827 }
34828
34829
34830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
34831   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
34832   Dali::TouchEvent *arg2 = 0 ;
34833
34834   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
34835   arg2 = (Dali::TouchEvent *)jarg2;
34836   if (!arg2) {
34837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
34838     return ;
34839   }
34840   {
34841     try {
34842       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchEvent const &)*arg2);
34843     } CALL_CATCH_EXCEPTION();
34844   }
34845
34846 }
34847
34848
34849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
34850   void * jresult ;
34851   Dali::Signal< void (Dali::TouchEvent const &) > *result = 0 ;
34852
34853   {
34854     try {
34855       result = (Dali::Signal< void (Dali::TouchEvent const &) > *)new Dali::Signal< void (Dali::TouchEvent const &) >();
34856     } CALL_CATCH_EXCEPTION(0);
34857   }
34858
34859   jresult = (void *)result;
34860   return jresult;
34861 }
34862
34863
34864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
34865   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
34866
34867   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
34868   {
34869     try {
34870       delete arg1;
34871     } CALL_CATCH_EXCEPTION();
34872   }
34873
34874 }
34875
34876
34877 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
34878   bool jresult ;
34879   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
34880   bool result;
34881
34882   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
34883   {
34884     try {
34885       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
34886     } CALL_CATCH_EXCEPTION(0);
34887   }
34888
34889   jresult = result;
34890   return jresult;
34891 }
34892
34893
34894 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
34895   unsigned long jresult ;
34896   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
34897   std::size_t result;
34898
34899   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
34900   {
34901     try {
34902       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
34903     } CALL_CATCH_EXCEPTION(0);
34904   }
34905
34906   jresult = (unsigned long)result;
34907   return jresult;
34908 }
34909
34910
34911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
34912   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
34913   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
34914
34915   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
34916   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
34917   {
34918     try {
34919       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
34920     } CALL_CATCH_EXCEPTION();
34921   }
34922
34923 }
34924
34925
34926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
34927   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
34928   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
34929
34930   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
34931   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
34932   {
34933     try {
34934       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
34935     } CALL_CATCH_EXCEPTION();
34936   }
34937
34938 }
34939
34940
34941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
34942   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
34943   Dali::WheelEvent *arg2 = 0 ;
34944
34945   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
34946   arg2 = (Dali::WheelEvent *)jarg2;
34947   if (!arg2) {
34948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34949     return ;
34950   }
34951   {
34952     try {
34953       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
34954     } CALL_CATCH_EXCEPTION();
34955   }
34956
34957 }
34958
34959
34960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
34961   void * jresult ;
34962   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
34963
34964   {
34965     try {
34966       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
34967     } CALL_CATCH_EXCEPTION(0);
34968   }
34969
34970   jresult = (void *)result;
34971   return jresult;
34972 }
34973
34974
34975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
34976   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
34977
34978   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
34979   {
34980     try {
34981       delete arg1;
34982     } CALL_CATCH_EXCEPTION();
34983   }
34984
34985 }
34986
34987
34988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
34989   void * jresult ;
34990   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
34991
34992   {
34993     try {
34994       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
34995     } CALL_CATCH_EXCEPTION(0);
34996   }
34997
34998   jresult = (void *)result;
34999   return jresult;
35000 }
35001
35002
35003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
35004   void * jresult ;
35005   Dali::Radian arg1 ;
35006   Dali::Radian arg2 ;
35007   Dali::Radian *argp1 ;
35008   Dali::Radian *argp2 ;
35009   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
35010
35011   argp1 = (Dali::Radian *)jarg1;
35012   if (!argp1) {
35013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35014     return 0;
35015   }
35016   arg1 = *argp1;
35017   argp2 = (Dali::Radian *)jarg2;
35018   if (!argp2) {
35019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35020     return 0;
35021   }
35022   arg2 = *argp2;
35023   {
35024     try {
35025       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
35026     } CALL_CATCH_EXCEPTION(0);
35027   }
35028
35029   jresult = (void *)result;
35030   return jresult;
35031 }
35032
35033
35034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
35035   void * jresult ;
35036   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
35037   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
35038
35039   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
35040   if (!arg1) {
35041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
35042     return 0;
35043   }
35044   {
35045     try {
35046       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
35047     } CALL_CATCH_EXCEPTION(0);
35048   }
35049
35050   jresult = (void *)result;
35051   return jresult;
35052 }
35053
35054
35055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
35056   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
35057   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
35058
35059   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
35060   arg2 = (Dali::Radian *)jarg2;
35061   if (arg1) (arg1)->first = *arg2;
35062 }
35063
35064
35065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
35066   void * jresult ;
35067   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
35068   Dali::Radian *result = 0 ;
35069
35070   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
35071   result = (Dali::Radian *)& ((arg1)->first);
35072   jresult = (void *)result;
35073   return jresult;
35074 }
35075
35076
35077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
35078   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
35079   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
35080
35081   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
35082   arg2 = (Dali::Radian *)jarg2;
35083   if (arg1) (arg1)->second = *arg2;
35084 }
35085
35086
35087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
35088   void * jresult ;
35089   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
35090   Dali::Radian *result = 0 ;
35091
35092   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
35093   result = (Dali::Radian *)& ((arg1)->second);
35094   jresult = (void *)result;
35095   return jresult;
35096 }
35097
35098
35099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
35100   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
35101
35102   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
35103   {
35104     try {
35105       delete arg1;
35106     } CALL_CATCH_EXCEPTION();
35107   }
35108
35109 }
35110
35111
35112 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
35113   bool jresult ;
35114   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
35115   bool result;
35116
35117   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
35118   {
35119     try {
35120       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);
35121     } CALL_CATCH_EXCEPTION(0);
35122   }
35123
35124   jresult = result;
35125   return jresult;
35126 }
35127
35128
35129 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
35130   unsigned long jresult ;
35131   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
35132   std::size_t result;
35133
35134   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
35135   {
35136     try {
35137       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);
35138     } CALL_CATCH_EXCEPTION(0);
35139   }
35140
35141   jresult = (unsigned long)result;
35142   return jresult;
35143 }
35144
35145
35146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
35147   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
35148   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
35149
35150   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
35151   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
35152   {
35153     try {
35154       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
35155     } CALL_CATCH_EXCEPTION();
35156   }
35157
35158 }
35159
35160
35161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
35162   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
35163   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
35164
35165   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
35166   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
35167   {
35168     try {
35169       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
35170     } CALL_CATCH_EXCEPTION();
35171   }
35172
35173 }
35174
35175
35176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
35177   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
35178   Dali::Actor arg2 ;
35179   Dali::PanGesture *arg3 = 0 ;
35180   Dali::Actor *argp2 ;
35181
35182   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
35183   argp2 = (Dali::Actor *)jarg2;
35184   if (!argp2) {
35185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
35186     return ;
35187   }
35188   arg2 = *argp2;
35189   arg3 = (Dali::PanGesture *)jarg3;
35190   if (!arg3) {
35191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35192     return ;
35193   }
35194   {
35195     try {
35196       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
35197     } CALL_CATCH_EXCEPTION();
35198   }
35199
35200 }
35201
35202
35203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
35204   void * jresult ;
35205   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
35206
35207   {
35208     try {
35209       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
35210     } CALL_CATCH_EXCEPTION(0);
35211   }
35212
35213   jresult = (void *)result;
35214   return jresult;
35215 }
35216
35217
35218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
35219   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
35220
35221   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
35222   {
35223     try {
35224       delete arg1;
35225     } CALL_CATCH_EXCEPTION();
35226   }
35227
35228 }
35229
35230
35231 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
35232   bool jresult ;
35233   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
35234   bool result;
35235
35236   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
35237   {
35238     try {
35239       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);
35240     } CALL_CATCH_EXCEPTION(0);
35241   }
35242
35243   jresult = result;
35244   return jresult;
35245 }
35246
35247
35248 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
35249   unsigned long jresult ;
35250   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
35251   std::size_t result;
35252
35253   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
35254   {
35255     try {
35256       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);
35257     } CALL_CATCH_EXCEPTION(0);
35258   }
35259
35260   jresult = (unsigned long)result;
35261   return jresult;
35262 }
35263
35264
35265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
35266   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
35267   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
35268
35269   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
35270   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
35271   {
35272     try {
35273       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
35274     } CALL_CATCH_EXCEPTION();
35275   }
35276
35277 }
35278
35279
35280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
35281   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
35282   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
35283
35284   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
35285   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
35286   {
35287     try {
35288       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
35289     } CALL_CATCH_EXCEPTION();
35290   }
35291
35292 }
35293
35294
35295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
35296   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
35297   Dali::Actor arg2 ;
35298   Dali::PinchGesture *arg3 = 0 ;
35299   Dali::Actor *argp2 ;
35300
35301   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
35302   argp2 = (Dali::Actor *)jarg2;
35303   if (!argp2) {
35304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
35305     return ;
35306   }
35307   arg2 = *argp2;
35308   arg3 = (Dali::PinchGesture *)jarg3;
35309   if (!arg3) {
35310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
35311     return ;
35312   }
35313   {
35314     try {
35315       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
35316     } CALL_CATCH_EXCEPTION();
35317   }
35318
35319 }
35320
35321
35322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
35323   void * jresult ;
35324   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
35325
35326   {
35327     try {
35328       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
35329     } CALL_CATCH_EXCEPTION(0);
35330   }
35331
35332   jresult = (void *)result;
35333   return jresult;
35334 }
35335
35336
35337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
35338   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
35339
35340   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
35341   {
35342     try {
35343       delete arg1;
35344     } CALL_CATCH_EXCEPTION();
35345   }
35346
35347 }
35348
35349
35350 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
35351   bool jresult ;
35352   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
35353   bool result;
35354
35355   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
35356   {
35357     try {
35358       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);
35359     } CALL_CATCH_EXCEPTION(0);
35360   }
35361
35362   jresult = result;
35363   return jresult;
35364 }
35365
35366
35367 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
35368   unsigned long jresult ;
35369   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
35370   std::size_t result;
35371
35372   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
35373   {
35374     try {
35375       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);
35376     } CALL_CATCH_EXCEPTION(0);
35377   }
35378
35379   jresult = (unsigned long)result;
35380   return jresult;
35381 }
35382
35383
35384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
35385   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
35386   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
35387
35388   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
35389   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
35390   {
35391     try {
35392       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
35393     } CALL_CATCH_EXCEPTION();
35394   }
35395
35396 }
35397
35398
35399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
35400   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
35401   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
35402
35403   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
35404   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
35405   {
35406     try {
35407       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
35408     } CALL_CATCH_EXCEPTION();
35409   }
35410
35411 }
35412
35413
35414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
35415   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
35416   Dali::Actor arg2 ;
35417   Dali::TapGesture *arg3 = 0 ;
35418   Dali::Actor *argp2 ;
35419
35420   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
35421   argp2 = (Dali::Actor *)jarg2;
35422   if (!argp2) {
35423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
35424     return ;
35425   }
35426   arg2 = *argp2;
35427   arg3 = (Dali::TapGesture *)jarg3;
35428   if (!arg3) {
35429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
35430     return ;
35431   }
35432   {
35433     try {
35434       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
35435     } CALL_CATCH_EXCEPTION();
35436   }
35437
35438 }
35439
35440
35441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
35442   void * jresult ;
35443   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
35444
35445   {
35446     try {
35447       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
35448     } CALL_CATCH_EXCEPTION(0);
35449   }
35450
35451   jresult = (void *)result;
35452   return jresult;
35453 }
35454
35455
35456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
35457   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
35458
35459   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
35460   {
35461     try {
35462       delete arg1;
35463     } CALL_CATCH_EXCEPTION();
35464   }
35465
35466 }
35467
35468
35469 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
35470   bool jresult ;
35471   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
35472   bool result = false;
35473
35474   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
35475   {
35476     try {
35477       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);
35478     } CALL_CATCH_EXCEPTION(0);
35479   }
35480   jresult = result;
35481   return jresult;
35482 }
35483
35484 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
35485   unsigned long jresult ;
35486   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
35487   std::size_t result = 0;
35488
35489   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
35490   {
35491     try {
35492       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);
35493     }CALL_CATCH_EXCEPTION(0);
35494   }
35495   jresult = (unsigned long)result;
35496   return jresult;
35497 }
35498
35499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
35500   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
35501   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
35502
35503   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
35504   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
35505   {
35506     try {
35507       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
35508     } CALL_CATCH_EXCEPTION();
35509   }
35510 }
35511
35512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
35513   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
35514   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
35515
35516   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
35517   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
35518   {
35519     try {
35520       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
35521     } CALL_CATCH_EXCEPTION();
35522   }
35523 }
35524
35525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
35526   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
35527   Dali::Actor arg2 ;
35528   //bool arg3 ;
35529   Dali::LayoutDirection::Type arg4 ;
35530   Dali::Actor *argp2 ;
35531
35532   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
35533   argp2 = (Dali::Actor *)jarg2;
35534   if (!argp2) {
35535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
35536     return ;
35537   }
35538   arg2 = *argp2;
35539   //arg3 = jarg3 ? true : false;
35540   arg4 = (Dali::LayoutDirection::Type)jarg4;
35541   {
35542     try {
35543       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
35544     } CALL_CATCH_EXCEPTION();
35545   }
35546 }
35547
35548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
35549   void * jresult ;
35550   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
35551
35552   {
35553     try {
35554       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
35555     } CALL_CATCH_EXCEPTION(0);
35556   }
35557   jresult = (void *)result;
35558   return jresult;
35559 }
35560
35561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
35562   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
35563
35564   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
35565   {
35566     try {
35567       delete arg1;
35568     } CALL_CATCH_EXCEPTION();
35569   }
35570 }
35571
35572
35573 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
35574   bool jresult ;
35575   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
35576   bool result = false;
35577
35578   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
35579   {
35580     try {
35581       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);
35582     } CALL_CATCH_EXCEPTION(0);
35583   }
35584   jresult = result;
35585   return jresult;
35586 }
35587
35588
35589 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
35590   unsigned long jresult ;
35591   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
35592   std::size_t result;
35593
35594   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
35595   {
35596     try {
35597       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);
35598     } CALL_CATCH_EXCEPTION(0);
35599   }
35600
35601   jresult = (unsigned long)result;
35602   return jresult;
35603 }
35604
35605
35606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
35607   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
35608   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
35609
35610   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
35611   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
35612   {
35613     try {
35614       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
35615     } CALL_CATCH_EXCEPTION();
35616   }
35617
35618 }
35619
35620
35621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
35622   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
35623   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
35624
35625   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
35626   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
35627   {
35628     try {
35629       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
35630     } CALL_CATCH_EXCEPTION();
35631   }
35632
35633 }
35634
35635
35636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, bool jarg3, int jarg4) {
35637   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
35638   Dali::Actor arg2 ;
35639   bool arg3 ;
35640   Dali::DevelActor::VisibilityChange::Type arg4 ;
35641   Dali::Actor *argp2 ;
35642
35643   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
35644   argp2 = (Dali::Actor *)jarg2;
35645   if (!argp2) {
35646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
35647     return ;
35648   }
35649   arg2 = *argp2;
35650   arg3 = jarg3 ? true : false;
35651   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
35652   {
35653     try {
35654       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
35655     } CALL_CATCH_EXCEPTION();
35656   }
35657
35658 }
35659
35660
35661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
35662   void * jresult ;
35663   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
35664
35665   {
35666     try {
35667       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
35668     } CALL_CATCH_EXCEPTION(0);
35669   }
35670
35671   jresult = (void *)result;
35672   return jresult;
35673 }
35674
35675
35676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
35677   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
35678
35679   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
35680   {
35681     try {
35682       delete arg1;
35683     } CALL_CATCH_EXCEPTION();
35684   }
35685
35686 }
35687
35688
35689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
35690   void * jresult ;
35691   Dali::Timer *result = 0 ;
35692
35693   {
35694     try {
35695       result = (Dali::Timer *)new Dali::Timer();
35696     } CALL_CATCH_EXCEPTION(0);
35697   }
35698
35699   jresult = (void *)result;
35700   return jresult;
35701 }
35702
35703
35704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
35705   void * jresult ;
35706   unsigned int arg1 ;
35707   Dali::Timer result;
35708
35709   arg1 = (unsigned int)jarg1;
35710   {
35711     try {
35712       result = Dali::Timer::New(arg1);
35713     } CALL_CATCH_EXCEPTION(0);
35714   }
35715
35716   jresult = new Dali::Timer((const Dali::Timer &)result);
35717   return jresult;
35718 }
35719
35720
35721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
35722   void * jresult ;
35723   Dali::Timer *arg1 = 0 ;
35724   Dali::Timer *result = 0 ;
35725
35726   arg1 = (Dali::Timer *)jarg1;
35727   if (!arg1) {
35728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
35729     return 0;
35730   }
35731   {
35732     try {
35733       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
35734     } CALL_CATCH_EXCEPTION(0);
35735   }
35736
35737   jresult = (void *)result;
35738   return jresult;
35739 }
35740
35741
35742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
35743   void * jresult ;
35744   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
35745   Dali::Timer *arg2 = 0 ;
35746   Dali::Timer *result = 0 ;
35747
35748   arg1 = (Dali::Timer *)jarg1;
35749   arg2 = (Dali::Timer *)jarg2;
35750   if (!arg2) {
35751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
35752     return 0;
35753   }
35754   {
35755     try {
35756       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
35757     } CALL_CATCH_EXCEPTION(0);
35758   }
35759
35760   jresult = (void *)result;
35761   return jresult;
35762 }
35763
35764
35765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
35766   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
35767
35768   arg1 = (Dali::Timer *)jarg1;
35769   {
35770     try {
35771       delete arg1;
35772     } CALL_CATCH_EXCEPTION();
35773   }
35774
35775 }
35776
35777
35778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
35779   void * jresult ;
35780   Dali::BaseHandle arg1 ;
35781   Dali::BaseHandle *argp1 ;
35782   Dali::Timer result;
35783
35784   argp1 = (Dali::BaseHandle *)jarg1;
35785   if (!argp1) {
35786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35787     return 0;
35788   }
35789   arg1 = *argp1;
35790   {
35791     try {
35792       result = Dali::Timer::DownCast(arg1);
35793     } CALL_CATCH_EXCEPTION(0);
35794   }
35795
35796   jresult = new Dali::Timer((const Dali::Timer &)result);
35797   return jresult;
35798 }
35799
35800
35801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
35802   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
35803
35804   arg1 = (Dali::Timer *)jarg1;
35805   {
35806     try {
35807       (arg1)->Start();
35808     } CALL_CATCH_EXCEPTION();
35809   }
35810
35811 }
35812
35813
35814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
35815   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
35816
35817   arg1 = (Dali::Timer *)jarg1;
35818   {
35819     try {
35820       (arg1)->Stop();
35821     } CALL_CATCH_EXCEPTION();
35822   }
35823
35824 }
35825
35826
35827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
35828   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
35829   unsigned int arg2 ;
35830
35831   arg1 = (Dali::Timer *)jarg1;
35832   arg2 = (unsigned int)jarg2;
35833   {
35834     try {
35835       (arg1)->SetInterval(arg2);
35836     } CALL_CATCH_EXCEPTION();
35837   }
35838
35839 }
35840
35841
35842 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
35843   unsigned int jresult ;
35844   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
35845   unsigned int result;
35846
35847   arg1 = (Dali::Timer *)jarg1;
35848   {
35849     try {
35850       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
35851     } CALL_CATCH_EXCEPTION(0);
35852   }
35853
35854   jresult = result;
35855   return jresult;
35856 }
35857
35858
35859 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
35860   bool jresult ;
35861   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
35862   bool result;
35863
35864   arg1 = (Dali::Timer *)jarg1;
35865   {
35866     try {
35867       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
35868     } CALL_CATCH_EXCEPTION(0);
35869   }
35870
35871   jresult = result;
35872   return jresult;
35873 }
35874
35875
35876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
35877   void * jresult ;
35878   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
35879   Dali::Timer::TimerSignalType *result = 0 ;
35880
35881   arg1 = (Dali::Timer *)jarg1;
35882   {
35883     try {
35884       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
35885     } CALL_CATCH_EXCEPTION(0);
35886   }
35887
35888   jresult = (void *)result;
35889   return jresult;
35890 }
35891
35892
35893 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
35894   bool jresult ;
35895   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
35896   bool result;
35897
35898   arg1 = (Dali::Signal< bool () > *)jarg1;
35899   {
35900     try {
35901       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
35902     } CALL_CATCH_EXCEPTION(0);
35903   }
35904
35905   jresult = result;
35906   return jresult;
35907 }
35908
35909
35910 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
35911   unsigned long jresult ;
35912   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
35913   std::size_t result;
35914
35915   arg1 = (Dali::Signal< bool () > *)jarg1;
35916   {
35917     try {
35918       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
35919     } CALL_CATCH_EXCEPTION(0);
35920   }
35921
35922   jresult = (unsigned long)result;
35923   return jresult;
35924 }
35925
35926
35927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
35928   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
35929   bool (*arg2)() = (bool (*)()) 0 ;
35930
35931   arg1 = (Dali::Signal< bool () > *)jarg1;
35932   arg2 = (bool (*)())jarg2;
35933   {
35934     try {
35935       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
35936     } CALL_CATCH_EXCEPTION();
35937   }
35938
35939 }
35940
35941
35942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
35943   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
35944   bool (*arg2)() = (bool (*)()) 0 ;
35945
35946   arg1 = (Dali::Signal< bool () > *)jarg1;
35947   arg2 = (bool (*)())jarg2;
35948   {
35949     try {
35950       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
35951     } CALL_CATCH_EXCEPTION();
35952   }
35953
35954 }
35955
35956
35957 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
35958   bool jresult ;
35959   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
35960   bool result;
35961
35962   arg1 = (Dali::Signal< bool () > *)jarg1;
35963   {
35964     try {
35965       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
35966     } CALL_CATCH_EXCEPTION(0);
35967   }
35968
35969   jresult = result;
35970   return jresult;
35971 }
35972
35973
35974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
35975   void * jresult ;
35976   Dali::Signal< bool () > *result = 0 ;
35977
35978   {
35979     try {
35980       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
35981     } CALL_CATCH_EXCEPTION(0);
35982   }
35983
35984   jresult = (void *)result;
35985   return jresult;
35986 }
35987
35988
35989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
35990   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
35991
35992   arg1 = (Dali::Signal< bool () > *)jarg1;
35993   {
35994     try {
35995       delete arg1;
35996     } CALL_CATCH_EXCEPTION();
35997   }
35998
35999 }
36000
36001
36002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
36003   int jresult ;
36004   int result;
36005
36006   {
36007     try {
36008       result = (int)Dali::Toolkit::Visual::Property::TYPE;
36009     } CALL_CATCH_EXCEPTION(0);
36010   }
36011
36012   jresult = (int)result;
36013   return jresult;
36014 }
36015
36016
36017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
36018   int jresult ;
36019   int result;
36020
36021   {
36022     try {
36023       result = (int)Dali::Toolkit::Visual::Property::SHADER;
36024     } CALL_CATCH_EXCEPTION(0);
36025   }
36026
36027   jresult = (int)result;
36028   return jresult;
36029 }
36030
36031
36032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
36033   int jresult ;
36034   int result;
36035
36036   {
36037     try {
36038       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
36039     } CALL_CATCH_EXCEPTION(0);
36040   }
36041
36042   jresult = (int)result;
36043   return jresult;
36044 }
36045
36046
36047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
36048   int jresult ;
36049   int result;
36050
36051   {
36052     try {
36053       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
36054     } CALL_CATCH_EXCEPTION(0);
36055   }
36056
36057   jresult = (int)result;
36058   return jresult;
36059 }
36060
36061
36062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
36063   int jresult ;
36064   int result;
36065
36066   {
36067     try {
36068       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
36069     } CALL_CATCH_EXCEPTION(0);
36070   }
36071
36072   jresult = (int)result;
36073   return jresult;
36074 }
36075
36076
36077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
36078   int jresult ;
36079   int result;
36080
36081   {
36082     try {
36083       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
36084     } CALL_CATCH_EXCEPTION(0);
36085   }
36086
36087   jresult = (int)result;
36088   return jresult;
36089 }
36090
36091
36092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
36093   int jresult ;
36094   int result;
36095
36096   {
36097     try {
36098       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
36099     } CALL_CATCH_EXCEPTION(0);
36100   }
36101
36102   jresult = (int)result;
36103   return jresult;
36104 }
36105
36106
36107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
36108   int jresult ;
36109   int result;
36110
36111   {
36112     try {
36113       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
36114     } CALL_CATCH_EXCEPTION(0);
36115   }
36116
36117   jresult = (int)result;
36118   return jresult;
36119 }
36120
36121
36122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
36123   int jresult ;
36124   int result;
36125
36126   {
36127     try {
36128       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
36129     } CALL_CATCH_EXCEPTION(0);
36130   }
36131
36132   jresult = (int)result;
36133   return jresult;
36134 }
36135
36136
36137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
36138   int jresult ;
36139   int result;
36140
36141   {
36142     try {
36143       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
36144     } CALL_CATCH_EXCEPTION(0);
36145   }
36146
36147   jresult = (int)result;
36148   return jresult;
36149 }
36150
36151
36152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
36153   int jresult ;
36154   int result;
36155
36156   {
36157     try {
36158       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
36159     } CALL_CATCH_EXCEPTION(0);
36160   }
36161
36162   jresult = (int)result;
36163   return jresult;
36164 }
36165
36166
36167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
36168   int jresult ;
36169   int result;
36170
36171   {
36172     try {
36173       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
36174     } CALL_CATCH_EXCEPTION(0);
36175   }
36176
36177   jresult = (int)result;
36178   return jresult;
36179 }
36180
36181
36182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
36183   int jresult ;
36184   int result;
36185
36186   {
36187     try {
36188       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
36189     } CALL_CATCH_EXCEPTION(0);
36190   }
36191
36192   jresult = (int)result;
36193   return jresult;
36194 }
36195
36196
36197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
36198   int jresult ;
36199   int result;
36200
36201   {
36202     try {
36203       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
36204     } CALL_CATCH_EXCEPTION(0);
36205   }
36206
36207   jresult = (int)result;
36208   return jresult;
36209 }
36210
36211
36212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
36213   int jresult ;
36214   int result;
36215
36216   {
36217     try {
36218       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
36219     } CALL_CATCH_EXCEPTION(0);
36220   }
36221
36222   jresult = (int)result;
36223   return jresult;
36224 }
36225
36226
36227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
36228   int jresult ;
36229   int result;
36230
36231   {
36232     try {
36233       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
36234     } CALL_CATCH_EXCEPTION(0);
36235   }
36236
36237   jresult = (int)result;
36238   return jresult;
36239 }
36240
36241
36242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
36243   int jresult ;
36244   int result;
36245
36246   {
36247     try {
36248       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
36249     } CALL_CATCH_EXCEPTION(0);
36250   }
36251
36252   jresult = (int)result;
36253   return jresult;
36254 }
36255
36256
36257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
36258   int jresult ;
36259   int result;
36260
36261   {
36262     try {
36263       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
36264     } CALL_CATCH_EXCEPTION(0);
36265   }
36266
36267   jresult = (int)result;
36268   return jresult;
36269 }
36270
36271
36272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
36273   int jresult ;
36274   int result;
36275
36276   {
36277     try {
36278       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
36279     } CALL_CATCH_EXCEPTION(0);
36280   }
36281
36282   jresult = (int)result;
36283   return jresult;
36284 }
36285
36286
36287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
36288   int jresult ;
36289   int result;
36290
36291   {
36292     try {
36293       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
36294     } CALL_CATCH_EXCEPTION(0);
36295   }
36296
36297   jresult = (int)result;
36298   return jresult;
36299 }
36300
36301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
36302   int jresult ;
36303   int result;
36304
36305   {
36306     try {
36307       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
36308     } CALL_CATCH_EXCEPTION(0);
36309   }
36310
36311   jresult = (int)result;
36312   return jresult;
36313 }
36314
36315
36316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
36317   int jresult ;
36318   int result;
36319   {
36320     try
36321     {
36322       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
36323     } CALL_CATCH_EXCEPTION(0);
36324   }
36325
36326   jresult = (int)result;
36327   return jresult;
36328 }
36329
36330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
36331   int jresult ;
36332   int result;
36333   {
36334     try
36335     {
36336       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
36337     } CALL_CATCH_EXCEPTION(0);
36338   }
36339
36340   jresult = (int)result;
36341   return jresult;
36342 }
36343
36344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
36345   int jresult ;
36346   int result;
36347   {
36348     try
36349     {
36350       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
36351     } CALL_CATCH_EXCEPTION(0);
36352   }
36353
36354   jresult = (int)result;
36355   return jresult;
36356 }
36357
36358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
36359   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
36360 }
36361
36362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
36363   int jresult ;
36364   int result;
36365   {
36366     try
36367     {
36368       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
36369     } CALL_CATCH_EXCEPTION(0);
36370   }
36371
36372   jresult = (int)result;
36373   return jresult;
36374 }
36375
36376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
36377   int jresult ;
36378   int result;
36379   {
36380     try
36381     {
36382       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
36383     } CALL_CATCH_EXCEPTION(0);
36384   }
36385
36386   jresult = (int)result;
36387   return jresult;
36388 }
36389
36390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
36391   int jresult ;
36392   int result;
36393
36394   {
36395     try {
36396       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
36397     } CALL_CATCH_EXCEPTION(0);
36398   }
36399
36400   jresult = (int)result;
36401   return jresult;
36402 }
36403
36404
36405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
36406   int jresult ;
36407   int result;
36408
36409   {
36410     try {
36411       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
36412     } CALL_CATCH_EXCEPTION(0);
36413   }
36414
36415   jresult = (int)result;
36416   return jresult;
36417 }
36418
36419 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
36420   int jresult ;
36421   int result;
36422   {
36423     try
36424     {
36425       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
36426     } CALL_CATCH_EXCEPTION(0);
36427   }
36428
36429   jresult = (int)result;
36430   return jresult;
36431 }
36432
36433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
36434   int jresult ;
36435   int result;
36436   {
36437     try
36438     {
36439       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
36440     } CALL_CATCH_EXCEPTION(0);
36441   }
36442
36443   jresult = (int)result;
36444   return jresult;
36445 }
36446
36447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
36448   int jresult ;
36449   int result;
36450   {
36451     try
36452     {
36453       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
36454     } CALL_CATCH_EXCEPTION(0);
36455   }
36456
36457   jresult = (int)result;
36458   return jresult;
36459 }
36460
36461
36462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
36463   int jresult ;
36464   int result;
36465   {
36466     try
36467     {
36468       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
36469     } CALL_CATCH_EXCEPTION(0);
36470   }
36471
36472   jresult = (int)result;
36473   return jresult;
36474 }
36475
36476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
36477   int jresult ;
36478   int result;
36479   {
36480     try
36481     {
36482       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
36483     } CALL_CATCH_EXCEPTION(0);
36484   }
36485
36486   jresult = (int)result;
36487   return jresult;
36488 }
36489
36490
36491
36492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
36493   int jresult ;
36494   int result;
36495
36496   {
36497     try {
36498       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
36499     } CALL_CATCH_EXCEPTION(0);
36500   }
36501
36502   jresult = (int)result;
36503   return jresult;
36504 }
36505
36506
36507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
36508   int jresult ;
36509   int result;
36510
36511   {
36512     try {
36513       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
36514     } CALL_CATCH_EXCEPTION(0);
36515   }
36516
36517   jresult = (int)result;
36518   return jresult;
36519 }
36520
36521
36522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
36523   int jresult ;
36524   int result;
36525
36526   {
36527     try {
36528       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
36529     } CALL_CATCH_EXCEPTION(0);
36530   }
36531
36532   jresult = (int)result;
36533   return jresult;
36534 }
36535
36536
36537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
36538   int jresult ;
36539   int result;
36540
36541   {
36542     try {
36543       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
36544     } CALL_CATCH_EXCEPTION(0);
36545   }
36546
36547   jresult = (int)result;
36548   return jresult;
36549 }
36550
36551
36552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
36553   int jresult ;
36554   int result;
36555
36556   {
36557     try {
36558       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
36559     } CALL_CATCH_EXCEPTION(0);
36560   }
36561
36562   jresult = (int)result;
36563   return jresult;
36564 }
36565
36566
36567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
36568   int jresult ;
36569   int result;
36570
36571   {
36572     try {
36573       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
36574     } CALL_CATCH_EXCEPTION(0);
36575   }
36576
36577   jresult = (int)result;
36578   return jresult;
36579 }
36580
36581
36582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
36583   int jresult ;
36584   int result;
36585
36586   {
36587     try {
36588       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
36589     } CALL_CATCH_EXCEPTION(0);
36590   }
36591
36592   jresult = (int)result;
36593   return jresult;
36594 }
36595
36596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_USE_FIXED_CACHE_get() {
36597   int jresult ;
36598   int result;
36599
36600   {
36601     try {
36602       result = (int)Dali::Toolkit::DevelImageVisual::Property::USE_FIXED_CACHE;
36603     } CALL_CATCH_EXCEPTION(0);
36604   }
36605
36606   jresult = (int)result;
36607   return jresult;
36608 }
36609
36610 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
36611   int jresult ;
36612   int result;
36613
36614   {
36615     try {
36616       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
36617     } CALL_CATCH_EXCEPTION(0);
36618   }
36619
36620   jresult = (int)result;
36621   return jresult;
36622 }
36623
36624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
36625   int jresult ;
36626   int result;
36627
36628   {
36629     try {
36630       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
36631     } CALL_CATCH_EXCEPTION(0);
36632   }
36633
36634   jresult = (int)result;
36635   return jresult;
36636 }
36637
36638
36639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
36640   int jresult ;
36641   int result;
36642
36643   {
36644     try {
36645       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
36646     } CALL_CATCH_EXCEPTION(0);
36647   }
36648
36649   jresult = (int)result;
36650   return jresult;
36651 }
36652
36653
36654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
36655   int jresult ;
36656   int result;
36657
36658   {
36659     try {
36660       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
36661     } CALL_CATCH_EXCEPTION(0);
36662   }
36663
36664   jresult = (int)result;
36665   return jresult;
36666 }
36667
36668
36669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
36670   int jresult ;
36671   int result;
36672
36673   {
36674     try {
36675       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
36676     } CALL_CATCH_EXCEPTION(0);
36677   }
36678
36679   jresult = (int)result;
36680   return jresult;
36681 }
36682
36683
36684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
36685   int jresult ;
36686   int result;
36687
36688   {
36689     try {
36690       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
36691     } CALL_CATCH_EXCEPTION(0);
36692   }
36693
36694   jresult = (int)result;
36695   return jresult;
36696 }
36697
36698
36699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
36700   int jresult ;
36701   int result;
36702
36703   {
36704     try {
36705       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
36706     } CALL_CATCH_EXCEPTION(0);
36707   }
36708
36709   jresult = (int)result;
36710   return jresult;
36711 }
36712
36713
36714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
36715   int jresult ;
36716   int result;
36717
36718   {
36719     try {
36720       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
36721     } CALL_CATCH_EXCEPTION(0);
36722   }
36723
36724   jresult = (int)result;
36725   return jresult;
36726 }
36727
36728
36729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
36730   int jresult ;
36731   int result;
36732
36733   {
36734     try {
36735       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
36736     } CALL_CATCH_EXCEPTION(0);
36737   }
36738
36739   jresult = (int)result;
36740   return jresult;
36741 }
36742
36743
36744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
36745   int jresult ;
36746   int result;
36747
36748   {
36749     try {
36750       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
36751     } CALL_CATCH_EXCEPTION(0);
36752   }
36753
36754   jresult = (int)result;
36755   return jresult;
36756 }
36757
36758
36759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
36760   int jresult ;
36761   int result;
36762
36763   {
36764     try {
36765       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
36766     } CALL_CATCH_EXCEPTION(0);
36767   }
36768
36769   jresult = (int)result;
36770   return jresult;
36771 }
36772
36773
36774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
36775   int jresult ;
36776   int result;
36777
36778   {
36779     try {
36780       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
36781     } CALL_CATCH_EXCEPTION(0);
36782   }
36783
36784   jresult = (int)result;
36785   return jresult;
36786 }
36787
36788
36789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
36790   int jresult ;
36791   int result;
36792
36793   {
36794     try {
36795       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
36796     } CALL_CATCH_EXCEPTION(0);
36797   }
36798
36799   jresult = (int)result;
36800   return jresult;
36801 }
36802
36803
36804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
36805   int jresult ;
36806   int result;
36807
36808   {
36809     try {
36810       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
36811     } CALL_CATCH_EXCEPTION(0);
36812   }
36813
36814   jresult = (int)result;
36815   return jresult;
36816 }
36817
36818
36819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
36820   int jresult ;
36821   int result;
36822
36823   {
36824     try {
36825       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
36826     } CALL_CATCH_EXCEPTION(0);
36827   }
36828
36829   jresult = (int)result;
36830   return jresult;
36831 }
36832
36833
36834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
36835   int jresult ;
36836   int result;
36837
36838   {
36839     try {
36840       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
36841     } CALL_CATCH_EXCEPTION(0);
36842   }
36843
36844   jresult = (int)result;
36845   return jresult;
36846 }
36847
36848
36849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
36850   int jresult ;
36851   int result;
36852
36853   {
36854     try {
36855       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
36856     } CALL_CATCH_EXCEPTION(0);
36857   }
36858
36859   jresult = (int)result;
36860   return jresult;
36861 }
36862
36863
36864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
36865   int jresult ;
36866   int result;
36867
36868   {
36869     try {
36870       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
36871     } CALL_CATCH_EXCEPTION(0);
36872   }
36873
36874   jresult = (int)result;
36875   return jresult;
36876 }
36877
36878
36879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
36880   int jresult ;
36881   int result;
36882
36883   {
36884     try {
36885       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
36886     } CALL_CATCH_EXCEPTION(0);
36887   }
36888
36889   jresult = (int)result;
36890   return jresult;
36891 }
36892
36893
36894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
36895   int jresult ;
36896   int result;
36897
36898   {
36899     try {
36900       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
36901     } CALL_CATCH_EXCEPTION(0);
36902   }
36903
36904   jresult = (int)result;
36905   return jresult;
36906 }
36907
36908
36909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
36910   int jresult ;
36911   int result;
36912
36913   {
36914     try {
36915       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
36916     } CALL_CATCH_EXCEPTION(0);
36917   }
36918
36919   jresult = (int)result;
36920   return jresult;
36921 }
36922
36923
36924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
36925   int jresult ;
36926   int result;
36927
36928   {
36929     try {
36930       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
36931     } CALL_CATCH_EXCEPTION(0);
36932   }
36933
36934   jresult = (int)result;
36935   return jresult;
36936 }
36937
36938
36939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
36940   int jresult ;
36941   int result;
36942
36943   {
36944     try {
36945       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
36946     } CALL_CATCH_EXCEPTION(0);
36947   }
36948
36949   jresult = (int)result;
36950   return jresult;
36951 }
36952
36953
36954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
36955   int jresult ;
36956   int result;
36957
36958   {
36959     try {
36960       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
36961     } CALL_CATCH_EXCEPTION(0);
36962   }
36963
36964   jresult = (int)result;
36965   return jresult;
36966 }
36967
36968
36969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
36970   int jresult ;
36971   int result;
36972
36973   {
36974     try {
36975       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
36976     } CALL_CATCH_EXCEPTION(0);
36977   }
36978
36979   jresult = (int)result;
36980   return jresult;
36981 }
36982
36983
36984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
36985   int jresult ;
36986   int result;
36987
36988   {
36989     try {
36990       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
36991     } CALL_CATCH_EXCEPTION(0);
36992   }
36993
36994   jresult = (int)result;
36995   return jresult;
36996 }
36997
36998
36999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
37000   int jresult ;
37001   int result;
37002
37003   {
37004     try {
37005       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
37006     } CALL_CATCH_EXCEPTION(0);
37007   }
37008
37009   jresult = (int)result;
37010   return jresult;
37011 }
37012
37013
37014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
37015   int jresult ;
37016   int result;
37017
37018   {
37019     try {
37020       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
37021     } CALL_CATCH_EXCEPTION(0);
37022   }
37023
37024   jresult = (int)result;
37025   return jresult;
37026 }
37027
37028
37029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
37030   int jresult ;
37031   int result;
37032
37033   {
37034     try {
37035       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
37036     } CALL_CATCH_EXCEPTION(0);
37037   }
37038
37039   jresult = (int)result;
37040   return jresult;
37041 }
37042
37043
37044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
37045   void * jresult ;
37046   Dali::Toolkit::Builder *result = 0 ;
37047
37048   {
37049     try {
37050       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
37051     } CALL_CATCH_EXCEPTION(0);
37052   }
37053
37054   jresult = (void *)result;
37055   return jresult;
37056 }
37057
37058
37059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
37060   void * jresult ;
37061   Dali::Toolkit::Builder result;
37062
37063   {
37064     try {
37065       result = Dali::Toolkit::Builder::New();
37066     } CALL_CATCH_EXCEPTION(0);
37067   }
37068
37069   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
37070   return jresult;
37071 }
37072
37073
37074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
37075   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37076
37077   arg1 = (Dali::Toolkit::Builder *)jarg1;
37078   {
37079     try {
37080       delete arg1;
37081     } CALL_CATCH_EXCEPTION();
37082   }
37083
37084 }
37085
37086
37087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
37088   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37089   std::string *arg2 = 0 ;
37090   Dali::Toolkit::Builder::UIFormat arg3 ;
37091
37092   arg1 = (Dali::Toolkit::Builder *)jarg1;
37093   if (!jarg2) {
37094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37095     return ;
37096   }
37097   std::string arg2_str(jarg2);
37098   arg2 = &arg2_str;
37099   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
37100   {
37101     try {
37102       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
37103     } CALL_CATCH_EXCEPTION();
37104   }
37105
37106
37107   //argout typemap for const std::string&
37108
37109 }
37110
37111
37112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
37113   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37114   std::string *arg2 = 0 ;
37115
37116   arg1 = (Dali::Toolkit::Builder *)jarg1;
37117   if (!jarg2) {
37118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37119     return ;
37120   }
37121   std::string arg2_str(jarg2);
37122   arg2 = &arg2_str;
37123   {
37124     try {
37125       (arg1)->LoadFromString((std::string const &)*arg2);
37126     } CALL_CATCH_EXCEPTION();
37127   }
37128
37129
37130   //argout typemap for const std::string&
37131
37132 }
37133
37134
37135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
37136   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37137   Dali::Property::Map *arg2 = 0 ;
37138
37139   arg1 = (Dali::Toolkit::Builder *)jarg1;
37140   arg2 = (Dali::Property::Map *)jarg2;
37141   if (!arg2) {
37142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
37143     return ;
37144   }
37145   {
37146     try {
37147       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
37148     } CALL_CATCH_EXCEPTION();
37149   }
37150
37151 }
37152
37153
37154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
37155   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37156   std::string *arg2 = 0 ;
37157   Dali::Property::Value *arg3 = 0 ;
37158
37159   arg1 = (Dali::Toolkit::Builder *)jarg1;
37160   if (!jarg2) {
37161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37162     return ;
37163   }
37164   std::string arg2_str(jarg2);
37165   arg2 = &arg2_str;
37166   arg3 = (Dali::Property::Value *)jarg3;
37167   if (!arg3) {
37168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
37169     return ;
37170   }
37171   {
37172     try {
37173       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
37174     } CALL_CATCH_EXCEPTION();
37175   }
37176
37177
37178   //argout typemap for const std::string&
37179
37180 }
37181
37182
37183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
37184   void * jresult ;
37185   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37186   Dali::Property::Map *result = 0 ;
37187
37188   arg1 = (Dali::Toolkit::Builder *)jarg1;
37189   {
37190     try {
37191       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
37192     } CALL_CATCH_EXCEPTION(0);
37193   }
37194
37195   jresult = (void *)result;
37196   return jresult;
37197 }
37198
37199
37200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
37201   void * jresult ;
37202   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37203   std::string *arg2 = 0 ;
37204   Dali::Property::Value *result = 0 ;
37205
37206   arg1 = (Dali::Toolkit::Builder *)jarg1;
37207   if (!jarg2) {
37208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37209     return 0;
37210   }
37211   std::string arg2_str(jarg2);
37212   arg2 = &arg2_str;
37213   {
37214     try {
37215       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
37216     } CALL_CATCH_EXCEPTION(0);
37217   }
37218
37219   jresult = (void *)result;
37220
37221   //argout typemap for const std::string&
37222
37223   return jresult;
37224 }
37225
37226
37227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
37228   void * jresult ;
37229   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37230   std::string *arg2 = 0 ;
37231   Dali::Animation result;
37232
37233   arg1 = (Dali::Toolkit::Builder *)jarg1;
37234   if (!jarg2) {
37235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37236     return 0;
37237   }
37238   std::string arg2_str(jarg2);
37239   arg2 = &arg2_str;
37240   {
37241     try {
37242       result = (arg1)->CreateAnimation((std::string const &)*arg2);
37243     } CALL_CATCH_EXCEPTION(0);
37244   }
37245
37246   jresult = new Dali::Animation((const Dali::Animation &)result);
37247
37248   //argout typemap for const std::string&
37249
37250   return jresult;
37251 }
37252
37253
37254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
37255   void * jresult ;
37256   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37257   std::string *arg2 = 0 ;
37258   Dali::Property::Map *arg3 = 0 ;
37259   Dali::Animation result;
37260
37261   arg1 = (Dali::Toolkit::Builder *)jarg1;
37262   if (!jarg2) {
37263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37264     return 0;
37265   }
37266   std::string arg2_str(jarg2);
37267   arg2 = &arg2_str;
37268   arg3 = (Dali::Property::Map *)jarg3;
37269   if (!arg3) {
37270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
37271     return 0;
37272   }
37273   {
37274     try {
37275       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
37276     } CALL_CATCH_EXCEPTION(0);
37277   }
37278
37279   jresult = new Dali::Animation((const Dali::Animation &)result);
37280
37281   //argout typemap for const std::string&
37282
37283   return jresult;
37284 }
37285
37286
37287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
37288   void * jresult ;
37289   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37290   std::string *arg2 = 0 ;
37291   Dali::Actor arg3 ;
37292   Dali::Actor *argp3 ;
37293   Dali::Animation result;
37294
37295   arg1 = (Dali::Toolkit::Builder *)jarg1;
37296   if (!jarg2) {
37297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37298     return 0;
37299   }
37300   std::string arg2_str(jarg2);
37301   arg2 = &arg2_str;
37302   argp3 = (Dali::Actor *)jarg3;
37303   if (!argp3) {
37304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37305     return 0;
37306   }
37307   arg3 = *argp3;
37308   {
37309     try {
37310       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
37311     } CALL_CATCH_EXCEPTION(0);
37312   }
37313
37314   jresult = new Dali::Animation((const Dali::Animation &)result);
37315
37316   //argout typemap for const std::string&
37317
37318   return jresult;
37319 }
37320
37321
37322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
37323   void * jresult ;
37324   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37325   std::string *arg2 = 0 ;
37326   Dali::Property::Map *arg3 = 0 ;
37327   Dali::Actor arg4 ;
37328   Dali::Actor *argp4 ;
37329   Dali::Animation result;
37330
37331   arg1 = (Dali::Toolkit::Builder *)jarg1;
37332   if (!jarg2) {
37333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37334     return 0;
37335   }
37336   std::string arg2_str(jarg2);
37337   arg2 = &arg2_str;
37338   arg3 = (Dali::Property::Map *)jarg3;
37339   if (!arg3) {
37340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
37341     return 0;
37342   }
37343   argp4 = (Dali::Actor *)jarg4;
37344   if (!argp4) {
37345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37346     return 0;
37347   }
37348   arg4 = *argp4;
37349   {
37350     try {
37351       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
37352     } CALL_CATCH_EXCEPTION(0);
37353   }
37354
37355   jresult = new Dali::Animation((const Dali::Animation &)result);
37356
37357   //argout typemap for const std::string&
37358
37359   return jresult;
37360 }
37361
37362
37363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
37364   void * jresult ;
37365   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37366   std::string *arg2 = 0 ;
37367   Dali::BaseHandle result;
37368
37369   arg1 = (Dali::Toolkit::Builder *)jarg1;
37370   if (!jarg2) {
37371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37372     return 0;
37373   }
37374   std::string arg2_str(jarg2);
37375   arg2 = &arg2_str;
37376   {
37377     try {
37378       result = (arg1)->Create((std::string const &)*arg2);
37379     } CALL_CATCH_EXCEPTION(0);
37380   }
37381
37382   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
37383
37384   //argout typemap for const std::string&
37385
37386   return jresult;
37387 }
37388
37389
37390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
37391   void * jresult ;
37392   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37393   std::string *arg2 = 0 ;
37394   Dali::Property::Map *arg3 = 0 ;
37395   Dali::BaseHandle result;
37396
37397   arg1 = (Dali::Toolkit::Builder *)jarg1;
37398   if (!jarg2) {
37399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37400     return 0;
37401   }
37402   std::string arg2_str(jarg2);
37403   arg2 = &arg2_str;
37404   arg3 = (Dali::Property::Map *)jarg3;
37405   if (!arg3) {
37406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
37407     return 0;
37408   }
37409   {
37410     try {
37411       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
37412     } CALL_CATCH_EXCEPTION(0);
37413   }
37414
37415   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
37416
37417   //argout typemap for const std::string&
37418
37419   return jresult;
37420 }
37421
37422
37423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
37424   void * jresult ;
37425   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37426   std::string *arg2 = 0 ;
37427   Dali::BaseHandle result;
37428
37429   arg1 = (Dali::Toolkit::Builder *)jarg1;
37430   if (!jarg2) {
37431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37432     return 0;
37433   }
37434   std::string arg2_str(jarg2);
37435   arg2 = &arg2_str;
37436   {
37437     try {
37438       result = (arg1)->CreateFromJson((std::string const &)*arg2);
37439     } CALL_CATCH_EXCEPTION(0);
37440   }
37441
37442   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
37443
37444   //argout typemap for const std::string&
37445
37446   return jresult;
37447 }
37448
37449
37450 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
37451   bool jresult ;
37452   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37453   std::string *arg2 = 0 ;
37454   Dali::Handle *arg3 = 0 ;
37455   bool result;
37456
37457   arg1 = (Dali::Toolkit::Builder *)jarg1;
37458   if (!jarg2) {
37459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37460     return 0;
37461   }
37462   std::string arg2_str(jarg2);
37463   arg2 = &arg2_str;
37464   arg3 = (Dali::Handle *)jarg3;
37465   if (!arg3) {
37466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
37467     return 0;
37468   }
37469   {
37470     try {
37471       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
37472     } CALL_CATCH_EXCEPTION(0);
37473   }
37474
37475   jresult = result;
37476
37477   //argout typemap for const std::string&
37478
37479   return jresult;
37480 }
37481
37482
37483 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
37484   bool jresult ;
37485   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37486   Dali::Handle *arg2 = 0 ;
37487   std::string *arg3 = 0 ;
37488   bool result;
37489
37490   arg1 = (Dali::Toolkit::Builder *)jarg1;
37491   arg2 = (Dali::Handle *)jarg2;
37492   if (!arg2) {
37493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
37494     return 0;
37495   }
37496   if (!jarg3) {
37497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37498     return 0;
37499   }
37500   std::string arg3_str(jarg3);
37501   arg3 = &arg3_str;
37502   {
37503     try {
37504       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
37505     } CALL_CATCH_EXCEPTION(0);
37506   }
37507
37508   jresult = result;
37509
37510   //argout typemap for const std::string&
37511
37512   return jresult;
37513 }
37514
37515
37516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
37517   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37518   Dali::Actor arg2 ;
37519   Dali::Actor *argp2 ;
37520
37521   arg1 = (Dali::Toolkit::Builder *)jarg1;
37522   argp2 = (Dali::Actor *)jarg2;
37523   if (!argp2) {
37524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37525     return ;
37526   }
37527   arg2 = *argp2;
37528   {
37529     try {
37530       (arg1)->AddActors(arg2);
37531     } CALL_CATCH_EXCEPTION();
37532   }
37533
37534 }
37535
37536
37537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
37538   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37539   std::string *arg2 = 0 ;
37540   Dali::Actor arg3 ;
37541   Dali::Actor *argp3 ;
37542
37543   arg1 = (Dali::Toolkit::Builder *)jarg1;
37544   if (!jarg2) {
37545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37546     return ;
37547   }
37548   std::string arg2_str(jarg2);
37549   arg2 = &arg2_str;
37550   argp3 = (Dali::Actor *)jarg3;
37551   if (!argp3) {
37552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37553     return ;
37554   }
37555   arg3 = *argp3;
37556   {
37557     try {
37558       (arg1)->AddActors((std::string const &)*arg2,arg3);
37559     } CALL_CATCH_EXCEPTION();
37560   }
37561
37562
37563   //argout typemap for const std::string&
37564
37565 }
37566
37567
37568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
37569   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37570   std::string *arg2 = 0 ;
37571
37572   arg1 = (Dali::Toolkit::Builder *)jarg1;
37573   if (!jarg2) {
37574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37575     return ;
37576   }
37577   std::string arg2_str(jarg2);
37578   arg2 = &arg2_str;
37579   {
37580     try {
37581       (arg1)->CreateRenderTask((std::string const &)*arg2);
37582     } CALL_CATCH_EXCEPTION();
37583   }
37584
37585
37586   //argout typemap for const std::string&
37587
37588 }
37589
37590
37591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
37592   void * jresult ;
37593   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37594   std::string *arg2 = 0 ;
37595   Dali::Path result;
37596
37597   arg1 = (Dali::Toolkit::Builder *)jarg1;
37598   if (!jarg2) {
37599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37600     return 0;
37601   }
37602   std::string arg2_str(jarg2);
37603   arg2 = &arg2_str;
37604   {
37605     try {
37606       result = (arg1)->GetPath((std::string const &)*arg2);
37607     } CALL_CATCH_EXCEPTION(0);
37608   }
37609
37610   jresult = new Dali::Path((const Dali::Path &)result);
37611
37612   //argout typemap for const std::string&
37613
37614   return jresult;
37615 }
37616
37617
37618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
37619   void * jresult ;
37620   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37621   std::string *arg2 = 0 ;
37622   Dali::PathConstrainer result;
37623
37624   arg1 = (Dali::Toolkit::Builder *)jarg1;
37625   if (!jarg2) {
37626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37627     return 0;
37628   }
37629   std::string arg2_str(jarg2);
37630   arg2 = &arg2_str;
37631   {
37632     try {
37633       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
37634     } CALL_CATCH_EXCEPTION(0);
37635   }
37636
37637   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
37638
37639   //argout typemap for const std::string&
37640
37641   return jresult;
37642 }
37643
37644
37645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
37646   void * jresult ;
37647   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37648   std::string *arg2 = 0 ;
37649   Dali::LinearConstrainer result;
37650
37651   arg1 = (Dali::Toolkit::Builder *)jarg1;
37652   if (!jarg2) {
37653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37654     return 0;
37655   }
37656   std::string arg2_str(jarg2);
37657   arg2 = &arg2_str;
37658   {
37659     try {
37660       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
37661     } CALL_CATCH_EXCEPTION(0);
37662   }
37663
37664   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
37665
37666   //argout typemap for const std::string&
37667
37668   return jresult;
37669 }
37670
37671
37672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
37673   void * jresult ;
37674   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
37675   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
37676
37677   arg1 = (Dali::Toolkit::Builder *)jarg1;
37678   {
37679     try {
37680       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
37681     } CALL_CATCH_EXCEPTION(0);
37682   }
37683
37684   jresult = (void *)result;
37685   return jresult;
37686 }
37687
37688
37689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
37690   void * jresult ;
37691   Dali::Toolkit::TransitionData *result = 0 ;
37692
37693   {
37694     try {
37695       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
37696     } CALL_CATCH_EXCEPTION(0);
37697   }
37698
37699   jresult = (void *)result;
37700   return jresult;
37701 }
37702
37703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
37704   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
37705
37706   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
37707   {
37708     try {
37709       delete arg1;
37710     } CALL_CATCH_EXCEPTION();
37711   }
37712
37713 }
37714
37715
37716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
37717   void * jresult ;
37718   Dali::Property::Map *arg1 = 0 ;
37719   Dali::Toolkit::TransitionData result;
37720
37721   arg1 = (Dali::Property::Map *)jarg1;
37722   if (!arg1) {
37723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
37724     return 0;
37725   }
37726   {
37727     try {
37728       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
37729     } CALL_CATCH_EXCEPTION(0);
37730   }
37731
37732   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
37733   return jresult;
37734 }
37735
37736
37737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
37738   void * jresult ;
37739   Dali::Property::Array *arg1 = 0 ;
37740   Dali::Toolkit::TransitionData result;
37741
37742   arg1 = (Dali::Property::Array *)jarg1;
37743   if (!arg1) {
37744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
37745     return 0;
37746   }
37747   {
37748     try {
37749       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
37750     } CALL_CATCH_EXCEPTION(0);
37751   }
37752
37753   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
37754   return jresult;
37755 }
37756
37757
37758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
37759   void * jresult ;
37760   Dali::BaseHandle arg1 ;
37761   Dali::BaseHandle *argp1 ;
37762   Dali::Toolkit::TransitionData result;
37763
37764   argp1 = (Dali::BaseHandle *)jarg1;
37765   if (!argp1) {
37766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37767     return 0;
37768   }
37769   arg1 = *argp1;
37770   {
37771     try {
37772       result = Dali::Toolkit::TransitionData::DownCast(arg1);
37773     } CALL_CATCH_EXCEPTION(0);
37774   }
37775
37776   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
37777   return jresult;
37778 }
37779
37780
37781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
37782   void * jresult ;
37783   Dali::Toolkit::TransitionData *arg1 = 0 ;
37784   Dali::Toolkit::TransitionData *result = 0 ;
37785
37786   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
37787   if (!arg1) {
37788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
37789     return 0;
37790   }
37791   {
37792     try {
37793       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
37794     } CALL_CATCH_EXCEPTION(0);
37795   }
37796
37797   jresult = (void *)result;
37798   return jresult;
37799 }
37800
37801
37802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
37803   void * jresult ;
37804   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
37805   Dali::Toolkit::TransitionData *arg2 = 0 ;
37806   Dali::Toolkit::TransitionData *result = 0 ;
37807
37808   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
37809   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
37810   if (!arg2) {
37811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
37812     return 0;
37813   }
37814   {
37815     try {
37816       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
37817     } CALL_CATCH_EXCEPTION(0);
37818   }
37819
37820   jresult = (void *)result;
37821   return jresult;
37822 }
37823
37824
37825 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
37826   unsigned long jresult ;
37827   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
37828   size_t result;
37829
37830   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
37831   {
37832     try {
37833       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
37834     } CALL_CATCH_EXCEPTION(0);
37835   }
37836
37837   jresult = (unsigned long)result;
37838   return jresult;
37839 }
37840
37841
37842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
37843   void * jresult ;
37844   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
37845   size_t arg2 ;
37846   Dali::Property::Map result;
37847
37848   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
37849   arg2 = (size_t)jarg2;
37850   {
37851     try {
37852       result = (arg1)->GetAnimatorAt(arg2);
37853     } CALL_CATCH_EXCEPTION(0);
37854   }
37855
37856   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
37857   return jresult;
37858 }
37859
37860
37861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
37862   int jresult ;
37863   int result;
37864
37865   {
37866     try {
37867       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
37868     } CALL_CATCH_EXCEPTION(0);
37869   }
37870
37871   jresult = (int)result;
37872   return jresult;
37873 }
37874
37875
37876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
37877   int jresult ;
37878   int result;
37879
37880   {
37881     try {
37882       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
37883     } CALL_CATCH_EXCEPTION(0);
37884   }
37885
37886   jresult = (int)result;
37887   return jresult;
37888 }
37889
37890
37891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
37892   int jresult ;
37893   int result;
37894
37895   {
37896     try {
37897       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
37898     } CALL_CATCH_EXCEPTION(0);
37899   }
37900
37901   jresult = (int)result;
37902   return jresult;
37903 }
37904
37905
37906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
37907   int jresult ;
37908   int result;
37909
37910   {
37911     try {
37912       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
37913     } CALL_CATCH_EXCEPTION(0);
37914   }
37915
37916   jresult = (int)result;
37917   return jresult;
37918 }
37919
37920
37921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
37922   int jresult ;
37923   int result;
37924
37925   {
37926     try {
37927       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
37928     } CALL_CATCH_EXCEPTION(0);
37929   }
37930
37931   jresult = (int)result;
37932   return jresult;
37933 }
37934
37935
37936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
37937   int jresult ;
37938   int result;
37939
37940   {
37941     try {
37942       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
37943     } CALL_CATCH_EXCEPTION(0);
37944   }
37945
37946   jresult = (int)result;
37947   return jresult;
37948 }
37949
37950
37951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
37952   int jresult ;
37953   int result;
37954
37955   {
37956     try {
37957       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
37958     } CALL_CATCH_EXCEPTION(0);
37959   }
37960
37961   jresult = (int)result;
37962   return jresult;
37963 }
37964
37965
37966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
37967   int jresult ;
37968   int result;
37969
37970   {
37971     try {
37972       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
37973     } CALL_CATCH_EXCEPTION(0);
37974   }
37975
37976   jresult = (int)result;
37977   return jresult;
37978 }
37979
37980
37981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
37982   int jresult ;
37983   int result;
37984
37985   {
37986     try {
37987       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
37988     } CALL_CATCH_EXCEPTION(0);
37989   }
37990
37991   jresult = (int)result;
37992   return jresult;
37993 }
37994
37995
37996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
37997   int jresult ;
37998   int result;
37999
38000   {
38001     try {
38002       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
38003     } CALL_CATCH_EXCEPTION(0);
38004   }
38005
38006   jresult = (int)result;
38007   return jresult;
38008 }
38009
38010
38011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
38012   int jresult ;
38013   int result;
38014
38015   {
38016     try {
38017       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
38018     } CALL_CATCH_EXCEPTION(0);
38019   }
38020
38021   jresult = (int)result;
38022   return jresult;
38023 }
38024
38025
38026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
38027   int jresult ;
38028   int result;
38029
38030   {
38031     try {
38032       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
38033     } CALL_CATCH_EXCEPTION(0);
38034   }
38035
38036   jresult = (int)result;
38037   return jresult;
38038 }
38039
38040
38041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
38042   int jresult ;
38043   int result;
38044
38045   {
38046     try {
38047       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
38048     } CALL_CATCH_EXCEPTION(0);
38049   }
38050
38051   jresult = (int)result;
38052   return jresult;
38053 }
38054
38055
38056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
38057   int jresult ;
38058   int result;
38059
38060   {
38061     try {
38062       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
38063     } CALL_CATCH_EXCEPTION(0);
38064   }
38065
38066   jresult = (int)result;
38067   return jresult;
38068 }
38069
38070
38071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
38072   void * jresult ;
38073   Dali::Toolkit::Control result;
38074
38075   {
38076     try {
38077       result = Dali::Toolkit::Internal::Control::New(Dali::Toolkit::Internal::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
38078     } CALL_CATCH_EXCEPTION(0);
38079   }
38080
38081   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
38082   return jresult;
38083 }
38084
38085
38086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
38087   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38088   std::string *arg2 = 0 ;
38089
38090   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38091   if (!jarg2) {
38092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
38093     return ;
38094   }
38095   std::string arg2_str(jarg2);
38096   arg2 = &arg2_str;
38097   {
38098     try {
38099       (arg1)->SetStyleName((std::string const &)*arg2);
38100     } CALL_CATCH_EXCEPTION();
38101   }
38102
38103
38104   //argout typemap for const std::string&
38105
38106 }
38107
38108
38109 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
38110   char * jresult ;
38111   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38112   std::string *result = 0 ;
38113
38114   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38115   {
38116     try {
38117       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
38118     } CALL_CATCH_EXCEPTION(0);
38119   }
38120
38121   jresult = SWIG_csharp_string_callback(result->c_str());
38122   return jresult;
38123 }
38124
38125
38126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
38127   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38128   Dali::Vector4 *arg2 = 0 ;
38129
38130   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38131   arg2 = (Dali::Vector4 *)jarg2;
38132   if (!arg2) {
38133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
38134     return ;
38135   }
38136   {
38137     try {
38138       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
38139     } CALL_CATCH_EXCEPTION();
38140   }
38141
38142 }
38143
38144
38145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
38146   void * jresult ;
38147   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
38148   Dali::Vector4 result;
38149
38150   arg1 = (Dali::Handle *)jarg1;
38151   {
38152     try {
38153       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
38154       if (resultMap)
38155       {
38156         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
38157         if(type && type->Get<int>() == Visual::COLOR )
38158         {
38159           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
38160           if (value)
38161           {
38162             result = value->Get<Vector4>();
38163           }
38164         }
38165       }
38166     } CALL_CATCH_EXCEPTION(0);
38167   }
38168
38169   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38170   return jresult;
38171 }
38172
38173
38174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
38175   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38176   Dali::Property::Map *arg2 = 0 ;
38177
38178   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38179   arg2 = (Dali::Property::Map *)jarg2;
38180   if (!arg2) {
38181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
38182     return ;
38183   }
38184   {
38185     try {
38186       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
38187     } CALL_CATCH_EXCEPTION();
38188   }
38189
38190 }
38191
38192
38193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
38194   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38195
38196   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38197   {
38198     try {
38199       (arg1)->ClearBackground();
38200     } CALL_CATCH_EXCEPTION();
38201   }
38202
38203 }
38204
38205
38206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
38207   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38208   Dali::GestureType::Value arg2 ;
38209
38210   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38211   arg2 = (Dali::GestureType::Value)jarg2;
38212   {
38213     try {
38214       (arg1)->EnableGestureDetection(arg2);
38215     } CALL_CATCH_EXCEPTION();
38216   }
38217
38218 }
38219
38220
38221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
38222   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38223   Dali::GestureType::Value arg2 ;
38224
38225   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38226   arg2 = (Dali::GestureType::Value)jarg2;
38227   {
38228     try {
38229       (arg1)->DisableGestureDetection(arg2);
38230     } CALL_CATCH_EXCEPTION();
38231   }
38232
38233 }
38234
38235
38236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
38237   void * jresult ;
38238   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38239   Dali::PinchGestureDetector result;
38240
38241   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38242   {
38243     try {
38244       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
38245     } CALL_CATCH_EXCEPTION(0);
38246   }
38247
38248   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
38249   return jresult;
38250 }
38251
38252
38253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
38254   void * jresult ;
38255   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38256   Dali::PanGestureDetector result;
38257
38258   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38259   {
38260     try {
38261       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
38262     } CALL_CATCH_EXCEPTION(0);
38263   }
38264
38265   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
38266   return jresult;
38267 }
38268
38269
38270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
38271   void * jresult ;
38272   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38273   Dali::TapGestureDetector result;
38274
38275   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38276   {
38277     try {
38278       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
38279     } CALL_CATCH_EXCEPTION(0);
38280   }
38281
38282   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
38283   return jresult;
38284 }
38285
38286
38287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
38288   void * jresult ;
38289   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38290   Dali::LongPressGestureDetector result;
38291
38292   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38293   {
38294     try {
38295       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
38296     } CALL_CATCH_EXCEPTION(0);
38297   }
38298
38299   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
38300   return jresult;
38301 }
38302
38303
38304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, bool jarg2) {
38305   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38306   bool arg2 ;
38307
38308   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38309   arg2 = jarg2 ? true : false;
38310   {
38311     try {
38312       (arg1)->SetKeyboardNavigationSupport(arg2);
38313     } CALL_CATCH_EXCEPTION();
38314   }
38315
38316 }
38317
38318
38319 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
38320   bool jresult ;
38321   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38322   bool result;
38323
38324   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38325   {
38326     try {
38327       result = (bool)(arg1)->IsKeyboardNavigationSupported();
38328     } CALL_CATCH_EXCEPTION(0);
38329   }
38330
38331   jresult = result;
38332   return jresult;
38333 }
38334
38335
38336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
38337   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38338
38339   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38340   {
38341     try {
38342       (arg1)->SetKeyInputFocus();
38343     } CALL_CATCH_EXCEPTION();
38344   }
38345
38346 }
38347
38348
38349 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
38350   bool jresult ;
38351   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38352   bool result;
38353
38354   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38355   {
38356     try {
38357       result = (bool)(arg1)->HasKeyInputFocus();
38358     } CALL_CATCH_EXCEPTION(0);
38359   }
38360
38361   jresult = result;
38362   return jresult;
38363 }
38364
38365
38366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
38367   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38368
38369   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38370   {
38371     try {
38372       (arg1)->ClearKeyInputFocus();
38373     } CALL_CATCH_EXCEPTION();
38374   }
38375
38376 }
38377
38378
38379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, bool jarg2) {
38380   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38381   bool arg2 ;
38382
38383   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38384   arg2 = jarg2 ? true : false;
38385   {
38386     try {
38387       (arg1)->SetAsKeyboardFocusGroup(arg2);
38388     } CALL_CATCH_EXCEPTION();
38389   }
38390
38391 }
38392
38393
38394 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
38395   bool jresult ;
38396   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38397   bool result;
38398
38399   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38400   {
38401     try {
38402       result = (bool)(arg1)->IsKeyboardFocusGroup();
38403     } CALL_CATCH_EXCEPTION(0);
38404   }
38405
38406   jresult = result;
38407   return jresult;
38408 }
38409
38410
38411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
38412   void * jresult ;
38413   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38414   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
38415
38416   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38417   {
38418     try {
38419       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38420     } CALL_CATCH_EXCEPTION(0);
38421   }
38422
38423   jresult = (void *)result;
38424   return jresult;
38425 }
38426
38427
38428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
38429   void * jresult ;
38430   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38431   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
38432
38433   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38434   {
38435     try {
38436       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
38437     } CALL_CATCH_EXCEPTION(0);
38438   }
38439
38440   jresult = (void *)result;
38441   return jresult;
38442 }
38443
38444
38445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
38446   void * jresult ;
38447   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38448   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
38449
38450   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38451   {
38452     try {
38453       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
38454     } CALL_CATCH_EXCEPTION(0);
38455   }
38456
38457   jresult = (void *)result;
38458   return jresult;
38459 }
38460
38461
38462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnection(void * jarg1, int jarg2) {
38463   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38464   int arg2 ;
38465   SwigDirector_ViewImpl *darg = 0;
38466
38467   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38468   arg2 = (int)jarg2;
38469   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38470   if(!darg) {
38471     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38472     return;
38473   }
38474   {
38475     try {
38476       if(darg) {
38477         (darg)->OnSceneConnection(arg2);
38478       }
38479     } CALL_CATCH_EXCEPTION();
38480   }
38481
38482 }
38483
38484
38485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
38486   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38487   int arg2 ;
38488   SwigDirector_ViewImpl *darg = 0;
38489
38490   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38491   arg2 = (int)jarg2;
38492   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38493   if(!darg) {
38494     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38495     return;
38496   }
38497   {
38498     try {
38499       if(darg) {
38500         (darg)->OnSceneConnectionSwigPublic(arg2);
38501       }
38502     } CALL_CATCH_EXCEPTION();
38503   }
38504
38505 }
38506
38507
38508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnection(void * jarg1) {
38509   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38510   SwigDirector_ViewImpl *darg = 0;
38511
38512   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38513   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38514   if(!darg) {
38515     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38516     return;
38517   }
38518   {
38519     try {
38520       if(darg) {
38521         (darg)->OnSceneDisconnection();
38522       }
38523     } CALL_CATCH_EXCEPTION();
38524   }
38525
38526 }
38527
38528
38529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnectionSwigExplicitViewImpl(void * jarg1) {
38530   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38531   SwigDirector_ViewImpl *darg = 0;
38532
38533   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38534   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38535   if(!darg) {
38536     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38537     return;
38538   }
38539   {
38540     try {
38541       if(darg) {
38542         (darg)->OnSceneDisconnectionSwigPublic();
38543       }
38544     } CALL_CATCH_EXCEPTION();
38545   }
38546
38547 }
38548
38549
38550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
38551   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38552   Dali::Actor *arg2 = 0 ;
38553   SwigDirector_ViewImpl *darg = 0;
38554
38555   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38556   arg2 = (Dali::Actor *)jarg2;
38557   if (!arg2) {
38558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38559     return ;
38560   }
38561   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38562   if(!darg) {
38563     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38564     return;
38565   }
38566   {
38567     try {
38568       if(darg) {
38569         (darg)->OnChildAdd(*arg2);
38570       }
38571     } CALL_CATCH_EXCEPTION();
38572   }
38573
38574 }
38575
38576
38577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
38578   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38579   Dali::Actor *arg2 = 0 ;
38580   SwigDirector_ViewImpl *darg = 0;
38581
38582   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38583   arg2 = (Dali::Actor *)jarg2;
38584   if (!arg2) {
38585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38586     return ;
38587   }
38588   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38589   if(!darg) {
38590     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38591     return;
38592   }
38593   {
38594     try {
38595       if(darg) {
38596           (darg)->OnChildAddSwigPublic(*arg2);
38597       }
38598     } CALL_CATCH_EXCEPTION();
38599   }
38600
38601 }
38602
38603
38604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
38605   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38606   Dali::Actor *arg2 = 0 ;
38607   SwigDirector_ViewImpl *darg = 0;
38608
38609   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38610   arg2 = (Dali::Actor *)jarg2;
38611   if (!arg2) {
38612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38613     return ;
38614   }
38615   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38616   if(!darg) {
38617     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38618     return;
38619   }
38620   {
38621     try {
38622       if(darg) {
38623         (darg)->OnChildRemove(*arg2);
38624       }
38625     } CALL_CATCH_EXCEPTION();
38626   }
38627
38628 }
38629
38630
38631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
38632   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38633   Dali::Actor *arg2 = 0 ;
38634   SwigDirector_ViewImpl *darg = 0;
38635
38636   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38637   arg2 = (Dali::Actor *)jarg2;
38638   if (!arg2) {
38639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38640     return ;
38641   }
38642   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38643   if(!darg) {
38644     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38645     return;
38646   }
38647   {
38648     try {
38649       if(darg) {
38650         (darg)->OnChildRemoveSwigPublic(*arg2);
38651       }
38652     } CALL_CATCH_EXCEPTION();
38653   }
38654
38655 }
38656
38657
38658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
38659   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38660   Dali::Property::Index arg2 ;
38661   Dali::Property::Value arg3 ;
38662   Dali::Property::Value *argp3 ;
38663   SwigDirector_ViewImpl *darg = 0;
38664
38665   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38666   arg2 = (Dali::Property::Index)jarg2;
38667   argp3 = (Dali::Property::Value *)jarg3;
38668   if (!argp3) {
38669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
38670     return ;
38671   }
38672   arg3 = *argp3;
38673   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38674   if (!darg) {
38675     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38676     return;
38677   }
38678   {
38679     try {
38680       (darg)->OnPropertySet(arg2,arg3);
38681     } CALL_CATCH_EXCEPTION();
38682   }
38683
38684 }
38685
38686
38687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
38688   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38689   Dali::Vector3 *arg2 = 0 ;
38690   SwigDirector_ViewImpl *darg = 0;
38691
38692   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38693   arg2 = (Dali::Vector3 *)jarg2;
38694   if (!arg2) {
38695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38696     return ;
38697   }
38698   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38699   if (!darg) {
38700     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38701     return;
38702   }
38703   {
38704     try {
38705       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
38706     } CALL_CATCH_EXCEPTION();
38707   }
38708
38709 }
38710
38711
38712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
38713   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38714   Dali::Vector3 *arg2 = 0 ;
38715   SwigDirector_ViewImpl *darg = 0;
38716
38717   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38718   arg2 = (Dali::Vector3 *)jarg2;
38719   if (!arg2) {
38720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38721     return ;
38722   }
38723   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38724   if (!darg) {
38725     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38726     return;
38727   }
38728   {
38729     try {
38730       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
38731     } CALL_CATCH_EXCEPTION();
38732   }
38733
38734 }
38735
38736
38737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
38738   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38739   Dali::Animation *arg2 = 0 ;
38740   Dali::Vector3 *arg3 = 0 ;
38741   SwigDirector_ViewImpl *darg = 0;
38742
38743   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38744   arg2 = (Dali::Animation *)jarg2;
38745   if (!arg2) {
38746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
38747     return ;
38748   }
38749   arg3 = (Dali::Vector3 *)jarg3;
38750   if (!arg3) {
38751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38752     return ;
38753   }
38754   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38755   if (!darg) {
38756     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38757     return;
38758   }
38759   {
38760     try {
38761       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
38762     } CALL_CATCH_EXCEPTION();
38763   }
38764
38765 }
38766
38767
38768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
38769   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38770   Dali::Animation *arg2 = 0 ;
38771   Dali::Vector3 *arg3 = 0 ;
38772   SwigDirector_ViewImpl *darg = 0;
38773
38774   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38775   arg2 = (Dali::Animation *)jarg2;
38776   if (!arg2) {
38777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
38778     return ;
38779   }
38780   arg3 = (Dali::Vector3 *)jarg3;
38781   if (!arg3) {
38782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38783     return ;
38784   }
38785   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38786   if (!darg) {
38787     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38788     return;
38789   }
38790   {
38791     try {
38792       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
38793     } CALL_CATCH_EXCEPTION();
38794   }
38795 }
38796
38797 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
38798   bool jresult ;
38799   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38800   Dali::KeyEvent *arg2 = 0 ;
38801   SwigDirector_ViewImpl *darg = 0;
38802   bool result;
38803
38804   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38805   arg2 = (Dali::KeyEvent *)jarg2;
38806   if (!arg2) {
38807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
38808     return 0;
38809   }
38810   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38811   if (!darg) {
38812     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38813     return 0;
38814   }
38815   {
38816     try {
38817       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
38818     } CALL_CATCH_EXCEPTION(0);
38819   }
38820
38821   jresult = result;
38822   return jresult;
38823 }
38824
38825
38826 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
38827   bool jresult ;
38828   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38829   Dali::KeyEvent *arg2 = 0 ;
38830   SwigDirector_ViewImpl *darg = 0;
38831   bool result;
38832
38833   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38834   arg2 = (Dali::KeyEvent *)jarg2;
38835   if (!arg2) {
38836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
38837     return 0;
38838   }
38839   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38840   if (!darg) {
38841     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38842     return 0;
38843   }
38844   {
38845     try {
38846       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
38847     } CALL_CATCH_EXCEPTION(0);
38848   }
38849
38850   jresult = result;
38851   return jresult;
38852 }
38853
38854
38855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
38856   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38857   Dali::Vector2 *arg2 = 0 ;
38858   Dali::RelayoutContainer *arg3 = 0 ;
38859   SwigDirector_ViewImpl *darg = 0;
38860
38861   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38862   arg2 = (Dali::Vector2 *)jarg2;
38863   if (!arg2) {
38864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38865     return ;
38866   }
38867   arg3 = (Dali::RelayoutContainer *)jarg3;
38868   if (!arg3) {
38869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
38870     return ;
38871   }
38872   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38873   if (!darg) {
38874     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38875     return;
38876   }
38877   {
38878     try {
38879       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
38880     } CALL_CATCH_EXCEPTION();
38881   }
38882
38883 }
38884
38885
38886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
38887   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38888   Dali::Vector2 *arg2 = 0 ;
38889   Dali::RelayoutContainer *arg3 = 0 ;
38890   SwigDirector_ViewImpl *darg = 0;
38891
38892   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38893   arg2 = (Dali::Vector2 *)jarg2;
38894   if (!arg2) {
38895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38896     return ;
38897   }
38898   arg3 = (Dali::RelayoutContainer *)jarg3;
38899   if (!arg3) {
38900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
38901     return ;
38902   }
38903   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38904   if (!darg) {
38905     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38906     return;
38907   }
38908   {
38909     try {
38910       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
38911     } CALL_CATCH_EXCEPTION();
38912   }
38913
38914 }
38915
38916
38917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
38918   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38919   Dali::ResizePolicy::Type arg2 ;
38920   Dali::Dimension::Type arg3 ;
38921   SwigDirector_ViewImpl *darg = 0;
38922
38923   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38924   arg2 = (Dali::ResizePolicy::Type)jarg2;
38925   arg3 = (Dali::Dimension::Type)jarg3;
38926   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38927   if (!darg) {
38928     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38929     return;
38930   }
38931   {
38932     try {
38933       (darg)->OnSetResizePolicy(arg2,arg3);
38934     } CALL_CATCH_EXCEPTION();
38935   }
38936
38937 }
38938
38939
38940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
38941   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38942   Dali::ResizePolicy::Type arg2 ;
38943   Dali::Dimension::Type arg3 ;
38944   SwigDirector_ViewImpl *darg = 0;
38945
38946   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38947   arg2 = (Dali::ResizePolicy::Type)jarg2;
38948   arg3 = (Dali::Dimension::Type)jarg3;
38949   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38950   if (!darg) {
38951     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38952     return;
38953   }
38954   {
38955     try {
38956       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
38957     } CALL_CATCH_EXCEPTION();
38958   }
38959
38960 }
38961
38962
38963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
38964   void * jresult ;
38965   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38966   SwigDirector_ViewImpl *darg = 0;
38967   Dali::Vector3 result;
38968
38969   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38970   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38971   if (!darg) {
38972     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38973     return 0;
38974   }
38975   {
38976     try {
38977       result = (darg)->GetNaturalSize();
38978     } CALL_CATCH_EXCEPTION(0);
38979   }
38980
38981   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
38982   return jresult;
38983 }
38984
38985
38986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
38987   void * jresult ;
38988   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38989   SwigDirector_ViewImpl *darg = 0;
38990   Dali::Vector3 result;
38991
38992   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38993   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
38994   if (!darg) {
38995     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
38996     return 0;
38997   }
38998   {
38999     try {
39000       result = (darg)->GetNaturalSizeSwigPublic();
39001     } CALL_CATCH_EXCEPTION(0);
39002   }
39003
39004   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39005   return jresult;
39006 }
39007
39008
39009 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39010   float jresult ;
39011   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39012   Dali::Actor *arg2 = 0 ;
39013   Dali::Dimension::Type arg3 ;
39014   SwigDirector_ViewImpl *darg = 0;
39015   float result;
39016
39017   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39018   arg2 = (Dali::Actor *)jarg2;
39019   if (!arg2) {
39020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39021     return 0;
39022   }
39023   arg3 = (Dali::Dimension::Type)jarg3;
39024   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
39025   if (!darg) {
39026     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
39027     return 0;
39028   }
39029   {
39030     try {
39031       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39032     } CALL_CATCH_EXCEPTION(0);
39033   }
39034
39035   jresult = result;
39036   return jresult;
39037 }
39038
39039
39040 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
39041   float jresult ;
39042   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39043   Dali::Actor *arg2 = 0 ;
39044   Dali::Dimension::Type arg3 ;
39045   SwigDirector_ViewImpl *darg = 0;
39046   float result;
39047
39048   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39049   arg2 = (Dali::Actor *)jarg2;
39050   if (!arg2) {
39051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39052     return 0;
39053   }
39054   arg3 = (Dali::Dimension::Type)jarg3;
39055   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
39056   if (!darg) {
39057     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
39058     return 0;
39059   }
39060   {
39061     try {
39062       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
39063     } CALL_CATCH_EXCEPTION(0);
39064   }
39065
39066   jresult = result;
39067   return jresult;
39068 }
39069
39070
39071 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39072   float jresult ;
39073   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39074   float arg2 ;
39075   SwigDirector_ViewImpl *darg = 0;
39076   float result;
39077
39078   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39079   arg2 = (float)jarg2;
39080   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
39081   if (!darg) {
39082     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
39083     return 0;
39084   }
39085   {
39086     try {
39087       result = (float)(darg)->GetHeightForWidth(arg2);
39088     } CALL_CATCH_EXCEPTION(0);
39089   }
39090
39091   jresult = result;
39092   return jresult;
39093 }
39094
39095
39096 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
39097   float jresult ;
39098   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39099   float arg2 ;
39100   SwigDirector_ViewImpl *darg = 0;
39101   float result;
39102
39103   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39104   arg2 = (float)jarg2;
39105   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
39106   if (!darg) {
39107     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
39108     return 0;
39109   }
39110   {
39111     try {
39112       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
39113     } CALL_CATCH_EXCEPTION(0);
39114   }
39115
39116   jresult = result;
39117   return jresult;
39118 }
39119
39120
39121 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39122   float jresult ;
39123   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39124   float arg2 ;
39125   SwigDirector_ViewImpl *darg = 0;
39126   float result;
39127
39128   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39129   arg2 = (float)jarg2;
39130   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
39131   if (!darg) {
39132     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
39133     return 0;
39134   }
39135   {
39136     try {
39137       result = (float)(darg)->GetWidthForHeight(arg2);
39138     } CALL_CATCH_EXCEPTION(0);
39139   }
39140
39141   jresult = result;
39142   return jresult;
39143 }
39144
39145
39146 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
39147   float jresult ;
39148   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39149   float arg2 ;
39150   SwigDirector_ViewImpl *darg = 0;
39151   float result;
39152
39153   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39154   arg2 = (float)jarg2;
39155   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
39156   if (!darg) {
39157     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
39158     return 0;
39159   }
39160   {
39161     try {
39162       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
39163     } CALL_CATCH_EXCEPTION(0);
39164   }
39165
39166   jresult = result;
39167   return jresult;
39168 }
39169
39170
39171 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39172   bool jresult ;
39173   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39174   Dali::Dimension::Type arg2 ;
39175   SwigDirector_ViewImpl *darg = 0;
39176   bool result;
39177
39178   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39179   arg2 = (Dali::Dimension::Type)jarg2;
39180   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
39181   if (!darg) {
39182     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
39183     return 0;
39184   }
39185   {
39186     try {
39187       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
39188     } CALL_CATCH_EXCEPTION(0);
39189   }
39190
39191   jresult = result;
39192   return jresult;
39193 }
39194
39195
39196 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
39197   bool jresult ;
39198   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39199   Dali::Dimension::Type arg2 ;
39200   SwigDirector_ViewImpl *darg = 0;
39201   bool result;
39202
39203   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39204   arg2 = (Dali::Dimension::Type)jarg2;
39205   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
39206   if (!darg) {
39207     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
39208     return 0;
39209   }
39210   {
39211     try {
39212       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
39213     } CALL_CATCH_EXCEPTION(0);
39214   }
39215
39216   jresult = result;
39217   return jresult;
39218 }
39219
39220
39221 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39222   bool jresult ;
39223   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39224   SwigDirector_ViewImpl *darg = 0;
39225   bool result;
39226
39227   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39228   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
39229   if (!darg) {
39230     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
39231     return 0;
39232   }
39233   {
39234     try {
39235       result = (bool)(darg)->RelayoutDependentOnChildren();
39236     } CALL_CATCH_EXCEPTION(0);
39237   }
39238
39239   jresult = result;
39240   return jresult;
39241 }
39242
39243
39244 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
39245   bool jresult ;
39246   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39247   SwigDirector_ViewImpl *darg = 0;
39248   bool result;
39249
39250   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39251   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
39252   if (!darg) {
39253     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
39254     return 0;
39255   }
39256   {
39257     try {
39258       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
39259     } CALL_CATCH_EXCEPTION(0);
39260   }
39261
39262   jresult = result;
39263   return jresult;
39264 }
39265
39266
39267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39268   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39269   Dali::Dimension::Type arg2 ;
39270   SwigDirector_ViewImpl *darg = 0;
39271
39272   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39273   arg2 = (Dali::Dimension::Type)jarg2;
39274   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
39275   if (!darg) {
39276     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
39277     return;
39278   }
39279   {
39280     try {
39281       (darg)->OnCalculateRelayoutSize(arg2);
39282     } CALL_CATCH_EXCEPTION();
39283   }
39284
39285 }
39286
39287
39288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
39289   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39290   Dali::Dimension::Type arg2 ;
39291   SwigDirector_ViewImpl *darg = 0;
39292
39293   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39294   arg2 = (Dali::Dimension::Type)jarg2;
39295   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
39296   if (!darg) {
39297     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
39298     return;
39299   }
39300   {
39301     try {
39302       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
39303     } CALL_CATCH_EXCEPTION();
39304   }
39305
39306 }
39307
39308
39309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39310   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39311   float arg2 ;
39312   Dali::Dimension::Type arg3 ;
39313   SwigDirector_ViewImpl *darg = 0;
39314
39315   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39316   arg2 = (float)jarg2;
39317   arg3 = (Dali::Dimension::Type)jarg3;
39318   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
39319   if (!darg) {
39320     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
39321     return;
39322   }
39323   {
39324     try {
39325       (darg)->OnLayoutNegotiated(arg2,arg3);
39326     } CALL_CATCH_EXCEPTION();
39327   }
39328
39329 }
39330
39331
39332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
39333   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39334   float arg2 ;
39335   Dali::Dimension::Type arg3 ;
39336   SwigDirector_ViewImpl *darg = 0;
39337
39338   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39339   arg2 = (float)jarg2;
39340   arg3 = (Dali::Dimension::Type)jarg3;
39341   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
39342   if (!darg) {
39343     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
39344     return;
39345   }
39346   {
39347     try {
39348       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
39349     } CALL_CATCH_EXCEPTION();
39350   }
39351
39352 }
39353
39354
39355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
39356   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39357
39358   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39359   {
39360     try {
39361       (arg1)->OnInitialize();
39362     } CALL_CATCH_EXCEPTION();
39363   }
39364
39365 }
39366
39367
39368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
39369   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39370
39371   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39372   {
39373     try {
39374       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
39375     } CALL_CATCH_EXCEPTION();
39376   }
39377
39378 }
39379
39380
39381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
39382   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39383   Dali::Toolkit::StyleManager arg2 ;
39384   Dali::StyleChange::Type arg3 ;
39385   Dali::Toolkit::StyleManager *argp2 ;
39386
39387   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39388   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
39389   if (!argp2) {
39390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
39391     return ;
39392   }
39393   arg2 = *argp2;
39394   arg3 = (Dali::StyleChange::Type)jarg3;
39395   {
39396     try {
39397       (arg1)->OnStyleChange(arg2,arg3);
39398     } CALL_CATCH_EXCEPTION();
39399   }
39400
39401 }
39402
39403
39404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
39405   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39406   Dali::Toolkit::StyleManager arg2 ;
39407   Dali::StyleChange::Type arg3 ;
39408   Dali::Toolkit::StyleManager *argp2 ;
39409
39410   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39411   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
39412   if (!argp2) {
39413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
39414     return ;
39415   }
39416   arg2 = *argp2;
39417   arg3 = (Dali::StyleChange::Type)jarg3;
39418   {
39419     try {
39420       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
39421     } CALL_CATCH_EXCEPTION();
39422   }
39423
39424 }
39425
39426
39427 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
39428   bool jresult ;
39429   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39430   bool result;
39431
39432   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39433   {
39434     try {
39435       result = (bool)(arg1)->OnAccessibilityActivated();
39436     } CALL_CATCH_EXCEPTION(0);
39437   }
39438
39439   jresult = result;
39440   return jresult;
39441 }
39442
39443
39444 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
39445   bool jresult ;
39446   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39447   bool result;
39448
39449   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39450   {
39451     try {
39452       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
39453     } CALL_CATCH_EXCEPTION(0);
39454   }
39455
39456   jresult = result;
39457   return jresult;
39458 }
39459
39460
39461 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
39462   bool jresult ;
39463   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39464   Dali::PanGesture arg2 ;
39465   Dali::PanGesture *argp2 ;
39466   bool result;
39467
39468   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39469   argp2 = (Dali::PanGesture *)jarg2;
39470   if (!argp2) {
39471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
39472     return 0;
39473   }
39474   arg2 = *argp2;
39475   {
39476     try {
39477       result = (bool)(arg1)->OnAccessibilityPan(arg2);
39478     } CALL_CATCH_EXCEPTION(0);
39479   }
39480
39481   jresult = result;
39482   return jresult;
39483 }
39484
39485
39486 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
39487   bool jresult ;
39488   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39489   Dali::PanGesture arg2 ;
39490   Dali::PanGesture *argp2 ;
39491   bool result;
39492
39493   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39494   argp2 = (Dali::PanGesture *)jarg2;
39495   if (!argp2) {
39496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
39497     return 0;
39498   }
39499   arg2 = *argp2;
39500   {
39501     try {
39502       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
39503     } CALL_CATCH_EXCEPTION(0);
39504   }
39505
39506   jresult = result;
39507   return jresult;
39508 }
39509
39510 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, bool jarg2) {
39511   bool jresult ;
39512   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39513   bool arg2 ;
39514   bool result;
39515
39516   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39517   arg2 = jarg2 ? true : false;
39518   {
39519     try {
39520       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
39521     } CALL_CATCH_EXCEPTION(0);
39522   }
39523
39524   jresult = result;
39525   return jresult;
39526 }
39527
39528
39529 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, bool jarg2) {
39530   bool jresult ;
39531   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39532   bool arg2 ;
39533   bool result;
39534
39535   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39536   arg2 = jarg2 ? true : false;
39537   {
39538     try {
39539       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
39540     } CALL_CATCH_EXCEPTION(0);
39541   }
39542
39543   jresult = result;
39544   return jresult;
39545 }
39546
39547
39548 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
39549   bool jresult ;
39550   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39551   bool result;
39552
39553   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39554   {
39555     try {
39556       result = (bool)(arg1)->OnAccessibilityZoom();
39557     } CALL_CATCH_EXCEPTION(0);
39558   }
39559
39560   jresult = result;
39561   return jresult;
39562 }
39563
39564
39565 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
39566   bool jresult ;
39567   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39568   bool result;
39569
39570   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39571   {
39572     try {
39573       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
39574     } CALL_CATCH_EXCEPTION(0);
39575   }
39576
39577   jresult = result;
39578   return jresult;
39579 }
39580
39581
39582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
39583   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39584
39585   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39586   {
39587     try {
39588       (arg1)->OnKeyInputFocusGained();
39589     } CALL_CATCH_EXCEPTION();
39590   }
39591
39592 }
39593
39594
39595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
39596   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39597
39598   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39599   {
39600     try {
39601       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
39602     } CALL_CATCH_EXCEPTION();
39603   }
39604
39605 }
39606
39607
39608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
39609   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39610
39611   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39612   {
39613     try {
39614       (arg1)->OnKeyInputFocusLost();
39615     } CALL_CATCH_EXCEPTION();
39616   }
39617
39618 }
39619
39620
39621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
39622   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39623
39624   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39625   {
39626     try {
39627       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
39628     } CALL_CATCH_EXCEPTION();
39629   }
39630
39631 }
39632
39633
39634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, bool jarg4) {
39635   void * jresult ;
39636   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39637   Dali::Actor arg2 ;
39638   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
39639   bool arg4 ;
39640   Dali::Actor *argp2 ;
39641   Dali::Actor result;
39642
39643   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39644   argp2 = (Dali::Actor *)jarg2;
39645   if (!argp2) {
39646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39647     return 0;
39648   }
39649   arg2 = *argp2;
39650   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
39651   arg4 = jarg4 ? true : false;
39652   {
39653     try {
39654       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
39655     } CALL_CATCH_EXCEPTION(0);
39656   }
39657
39658   jresult = new Dali::Actor((const Dali::Actor &)result);
39659   return jresult;
39660 }
39661
39662
39663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, bool jarg4) {
39664   void * jresult ;
39665   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39666   Dali::Actor arg2 ;
39667   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
39668   bool arg4 ;
39669   Dali::Actor *argp2 ;
39670   Dali::Actor result;
39671
39672   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39673   argp2 = (Dali::Actor *)jarg2;
39674   if (!argp2) {
39675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39676     return 0;
39677   }
39678   arg2 = *argp2;
39679   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
39680   arg4 = jarg4 ? true : false;
39681   {
39682     try {
39683       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
39684     } CALL_CATCH_EXCEPTION(0);
39685   }
39686
39687   jresult = new Dali::Actor((const Dali::Actor &)result);
39688   return jresult;
39689 }
39690
39691
39692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
39693   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39694   Dali::Actor arg2 ;
39695   Dali::Actor *argp2 ;
39696
39697   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39698   argp2 = (Dali::Actor *)jarg2;
39699   if (!argp2) {
39700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39701     return ;
39702   }
39703   arg2 = *argp2;
39704   {
39705     try {
39706       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
39707     } CALL_CATCH_EXCEPTION();
39708   }
39709
39710 }
39711
39712
39713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
39714   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39715   Dali::Actor arg2 ;
39716   Dali::Actor *argp2 ;
39717
39718   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39719   argp2 = (Dali::Actor *)jarg2;
39720   if (!argp2) {
39721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39722     return ;
39723   }
39724   arg2 = *argp2;
39725   {
39726     try {
39727       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
39728     } CALL_CATCH_EXCEPTION();
39729   }
39730
39731 }
39732
39733
39734 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
39735   bool jresult ;
39736   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39737   bool result;
39738
39739   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39740   {
39741     try {
39742       result = (bool)(arg1)->OnKeyboardEnter();
39743     } CALL_CATCH_EXCEPTION(0);
39744   }
39745
39746   jresult = result;
39747   return jresult;
39748 }
39749
39750
39751 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
39752   bool jresult ;
39753   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39754   bool result;
39755
39756   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39757   {
39758     try {
39759       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
39760     } CALL_CATCH_EXCEPTION(0);
39761   }
39762
39763   jresult = result;
39764   return jresult;
39765 }
39766
39767
39768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
39769   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39770   Dali::PinchGesture *arg2 = 0 ;
39771
39772   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39773   arg2 = (Dali::PinchGesture *)jarg2;
39774   if (!arg2) {
39775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
39776     return ;
39777   }
39778   {
39779     try {
39780       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
39781     } CALL_CATCH_EXCEPTION();
39782   }
39783
39784 }
39785
39786
39787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
39788   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39789   Dali::PinchGesture *arg2 = 0 ;
39790
39791   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39792   arg2 = (Dali::PinchGesture *)jarg2;
39793   if (!arg2) {
39794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
39795     return ;
39796   }
39797   {
39798     try {
39799       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
39800     } CALL_CATCH_EXCEPTION();
39801   }
39802
39803 }
39804
39805
39806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
39807   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39808   Dali::PanGesture *arg2 = 0 ;
39809
39810   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39811   arg2 = (Dali::PanGesture *)jarg2;
39812   if (!arg2) {
39813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
39814     return ;
39815   }
39816   {
39817     try {
39818       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
39819     } CALL_CATCH_EXCEPTION();
39820   }
39821
39822 }
39823
39824
39825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
39826   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39827   Dali::PanGesture *arg2 = 0 ;
39828
39829   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39830   arg2 = (Dali::PanGesture *)jarg2;
39831   if (!arg2) {
39832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
39833     return ;
39834   }
39835   {
39836     try {
39837       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
39838     } CALL_CATCH_EXCEPTION();
39839   }
39840
39841 }
39842
39843
39844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
39845   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39846   Dali::TapGesture *arg2 = 0 ;
39847
39848   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39849   arg2 = (Dali::TapGesture *)jarg2;
39850   if (!arg2) {
39851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
39852     return ;
39853   }
39854   {
39855     try {
39856       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
39857     } CALL_CATCH_EXCEPTION();
39858   }
39859
39860 }
39861
39862
39863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
39864   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39865   Dali::TapGesture *arg2 = 0 ;
39866
39867   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39868   arg2 = (Dali::TapGesture *)jarg2;
39869   if (!arg2) {
39870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
39871     return ;
39872   }
39873   {
39874     try {
39875       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
39876     } CALL_CATCH_EXCEPTION();
39877   }
39878
39879 }
39880
39881
39882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
39883   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39884   Dali::LongPressGesture *arg2 = 0 ;
39885
39886   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39887   arg2 = (Dali::LongPressGesture *)jarg2;
39888   if (!arg2) {
39889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
39890     return ;
39891   }
39892   {
39893     try {
39894       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
39895     } CALL_CATCH_EXCEPTION();
39896   }
39897
39898 }
39899
39900
39901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
39902   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39903   Dali::LongPressGesture *arg2 = 0 ;
39904
39905   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39906   arg2 = (Dali::LongPressGesture *)jarg2;
39907   if (!arg2) {
39908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
39909     return ;
39910   }
39911   {
39912     try {
39913       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
39914     } CALL_CATCH_EXCEPTION();
39915   }
39916
39917 }
39918
39919
39920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
39921   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39922   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
39923   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
39924
39925   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39926   arg2 = (Dali::SlotObserver *)jarg2;
39927   arg3 = (Dali::CallbackBase *)jarg3;
39928   {
39929     try {
39930       (arg1)->SignalConnected(arg2,arg3);
39931     } CALL_CATCH_EXCEPTION();
39932   }
39933
39934 }
39935
39936
39937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
39938   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39939   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
39940   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
39941
39942   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39943   arg2 = (Dali::SlotObserver *)jarg2;
39944   arg3 = (Dali::CallbackBase *)jarg3;
39945   {
39946     try {
39947       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
39948     } CALL_CATCH_EXCEPTION();
39949   }
39950
39951 }
39952
39953
39954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
39955   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39956   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
39957   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
39958
39959   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39960   arg2 = (Dali::SlotObserver *)jarg2;
39961   arg3 = (Dali::CallbackBase *)jarg3;
39962   {
39963     try {
39964       (arg1)->SignalDisconnected(arg2,arg3);
39965     } CALL_CATCH_EXCEPTION();
39966   }
39967
39968 }
39969
39970
39971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
39972   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
39973   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
39974   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
39975
39976   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39977   arg2 = (Dali::SlotObserver *)jarg2;
39978   arg3 = (Dali::CallbackBase *)jarg3;
39979   {
39980     try {
39981       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
39982     } CALL_CATCH_EXCEPTION();
39983   }
39984
39985 }
39986
39987 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) {
39988   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
39989   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
39990   if (director) {
39991     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);
39992   }
39993 }
39994
39995
39996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
39997   void * jresult ;
39998   Dali::Toolkit::Control *arg1 = 0 ;
39999   Dali::Toolkit::Internal::Control *result = 0 ;
40000
40001   arg1 = (Dali::Toolkit::Control *)jarg1;
40002   if (!arg1) {
40003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
40004     return 0;
40005   }
40006   {
40007     try {
40008       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
40009     } CALL_CATCH_EXCEPTION(0);
40010   }
40011
40012   jresult = (void *)result;
40013   return jresult;
40014 }
40015
40016
40017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
40018   int jresult ;
40019   int result;
40020
40021   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
40022   jresult = (int)result;
40023   return jresult;
40024 }
40025
40026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
40027   int jresult ;
40028   int result;
40029
40030   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
40031   jresult = (int)result;
40032   return jresult;
40033 }
40034
40035
40036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
40037   int jresult ;
40038   int result;
40039
40040   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
40041   jresult = (int)result;
40042   return jresult;
40043 }
40044
40045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
40046   int jresult ;
40047   int result;
40048
40049   result = (int)Dali::Toolkit::Control::Property::MARGIN;
40050   jresult = (int)result;
40051   return jresult;
40052 }
40053
40054
40055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
40056   int jresult ;
40057   int result;
40058
40059   result = (int)Dali::Toolkit::Control::Property::PADDING;
40060   jresult = (int)result;
40061   return jresult;
40062 }
40063
40064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
40065   int jresult ;
40066   int result;
40067
40068   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
40069   jresult = (int)result;
40070   return jresult;
40071 }
40072
40073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_NAME_get() {
40074   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_NAME;
40075 }
40076
40077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_DESCRIPTION_get() {
40078   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_DESCRIPTION;
40079 }
40080
40081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_TRANSLATION_DOMAIN_get() {
40082   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_TRANSLATION_DOMAIN;
40083 }
40084
40085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_ROLE_get() {
40086   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_ROLE;
40087 }
40088
40089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_HIGHLIGHTABLE_get() {
40090   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE;
40091 }
40092
40093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_ATTRIBUTES_get() {
40094   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_ATTRIBUTES;
40095 }
40096
40097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_HIDDEN_get() {
40098   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_HIDDEN;
40099 }
40100
40101 SWIGEXPORT int SWIGSTDCALL  CSharp_Dali_View_Property_AUTOMATION_ID_get() {
40102   return (int)Dali::Toolkit::DevelControl::Property::AUTOMATION_ID;
40103 }
40104
40105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
40106   void * jresult ;
40107   Dali::Toolkit::Control::Property *result = 0 ;
40108
40109   {
40110     try {
40111       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
40112     } CALL_CATCH_EXCEPTION(0);
40113   }
40114
40115   jresult = (void *)result;
40116   return jresult;
40117 }
40118
40119
40120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
40121   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
40122
40123   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
40124   {
40125     try {
40126       delete arg1;
40127     } CALL_CATCH_EXCEPTION();
40128   }
40129
40130 }
40131
40132
40133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
40134   void * jresult ;
40135   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
40136
40137   {
40138     try {
40139       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
40140     } CALL_CATCH_EXCEPTION(0);
40141   }
40142
40143   jresult = (void *)result;
40144   return jresult;
40145 }
40146
40147
40148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
40149   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
40150
40151   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
40152   {
40153     try {
40154       delete arg1;
40155     } CALL_CATCH_EXCEPTION();
40156   }
40157
40158 }
40159
40160
40161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
40162   void * jresult ;
40163   Dali::Toolkit::Control result;
40164
40165   {
40166     try {
40167       result = Dali::Toolkit::Control::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
40168     } CALL_CATCH_EXCEPTION(0);
40169   }
40170
40171   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
40172   return jresult;
40173 }
40174
40175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_NewCustom() {
40176   void * jresult;
40177   Dali::Toolkit::Control result;
40178
40179   {
40180     try {
40181       result = SlimCustomViewImpl::New(Dali::Toolkit::Internal::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
40182     } CALL_CATCH_EXCEPTION(0);
40183   }
40184
40185   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
40186   return jresult;
40187 }
40188
40189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
40190   void * jresult ;
40191   Dali::Toolkit::Control *result = 0 ;
40192
40193   {
40194     try {
40195       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
40196     } CALL_CATCH_EXCEPTION(0);
40197   }
40198
40199   jresult = (void *)result;
40200   return jresult;
40201 }
40202
40203
40204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
40205   void * jresult ;
40206   Dali::Toolkit::Control *arg1 = 0 ;
40207   Dali::Toolkit::Control *result = 0 ;
40208
40209   arg1 = (Dali::Toolkit::Control *)jarg1;
40210   if (!arg1) {
40211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
40212     return 0;
40213   }
40214   {
40215     try {
40216       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
40217     } CALL_CATCH_EXCEPTION(0);
40218   }
40219
40220   jresult = (void *)result;
40221   return jresult;
40222 }
40223
40224
40225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
40226   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40227
40228   arg1 = (Dali::Toolkit::Control *)jarg1;
40229   {
40230     try {
40231       delete arg1;
40232     } CALL_CATCH_EXCEPTION();
40233   }
40234
40235 }
40236
40237
40238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
40239   void * jresult ;
40240   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40241   Dali::Toolkit::Control *arg2 = 0 ;
40242   Dali::Toolkit::Control *result = 0 ;
40243
40244   arg1 = (Dali::Toolkit::Control *)jarg1;
40245   arg2 = (Dali::Toolkit::Control *)jarg2;
40246   if (!arg2) {
40247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
40248     return 0;
40249   }
40250   {
40251     try {
40252       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
40253     } CALL_CATCH_EXCEPTION(0);
40254   }
40255
40256   jresult = (void *)result;
40257   return jresult;
40258 }
40259
40260
40261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
40262   void * jresult ;
40263   Dali::BaseHandle arg1 ;
40264   Dali::BaseHandle *argp1 ;
40265   Dali::Toolkit::Control result;
40266
40267   argp1 = (Dali::BaseHandle *)jarg1;
40268   if (!argp1) {
40269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40270     return 0;
40271   }
40272   arg1 = *argp1;
40273   {
40274     try {
40275       result = Dali::Toolkit::Control::DownCast(arg1);
40276     } CALL_CATCH_EXCEPTION(0);
40277   }
40278
40279   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
40280   return jresult;
40281 }
40282
40283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Control(void * jarg1) {
40284   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) jarg1;
40285   try {
40286     delete arg1;
40287   } CALL_CATCH_EXCEPTION();
40288 }
40289
40290
40291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
40292   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40293
40294   arg1 = (Dali::Toolkit::Control *)jarg1;
40295   {
40296     try {
40297       (arg1)->SetKeyInputFocus();
40298     } CALL_CATCH_EXCEPTION();
40299   }
40300
40301 }
40302
40303
40304 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
40305   bool jresult ;
40306   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40307   bool result;
40308
40309   arg1 = (Dali::Toolkit::Control *)jarg1;
40310   {
40311     try {
40312       result = (bool)(arg1)->HasKeyInputFocus();
40313     } CALL_CATCH_EXCEPTION(0);
40314   }
40315
40316   jresult = result;
40317   return jresult;
40318 }
40319
40320
40321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
40322   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40323
40324   arg1 = (Dali::Toolkit::Control *)jarg1;
40325   {
40326     try {
40327       (arg1)->ClearKeyInputFocus();
40328     } CALL_CATCH_EXCEPTION();
40329   }
40330
40331 }
40332
40333
40334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
40335   void * jresult ;
40336   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40337   Dali::PinchGestureDetector result;
40338
40339   arg1 = (Dali::Toolkit::Control *)jarg1;
40340   {
40341     try {
40342       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
40343     } CALL_CATCH_EXCEPTION(0);
40344   }
40345
40346   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
40347   return jresult;
40348 }
40349
40350
40351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
40352   void * jresult ;
40353   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40354   Dali::PanGestureDetector result;
40355
40356   arg1 = (Dali::Toolkit::Control *)jarg1;
40357   {
40358     try {
40359       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
40360     } CALL_CATCH_EXCEPTION(0);
40361   }
40362
40363   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40364   return jresult;
40365 }
40366
40367
40368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
40369   void * jresult ;
40370   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40371   Dali::TapGestureDetector result;
40372
40373   arg1 = (Dali::Toolkit::Control *)jarg1;
40374   {
40375     try {
40376       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
40377     } CALL_CATCH_EXCEPTION(0);
40378   }
40379
40380   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
40381   return jresult;
40382 }
40383
40384
40385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
40386   void * jresult ;
40387   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40388   Dali::LongPressGestureDetector result;
40389
40390   arg1 = (Dali::Toolkit::Control *)jarg1;
40391   {
40392     try {
40393       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
40394     } CALL_CATCH_EXCEPTION(0);
40395   }
40396
40397   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
40398   return jresult;
40399 }
40400
40401
40402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
40403   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40404   std::string *arg2 = 0 ;
40405
40406   arg1 = (Dali::Toolkit::Control *)jarg1;
40407   if (!jarg2) {
40408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40409     return ;
40410   }
40411   std::string arg2_str(jarg2);
40412   arg2 = &arg2_str;
40413   {
40414     try {
40415       (arg1)->SetStyleName((std::string const &)*arg2);
40416     } CALL_CATCH_EXCEPTION();
40417   }
40418
40419
40420   //argout typemap for const std::string&
40421
40422 }
40423
40424
40425 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
40426   char * jresult ;
40427   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40428   std::string *result = 0 ;
40429
40430   arg1 = (Dali::Toolkit::Control *)jarg1;
40431   {
40432     try {
40433       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
40434     } CALL_CATCH_EXCEPTION(0);
40435   }
40436
40437   jresult = SWIG_csharp_string_callback(result->c_str());
40438   return jresult;
40439 }
40440
40441
40442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
40443   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40444   Dali::Vector4 *arg2 = 0 ;
40445
40446   arg1 = (Dali::Toolkit::Control *)jarg1;
40447   arg2 = (Dali::Vector4 *)jarg2;
40448   if (!arg2) {
40449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
40450     return ;
40451   }
40452   {
40453     try {
40454       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
40455     } CALL_CATCH_EXCEPTION();
40456   }
40457
40458 }
40459
40460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
40461   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40462
40463   arg1 = (Dali::Toolkit::Control *)jarg1;
40464   {
40465     try {
40466       (arg1)->ClearBackground();
40467     } CALL_CATCH_EXCEPTION();
40468   }
40469
40470 }
40471
40472
40473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
40474   void * jresult ;
40475   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40476   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
40477
40478   arg1 = (Dali::Toolkit::Control *)jarg1;
40479   {
40480     try {
40481       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
40482     } CALL_CATCH_EXCEPTION(0);
40483   }
40484
40485   jresult = (void *)result;
40486   return jresult;
40487 }
40488
40489
40490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
40491   void * jresult ;
40492   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40493   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
40494
40495   arg1 = (Dali::Toolkit::Control *)jarg1;
40496   {
40497     try {
40498       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
40499     } CALL_CATCH_EXCEPTION(0);
40500   }
40501
40502   jresult = (void *)result;
40503   return jresult;
40504 }
40505
40506
40507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
40508   void * jresult ;
40509   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40510   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
40511
40512   arg1 = (Dali::Toolkit::Control *)jarg1;
40513   {
40514     try {
40515       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
40516     } CALL_CATCH_EXCEPTION(0);
40517   }
40518
40519   jresult = (void *)result;
40520   return jresult;
40521 }
40522
40523
40524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
40525   void * jresult ;
40526   Dali::Toolkit::Internal::Control *arg1 = 0 ;
40527   Dali::Toolkit::Control *result = 0 ;
40528
40529   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
40530   if (!arg1) {
40531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
40532     return 0;
40533   }
40534   {
40535     try {
40536       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
40537     } CALL_CATCH_EXCEPTION(0);
40538   }
40539
40540   jresult = (void *)result;
40541   return jresult;
40542 }
40543
40544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
40545 {
40546   int jresult;
40547   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40548   arg1 = (Dali::Toolkit::Control *)jarg1;
40549
40550   if (!arg1) {
40551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
40552     return 0;
40553   }
40554
40555   Dali::Property::Index arg2 = 0 ;
40556   arg2 = (Dali::Property::Index)jarg2;
40557
40558   Toolkit::Visual::ResourceStatus result;
40559   {
40560     try {
40561       result = arg1->GetVisualResourceStatus(arg2);
40562     } CALL_CATCH_EXCEPTION(0);
40563   }
40564
40565   jresult = (int)result;
40566   return jresult;
40567 }
40568
40569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
40570 {
40571   void * jresult;
40572   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
40573   arg1 = (Dali::Toolkit::Control *)jarg1;
40574
40575   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
40576
40577   Dali::Toolkit::TransitionData *arg2 = 0 ;
40578   Dali::Animation result;
40579
40580   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
40581   if (!arg2) {
40582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
40583     return 0;
40584   }
40585   {
40586     try {
40587       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
40588     } CALL_CATCH_EXCEPTION(0);
40589   }
40590
40591   jresult = new Dali::Animation((const Dali::Animation &)result);
40592   return jresult;
40593 }
40594
40595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
40596 {
40597   Dali::Toolkit::Control arg1;
40598   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
40599
40600   if (!argp1) {
40601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
40602   }
40603   arg1 = *argp1;
40604
40605   Dali::Property::Index arg2 = 0 ;
40606   arg2 = (Dali::Property::Index)jarg2;
40607
40608   Dali::Property::Index arg3 = 0 ;
40609   arg3 = (Dali::Property::Index)jarg3;
40610
40611   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
40612
40613   {
40614     try {
40615       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
40616     } CALL_CATCH_EXCEPTION();
40617   }
40618 }
40619
40620 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_View_GetVisualProperty(void* control, int propertyIndex, int visualPropertyIndex)
40621 {
40622   if (!control)
40623   {
40624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Given control is null", 0);
40625     return 0;
40626   }
40627
40628   void* result = 0;
40629   try
40630   {
40631     Dali::Property property = DevelControl::GetVisualProperty(*((Dali::Toolkit::Control*)control), (Dali::Property::Index)propertyIndex, (Dali::Property::Index)visualPropertyIndex);
40632     result = new Dali::Property(property.object, property.propertyIndex, property.componentIndex);
40633   }
40634   CALL_CATCH_EXCEPTION(0);
40635
40636   return result;
40637 }
40638
40639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
40640   void * jresult ;
40641   Dali::Toolkit::Control *arg1 = 0 ;
40642   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
40643
40644   arg1 = (Dali::Toolkit::Control *)jarg1;
40645   if (!arg1) {
40646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
40647     return 0;
40648   }
40649   {
40650     try {
40651       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
40652     } CALL_CATCH_EXCEPTION(0);
40653   }
40654
40655   jresult = (void *)result;
40656   return jresult;
40657 }
40658
40659
40660 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
40661   bool jresult ;
40662   Dali::Toolkit::Control *arg1 = 0 ;
40663   bool result;
40664
40665   arg1 = (Dali::Toolkit::Control *)jarg1;
40666   if (!arg1) {
40667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
40668     return 0;
40669   }
40670   {
40671     try {
40672       result = (bool)arg1->IsResourceReady();
40673     } CALL_CATCH_EXCEPTION(0);
40674   }
40675
40676   jresult = result;
40677   return jresult;
40678 }
40679
40680
40681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
40682   void * jresult ;
40683   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
40684
40685   {
40686     try {
40687       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
40688     } CALL_CATCH_EXCEPTION(0);
40689   }
40690
40691   jresult = (void *)result;
40692   return jresult;
40693 }
40694
40695
40696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
40697   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
40698
40699   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
40700   {
40701     try {
40702       delete arg1;
40703     } CALL_CATCH_EXCEPTION();
40704   }
40705
40706 }
40707
40708
40709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
40710   void * jresult ;
40711   Dali::Toolkit::KeyInputFocusManager result;
40712
40713   {
40714     try {
40715       result = Dali::Toolkit::KeyInputFocusManager::Get();
40716     } CALL_CATCH_EXCEPTION(0);
40717   }
40718
40719   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
40720   return jresult;
40721 }
40722
40723
40724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
40725   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
40726   Dali::Toolkit::Control arg2 ;
40727   Dali::Toolkit::Control *argp2 ;
40728
40729   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
40730   argp2 = (Dali::Toolkit::Control *)jarg2;
40731   if (!argp2) {
40732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
40733     return ;
40734   }
40735   arg2 = *argp2;
40736   {
40737     try {
40738       (arg1)->SetFocus(arg2);
40739     } CALL_CATCH_EXCEPTION();
40740   }
40741
40742 }
40743
40744
40745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
40746   void * jresult ;
40747   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
40748   Dali::Toolkit::Control result;
40749
40750   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
40751   {
40752     try {
40753       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
40754     } CALL_CATCH_EXCEPTION(0);
40755   }
40756
40757   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
40758   return jresult;
40759 }
40760
40761
40762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
40763   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
40764   Dali::Toolkit::Control arg2 ;
40765   Dali::Toolkit::Control *argp2 ;
40766
40767   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
40768   argp2 = (Dali::Toolkit::Control *)jarg2;
40769   if (!argp2) {
40770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
40771     return ;
40772   }
40773   arg2 = *argp2;
40774   {
40775     try {
40776       (arg1)->RemoveFocus(arg2);
40777     } CALL_CATCH_EXCEPTION();
40778   }
40779
40780 }
40781
40782
40783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
40784   void * jresult ;
40785   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
40786   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
40787
40788   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
40789   {
40790     try {
40791       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
40792     } CALL_CATCH_EXCEPTION(0);
40793   }
40794
40795   jresult = (void *)result;
40796   return jresult;
40797 }
40798
40799
40800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
40801   void * jresult ;
40802   Dali::Toolkit::Alignment::Padding *result = 0 ;
40803
40804   {
40805     try {
40806       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
40807     } CALL_CATCH_EXCEPTION(0);
40808   }
40809
40810   jresult = (void *)result;
40811   return jresult;
40812 }
40813
40814
40815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
40816   void * jresult ;
40817   float arg1 ;
40818   float arg2 ;
40819   float arg3 ;
40820   float arg4 ;
40821   Dali::Toolkit::Alignment::Padding *result = 0 ;
40822
40823   arg1 = (float)jarg1;
40824   arg2 = (float)jarg2;
40825   arg3 = (float)jarg3;
40826   arg4 = (float)jarg4;
40827   {
40828     try {
40829       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
40830     } CALL_CATCH_EXCEPTION(0);
40831   }
40832
40833   jresult = (void *)result;
40834   return jresult;
40835 }
40836
40837
40838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
40839   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
40840   float arg2 ;
40841
40842   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
40843   arg2 = (float)jarg2;
40844   if (arg1) (arg1)->left = arg2;
40845 }
40846
40847
40848 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
40849   float jresult ;
40850   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
40851   float result;
40852
40853   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
40854   result = (float) ((arg1)->left);
40855   jresult = result;
40856   return jresult;
40857 }
40858
40859
40860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
40861   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
40862   float arg2 ;
40863
40864   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
40865   arg2 = (float)jarg2;
40866   if (arg1) (arg1)->right = arg2;
40867 }
40868
40869
40870 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
40871   float jresult ;
40872   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
40873   float result;
40874
40875   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
40876   result = (float) ((arg1)->right);
40877   jresult = result;
40878   return jresult;
40879 }
40880
40881
40882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
40883   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
40884   float arg2 ;
40885
40886   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
40887   arg2 = (float)jarg2;
40888   if (arg1) (arg1)->top = arg2;
40889 }
40890
40891
40892 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
40893   float jresult ;
40894   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
40895   float result;
40896
40897   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
40898   result = (float) ((arg1)->top);
40899   jresult = result;
40900   return jresult;
40901 }
40902
40903
40904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
40905   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
40906   float arg2 ;
40907
40908   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
40909   arg2 = (float)jarg2;
40910   if (arg1) (arg1)->bottom = arg2;
40911 }
40912
40913
40914 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
40915   float jresult ;
40916   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
40917   float result;
40918
40919   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
40920   result = (float) ((arg1)->bottom);
40921   jresult = result;
40922   return jresult;
40923 }
40924
40925
40926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
40927   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
40928
40929   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
40930   {
40931     try {
40932       delete arg1;
40933     } CALL_CATCH_EXCEPTION();
40934   }
40935
40936 }
40937
40938
40939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
40940   void * jresult ;
40941   Dali::Toolkit::Alignment *result = 0 ;
40942
40943   {
40944     try {
40945       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
40946     } CALL_CATCH_EXCEPTION(0);
40947   }
40948
40949   jresult = (void *)result;
40950   return jresult;
40951 }
40952
40953
40954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
40955   void * jresult ;
40956   Dali::Toolkit::Alignment::Type arg1 ;
40957   Dali::Toolkit::Alignment::Type arg2 ;
40958   Dali::Toolkit::Alignment result;
40959
40960   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
40961   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
40962   {
40963     try {
40964       result = Dali::Toolkit::Alignment::New(arg1,arg2);
40965     } CALL_CATCH_EXCEPTION(0);
40966   }
40967
40968   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
40969   return jresult;
40970 }
40971
40972
40973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
40974   void * jresult ;
40975   Dali::Toolkit::Alignment::Type arg1 ;
40976   Dali::Toolkit::Alignment result;
40977
40978   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
40979   {
40980     try {
40981       result = Dali::Toolkit::Alignment::New(arg1);
40982     } CALL_CATCH_EXCEPTION(0);
40983   }
40984
40985   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
40986   return jresult;
40987 }
40988
40989
40990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
40991   void * jresult ;
40992   Dali::Toolkit::Alignment result;
40993
40994   {
40995     try {
40996       result = Dali::Toolkit::Alignment::New();
40997     } CALL_CATCH_EXCEPTION(0);
40998   }
40999
41000   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
41001   return jresult;
41002 }
41003
41004
41005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
41006   void * jresult ;
41007   Dali::Toolkit::Alignment *arg1 = 0 ;
41008   Dali::Toolkit::Alignment *result = 0 ;
41009
41010   arg1 = (Dali::Toolkit::Alignment *)jarg1;
41011   if (!arg1) {
41012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
41013     return 0;
41014   }
41015   {
41016     try {
41017       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
41018     } CALL_CATCH_EXCEPTION(0);
41019   }
41020
41021   jresult = (void *)result;
41022   return jresult;
41023 }
41024
41025
41026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
41027   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
41028
41029   arg1 = (Dali::Toolkit::Alignment *)jarg1;
41030   {
41031     try {
41032       delete arg1;
41033     } CALL_CATCH_EXCEPTION();
41034   }
41035
41036 }
41037
41038
41039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
41040   void * jresult ;
41041   Dali::BaseHandle arg1 ;
41042   Dali::BaseHandle *argp1 ;
41043   Dali::Toolkit::Alignment result;
41044
41045   argp1 = (Dali::BaseHandle *)jarg1;
41046   if (!argp1) {
41047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41048     return 0;
41049   }
41050   arg1 = *argp1;
41051   {
41052     try {
41053       result = Dali::Toolkit::Alignment::DownCast(arg1);
41054     } CALL_CATCH_EXCEPTION(0);
41055   }
41056
41057   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
41058   return jresult;
41059 }
41060
41061
41062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
41063   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
41064   Dali::Toolkit::Alignment::Type arg2 ;
41065
41066   arg1 = (Dali::Toolkit::Alignment *)jarg1;
41067   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
41068   {
41069     try {
41070       (arg1)->SetAlignmentType(arg2);
41071     } CALL_CATCH_EXCEPTION();
41072   }
41073
41074 }
41075
41076
41077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
41078   int jresult ;
41079   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
41080   Dali::Toolkit::Alignment::Type result;
41081
41082   arg1 = (Dali::Toolkit::Alignment *)jarg1;
41083   {
41084     try {
41085       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
41086     } CALL_CATCH_EXCEPTION(0);
41087   }
41088
41089   jresult = (int)result;
41090   return jresult;
41091 }
41092
41093
41094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
41095   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
41096   Dali::Toolkit::Alignment::Scaling arg2 ;
41097
41098   arg1 = (Dali::Toolkit::Alignment *)jarg1;
41099   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
41100   {
41101     try {
41102       (arg1)->SetScaling(arg2);
41103     } CALL_CATCH_EXCEPTION();
41104   }
41105
41106 }
41107
41108
41109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
41110   int jresult ;
41111   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
41112   Dali::Toolkit::Alignment::Scaling result;
41113
41114   arg1 = (Dali::Toolkit::Alignment *)jarg1;
41115   {
41116     try {
41117       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
41118     } CALL_CATCH_EXCEPTION(0);
41119   }
41120
41121   jresult = (int)result;
41122   return jresult;
41123 }
41124
41125
41126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
41127   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
41128   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
41129
41130   arg1 = (Dali::Toolkit::Alignment *)jarg1;
41131   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
41132   if (!arg2) {
41133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
41134     return ;
41135   }
41136   {
41137     try {
41138       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
41139     } CALL_CATCH_EXCEPTION();
41140   }
41141
41142 }
41143
41144
41145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
41146   void * jresult ;
41147   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
41148   Dali::Toolkit::Alignment::Padding *result = 0 ;
41149
41150   arg1 = (Dali::Toolkit::Alignment *)jarg1;
41151   {
41152     try {
41153       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
41154     } CALL_CATCH_EXCEPTION(0);
41155   }
41156
41157   jresult = (void *)result;
41158   return jresult;
41159 }
41160
41161
41162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
41163   void * jresult ;
41164   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
41165   Dali::Toolkit::Alignment *arg2 = 0 ;
41166   Dali::Toolkit::Alignment *result = 0 ;
41167
41168   arg1 = (Dali::Toolkit::Alignment *)jarg1;
41169   arg2 = (Dali::Toolkit::Alignment *)jarg2;
41170   if (!arg2) {
41171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
41172     return 0;
41173   }
41174   {
41175     try {
41176       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
41177     } CALL_CATCH_EXCEPTION(0);
41178   }
41179
41180   jresult = (void *)result;
41181   return jresult;
41182 }
41183
41184
41185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
41186   int jresult ;
41187   int result;
41188
41189   result = (int)Dali::Toolkit::Button::Property::DISABLED;
41190   jresult = (int)result;
41191   return jresult;
41192 }
41193
41194
41195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
41196   int jresult ;
41197   int result;
41198
41199   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
41200   jresult = (int)result;
41201   return jresult;
41202 }
41203
41204
41205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
41206   int jresult ;
41207   int result;
41208
41209   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
41210   jresult = (int)result;
41211   return jresult;
41212 }
41213
41214
41215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
41216   int jresult ;
41217   int result;
41218
41219   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
41220   jresult = (int)result;
41221   return jresult;
41222 }
41223
41224
41225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
41226   int jresult ;
41227   int result;
41228
41229   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
41230   jresult = (int)result;
41231   return jresult;
41232 }
41233
41234
41235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
41236   int jresult ;
41237   int result;
41238
41239   result = (int)Dali::Toolkit::Button::Property::SELECTED;
41240   jresult = (int)result;
41241   return jresult;
41242 }
41243
41244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
41245   int jresult ;
41246   int result;
41247
41248   result = (int)Dali::Toolkit::Button::Property::LABEL;
41249   jresult = (int)result;
41250   return jresult;
41251 }
41252
41253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
41254   void * jresult ;
41255   Dali::Toolkit::Button::Property *result = 0 ;
41256
41257   {
41258     try {
41259       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
41260     } CALL_CATCH_EXCEPTION(0);
41261   }
41262
41263   jresult = (void *)result;
41264   return jresult;
41265 }
41266
41267
41268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
41269   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
41270
41271   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
41272   {
41273     try {
41274       delete arg1;
41275     } CALL_CATCH_EXCEPTION();
41276   }
41277
41278 }
41279
41280
41281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
41282   void * jresult ;
41283   Dali::Toolkit::Button *result = 0 ;
41284
41285   {
41286     try {
41287       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
41288     } CALL_CATCH_EXCEPTION(0);
41289   }
41290
41291   jresult = (void *)result;
41292   return jresult;
41293 }
41294
41295
41296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
41297   void * jresult ;
41298   Dali::Toolkit::Button *arg1 = 0 ;
41299   Dali::Toolkit::Button *result = 0 ;
41300
41301   arg1 = (Dali::Toolkit::Button *)jarg1;
41302   if (!arg1) {
41303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
41304     return 0;
41305   }
41306   {
41307     try {
41308       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
41309     } CALL_CATCH_EXCEPTION(0);
41310   }
41311
41312   jresult = (void *)result;
41313   return jresult;
41314 }
41315
41316
41317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
41318   void * jresult ;
41319   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
41320   Dali::Toolkit::Button *arg2 = 0 ;
41321   Dali::Toolkit::Button *result = 0 ;
41322
41323   arg1 = (Dali::Toolkit::Button *)jarg1;
41324   arg2 = (Dali::Toolkit::Button *)jarg2;
41325   if (!arg2) {
41326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
41327     return 0;
41328   }
41329   {
41330     try {
41331       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
41332     } CALL_CATCH_EXCEPTION(0);
41333   }
41334
41335   jresult = (void *)result;
41336   return jresult;
41337 }
41338
41339
41340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
41341   void * jresult ;
41342   Dali::BaseHandle arg1 ;
41343   Dali::BaseHandle *argp1 ;
41344   Dali::Toolkit::Button result;
41345
41346   argp1 = (Dali::BaseHandle *)jarg1;
41347   if (!argp1) {
41348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41349     return 0;
41350   }
41351   arg1 = *argp1;
41352   {
41353     try {
41354       result = Dali::Toolkit::Button::DownCast(arg1);
41355     } CALL_CATCH_EXCEPTION(0);
41356   }
41357
41358   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
41359   return jresult;
41360 }
41361
41362
41363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
41364   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
41365
41366   arg1 = (Dali::Toolkit::Button *)jarg1;
41367   {
41368     try {
41369       delete arg1;
41370     } CALL_CATCH_EXCEPTION();
41371   }
41372
41373 }
41374
41375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
41376   void * jresult ;
41377   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
41378   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
41379
41380   arg1 = (Dali::Toolkit::Button *)jarg1;
41381   {
41382     try {
41383       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
41384     } CALL_CATCH_EXCEPTION(0);
41385   }
41386
41387   jresult = (void *)result;
41388   return jresult;
41389 }
41390
41391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
41392   void * jresult ;
41393   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
41394   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
41395
41396   arg1 = (Dali::Toolkit::Button *)jarg1;
41397   {
41398     try {
41399       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
41400     } CALL_CATCH_EXCEPTION(0);
41401   }
41402
41403   jresult = (void *)result;
41404   return jresult;
41405 }
41406
41407
41408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
41409   void * jresult ;
41410   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
41411   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
41412
41413   arg1 = (Dali::Toolkit::Button *)jarg1;
41414   {
41415     try {
41416       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
41417     } CALL_CATCH_EXCEPTION(0);
41418   }
41419
41420   jresult = (void *)result;
41421   return jresult;
41422 }
41423
41424
41425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
41426   void * jresult ;
41427   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
41428   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
41429
41430   arg1 = (Dali::Toolkit::Button *)jarg1;
41431   {
41432     try {
41433       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
41434     } CALL_CATCH_EXCEPTION(0);
41435   }
41436
41437   jresult = (void *)result;
41438   return jresult;
41439 }
41440
41441
41442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
41443   void * jresult ;
41444   Dali::Toolkit::CheckBoxButton *result = 0 ;
41445
41446   {
41447     try {
41448       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
41449     } CALL_CATCH_EXCEPTION(0);
41450   }
41451
41452   jresult = (void *)result;
41453   return jresult;
41454 }
41455
41456
41457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
41458   void * jresult ;
41459   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
41460   Dali::Toolkit::CheckBoxButton *result = 0 ;
41461
41462   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
41463   if (!arg1) {
41464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
41465     return 0;
41466   }
41467   {
41468     try {
41469       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
41470     } CALL_CATCH_EXCEPTION(0);
41471   }
41472
41473   jresult = (void *)result;
41474   return jresult;
41475 }
41476
41477
41478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
41479   void * jresult ;
41480   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
41481   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
41482   Dali::Toolkit::CheckBoxButton *result = 0 ;
41483
41484   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
41485   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
41486   if (!arg2) {
41487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
41488     return 0;
41489   }
41490   {
41491     try {
41492       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
41493     } CALL_CATCH_EXCEPTION(0);
41494   }
41495
41496   jresult = (void *)result;
41497   return jresult;
41498 }
41499
41500
41501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
41502   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
41503
41504   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
41505   {
41506     try {
41507       delete arg1;
41508     } CALL_CATCH_EXCEPTION();
41509   }
41510
41511 }
41512
41513
41514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
41515   void * jresult ;
41516   Dali::Toolkit::CheckBoxButton result;
41517
41518   {
41519     try {
41520       result = Dali::Toolkit::CheckBoxButton::New();
41521     } CALL_CATCH_EXCEPTION(0);
41522   }
41523
41524   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
41525   return jresult;
41526 }
41527
41528
41529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
41530   void * jresult ;
41531   Dali::BaseHandle arg1 ;
41532   Dali::BaseHandle *argp1 ;
41533   Dali::Toolkit::CheckBoxButton result;
41534
41535   argp1 = (Dali::BaseHandle *)jarg1;
41536   if (!argp1) {
41537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41538     return 0;
41539   }
41540   arg1 = *argp1;
41541   {
41542     try {
41543       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
41544     } CALL_CATCH_EXCEPTION(0);
41545   }
41546
41547   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
41548   return jresult;
41549 }
41550
41551
41552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
41553   int jresult ;
41554   int result;
41555
41556   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
41557   jresult = (int)result;
41558   return jresult;
41559 }
41560
41561
41562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
41563   int jresult ;
41564   int result;
41565
41566   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
41567   jresult = (int)result;
41568   return jresult;
41569 }
41570
41571
41572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
41573   void * jresult ;
41574   Dali::Toolkit::PushButton::Property *result = 0 ;
41575
41576   {
41577     try {
41578       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
41579     } CALL_CATCH_EXCEPTION(0);
41580   }
41581
41582   jresult = (void *)result;
41583   return jresult;
41584 }
41585
41586
41587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
41588   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
41589
41590   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
41591   {
41592     try {
41593       delete arg1;
41594     } CALL_CATCH_EXCEPTION();
41595   }
41596
41597 }
41598
41599
41600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
41601   void * jresult ;
41602   Dali::Toolkit::PushButton *result = 0 ;
41603
41604   {
41605     try {
41606       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
41607     } CALL_CATCH_EXCEPTION(0);
41608   }
41609
41610   jresult = (void *)result;
41611   return jresult;
41612 }
41613
41614
41615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
41616   void * jresult ;
41617   Dali::Toolkit::PushButton *arg1 = 0 ;
41618   Dali::Toolkit::PushButton *result = 0 ;
41619
41620   arg1 = (Dali::Toolkit::PushButton *)jarg1;
41621   if (!arg1) {
41622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
41623     return 0;
41624   }
41625   {
41626     try {
41627       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
41628     } CALL_CATCH_EXCEPTION(0);
41629   }
41630
41631   jresult = (void *)result;
41632   return jresult;
41633 }
41634
41635
41636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
41637   void * jresult ;
41638   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
41639   Dali::Toolkit::PushButton *arg2 = 0 ;
41640   Dali::Toolkit::PushButton *result = 0 ;
41641
41642   arg1 = (Dali::Toolkit::PushButton *)jarg1;
41643   arg2 = (Dali::Toolkit::PushButton *)jarg2;
41644   if (!arg2) {
41645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
41646     return 0;
41647   }
41648   {
41649     try {
41650       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
41651     } CALL_CATCH_EXCEPTION(0);
41652   }
41653
41654   jresult = (void *)result;
41655   return jresult;
41656 }
41657
41658
41659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
41660   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
41661
41662   arg1 = (Dali::Toolkit::PushButton *)jarg1;
41663   {
41664     try {
41665       delete arg1;
41666     } CALL_CATCH_EXCEPTION();
41667   }
41668
41669 }
41670
41671
41672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
41673   void * jresult ;
41674   Dali::Toolkit::PushButton result;
41675
41676   {
41677     try {
41678       result = Dali::Toolkit::PushButton::New();
41679     } CALL_CATCH_EXCEPTION(0);
41680   }
41681
41682   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
41683   return jresult;
41684 }
41685
41686
41687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
41688   void * jresult ;
41689   Dali::BaseHandle arg1 ;
41690   Dali::BaseHandle *argp1 ;
41691   Dali::Toolkit::PushButton result;
41692
41693   argp1 = (Dali::BaseHandle *)jarg1;
41694   if (!argp1) {
41695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41696     return 0;
41697   }
41698   arg1 = *argp1;
41699   {
41700     try {
41701       result = Dali::Toolkit::PushButton::DownCast(arg1);
41702     } CALL_CATCH_EXCEPTION(0);
41703   }
41704
41705   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
41706   return jresult;
41707 }
41708
41709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
41710   void * jresult ;
41711   Dali::Toolkit::RadioButton *result = 0 ;
41712
41713   {
41714     try {
41715       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
41716     } CALL_CATCH_EXCEPTION(0);
41717   }
41718
41719   jresult = (void *)result;
41720   return jresult;
41721 }
41722
41723
41724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
41725   void * jresult ;
41726   Dali::Toolkit::RadioButton *arg1 = 0 ;
41727   Dali::Toolkit::RadioButton *result = 0 ;
41728
41729   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
41730   if (!arg1) {
41731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
41732     return 0;
41733   }
41734   {
41735     try {
41736       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
41737     } CALL_CATCH_EXCEPTION(0);
41738   }
41739
41740   jresult = (void *)result;
41741   return jresult;
41742 }
41743
41744
41745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
41746   void * jresult ;
41747   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
41748   Dali::Toolkit::RadioButton *arg2 = 0 ;
41749   Dali::Toolkit::RadioButton *result = 0 ;
41750
41751   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
41752   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
41753   if (!arg2) {
41754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
41755     return 0;
41756   }
41757   {
41758     try {
41759       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
41760     } CALL_CATCH_EXCEPTION(0);
41761   }
41762
41763   jresult = (void *)result;
41764   return jresult;
41765 }
41766
41767
41768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
41769   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
41770
41771   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
41772   {
41773     try {
41774       delete arg1;
41775     } CALL_CATCH_EXCEPTION();
41776   }
41777
41778 }
41779
41780
41781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
41782   void * jresult ;
41783   Dali::Toolkit::RadioButton result;
41784
41785   {
41786     try {
41787       result = Dali::Toolkit::RadioButton::New();
41788     } CALL_CATCH_EXCEPTION(0);
41789   }
41790
41791   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
41792   return jresult;
41793 }
41794
41795
41796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
41797   void * jresult ;
41798   std::string *arg1 = 0 ;
41799   Dali::Toolkit::RadioButton result;
41800
41801   if (!jarg1) {
41802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
41803     return 0;
41804   }
41805   std::string arg1_str(jarg1);
41806   arg1 = &arg1_str;
41807   {
41808     try {
41809       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
41810     } CALL_CATCH_EXCEPTION(0);
41811   }
41812
41813   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
41814
41815   //argout typemap for const std::string&
41816
41817   return jresult;
41818 }
41819
41820
41821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
41822   void * jresult ;
41823   Dali::BaseHandle arg1 ;
41824   Dali::BaseHandle *argp1 ;
41825   Dali::Toolkit::RadioButton result;
41826
41827   argp1 = (Dali::BaseHandle *)jarg1;
41828   if (!argp1) {
41829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41830     return 0;
41831   }
41832   arg1 = *argp1;
41833   {
41834     try {
41835       result = Dali::Toolkit::RadioButton::DownCast(arg1);
41836     } CALL_CATCH_EXCEPTION(0);
41837   }
41838
41839   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
41840   return jresult;
41841 }
41842
41843
41844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
41845   int jresult ;
41846   int result;
41847
41848   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
41849   jresult = (int)result;
41850   return jresult;
41851 }
41852
41853
41854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
41855   int jresult ;
41856   int result;
41857
41858   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
41859   jresult = (int)result;
41860   return jresult;
41861 }
41862
41863
41864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
41865   int jresult ;
41866   int result;
41867
41868   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
41869   jresult = (int)result;
41870   return jresult;
41871 }
41872
41873
41874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
41875   int jresult ;
41876   int result;
41877
41878   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
41879   jresult = (int)result;
41880   return jresult;
41881 }
41882
41883
41884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
41885   int jresult ;
41886   int result;
41887
41888   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
41889   jresult = (int)result;
41890   return jresult;
41891 }
41892
41893
41894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
41895   int jresult ;
41896   int result;
41897
41898   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
41899   jresult = (int)result;
41900   return jresult;
41901 }
41902
41903
41904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
41905   void * jresult ;
41906   Dali::Toolkit::FlexContainer::Property *result = 0 ;
41907
41908   {
41909     try {
41910       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
41911     } CALL_CATCH_EXCEPTION(0);
41912   }
41913
41914   jresult = (void *)result;
41915   return jresult;
41916 }
41917
41918
41919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
41920   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
41921
41922   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
41923   {
41924     try {
41925       delete arg1;
41926     } CALL_CATCH_EXCEPTION();
41927   }
41928
41929 }
41930
41931
41932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
41933   int jresult ;
41934   int result;
41935
41936   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
41937   jresult = (int)result;
41938   return jresult;
41939 }
41940
41941
41942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
41943   int jresult ;
41944   int result;
41945
41946   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
41947   jresult = (int)result;
41948   return jresult;
41949 }
41950
41951
41952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
41953   int jresult ;
41954   int result;
41955
41956   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
41957   jresult = (int)result;
41958   return jresult;
41959 }
41960
41961
41962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
41963   void * jresult ;
41964   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
41965
41966   {
41967     try {
41968       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
41969     } CALL_CATCH_EXCEPTION(0);
41970   }
41971
41972   jresult = (void *)result;
41973   return jresult;
41974 }
41975
41976
41977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
41978   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
41979
41980   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
41981   {
41982     try {
41983       delete arg1;
41984     } CALL_CATCH_EXCEPTION();
41985   }
41986
41987 }
41988
41989
41990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
41991   void * jresult ;
41992   Dali::Toolkit::FlexContainer *result = 0 ;
41993
41994   {
41995     try {
41996       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
41997     } CALL_CATCH_EXCEPTION(0);
41998   }
41999
42000   jresult = (void *)result;
42001   return jresult;
42002 }
42003
42004
42005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
42006   void * jresult ;
42007   Dali::Toolkit::FlexContainer *arg1 = 0 ;
42008   Dali::Toolkit::FlexContainer *result = 0 ;
42009
42010   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
42011   if (!arg1) {
42012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
42013     return 0;
42014   }
42015   {
42016     try {
42017       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
42018     } CALL_CATCH_EXCEPTION(0);
42019   }
42020
42021   jresult = (void *)result;
42022   return jresult;
42023 }
42024
42025
42026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
42027   void * jresult ;
42028   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
42029   Dali::Toolkit::FlexContainer *arg2 = 0 ;
42030   Dali::Toolkit::FlexContainer *result = 0 ;
42031
42032   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
42033   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
42034   if (!arg2) {
42035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
42036     return 0;
42037   }
42038   {
42039     try {
42040       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
42041     } CALL_CATCH_EXCEPTION(0);
42042   }
42043
42044   jresult = (void *)result;
42045   return jresult;
42046 }
42047
42048
42049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
42050   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
42051
42052   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
42053   {
42054     try {
42055       delete arg1;
42056     } CALL_CATCH_EXCEPTION();
42057   }
42058
42059 }
42060
42061
42062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
42063   void * jresult ;
42064   Dali::Toolkit::FlexContainer result;
42065
42066   {
42067     try {
42068       result = Dali::Toolkit::FlexContainer::New();
42069     } CALL_CATCH_EXCEPTION(0);
42070   }
42071
42072   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
42073   return jresult;
42074 }
42075
42076
42077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
42078   void * jresult ;
42079   Dali::BaseHandle arg1 ;
42080   Dali::BaseHandle *argp1 ;
42081   Dali::Toolkit::FlexContainer result;
42082
42083   argp1 = (Dali::BaseHandle *)jarg1;
42084   if (!argp1) {
42085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42086     return 0;
42087   }
42088   arg1 = *argp1;
42089   {
42090     try {
42091       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
42092     } CALL_CATCH_EXCEPTION(0);
42093   }
42094
42095   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
42096   return jresult;
42097 }
42098
42099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
42100   int jresult ;
42101   int result;
42102
42103   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
42104   jresult = (int)result;
42105   return jresult;
42106 }
42107
42108
42109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
42110   int jresult ;
42111   int result;
42112
42113   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
42114   jresult = (int)result;
42115   return jresult;
42116 }
42117
42118
42119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
42120   int jresult ;
42121   int result;
42122
42123   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
42124   jresult = (int)result;
42125   return jresult;
42126 }
42127
42128
42129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
42130   void * jresult ;
42131   Dali::Toolkit::ImageView::Property *result = 0 ;
42132
42133   {
42134     try {
42135       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
42136     } CALL_CATCH_EXCEPTION(0);
42137   }
42138
42139   jresult = (void *)result;
42140   return jresult;
42141 }
42142
42143
42144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
42145   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
42146
42147   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
42148   {
42149     try {
42150       delete arg1;
42151     } CALL_CATCH_EXCEPTION();
42152   }
42153
42154 }
42155
42156
42157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
42158   void * jresult ;
42159   Dali::Toolkit::ImageView *result = 0 ;
42160
42161   {
42162     try {
42163       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
42164     } CALL_CATCH_EXCEPTION(0);
42165   }
42166
42167   jresult = (void *)result;
42168   return jresult;
42169 }
42170
42171
42172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
42173   void * jresult ;
42174   Dali::Toolkit::ImageView result;
42175
42176   {
42177     try {
42178       result = Dali::Toolkit::ImageView::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
42179     } CALL_CATCH_EXCEPTION(0);
42180   }
42181
42182   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
42183   return jresult;
42184 }
42185
42186
42187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
42188   void * jresult ;
42189   std::string *arg1 = 0 ;
42190   Dali::Toolkit::ImageView result;
42191
42192   if (!jarg1) {
42193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42194     return 0;
42195   }
42196   std::string arg1_str(jarg1);
42197   arg1 = &arg1_str;
42198   {
42199     try {
42200       result = Dali::Toolkit::ImageView::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS, (std::string const &)*arg1);
42201     } CALL_CATCH_EXCEPTION(0);
42202   }
42203
42204   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
42205
42206   //argout typemap for const std::string&
42207
42208   return jresult;
42209 }
42210
42211
42212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
42213   void * jresult ;
42214   std::string *arg1 = 0 ;
42215   Dali::ImageDimensions arg2 ;
42216   Dali::ImageDimensions *argp2 ;
42217   Dali::Toolkit::ImageView result;
42218
42219   if (!jarg1) {
42220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42221     return 0;
42222   }
42223   std::string arg1_str(jarg1);
42224   arg1 = &arg1_str;
42225   argp2 = (Dali::ImageDimensions *)jarg2;
42226   if (!argp2) {
42227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42228     return 0;
42229   }
42230   arg2 = *argp2;
42231   {
42232     try {
42233       result = Dali::Toolkit::ImageView::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS, (std::string const &)*arg1,arg2);
42234     } CALL_CATCH_EXCEPTION(0);
42235   }
42236
42237   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
42238
42239   //argout typemap for const std::string&
42240
42241   return jresult;
42242 }
42243
42244
42245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
42246   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
42247
42248   arg1 = (Dali::Toolkit::ImageView *)jarg1;
42249   {
42250     try {
42251       delete arg1;
42252     } CALL_CATCH_EXCEPTION();
42253   }
42254
42255 }
42256
42257
42258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
42259   void * jresult ;
42260   Dali::Toolkit::ImageView *arg1 = 0 ;
42261   Dali::Toolkit::ImageView *result = 0 ;
42262
42263   arg1 = (Dali::Toolkit::ImageView *)jarg1;
42264   if (!arg1) {
42265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
42266     return 0;
42267   }
42268   {
42269     try {
42270       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
42271     } CALL_CATCH_EXCEPTION(0);
42272   }
42273
42274   jresult = (void *)result;
42275   return jresult;
42276 }
42277
42278
42279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
42280   void * jresult ;
42281   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
42282   Dali::Toolkit::ImageView *arg2 = 0 ;
42283   Dali::Toolkit::ImageView *result = 0 ;
42284
42285   arg1 = (Dali::Toolkit::ImageView *)jarg1;
42286   arg2 = (Dali::Toolkit::ImageView *)jarg2;
42287   if (!arg2) {
42288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
42289     return 0;
42290   }
42291   {
42292     try {
42293       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
42294     } CALL_CATCH_EXCEPTION(0);
42295   }
42296
42297   jresult = (void *)result;
42298   return jresult;
42299 }
42300
42301
42302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
42303   void * jresult ;
42304   Dali::BaseHandle arg1 ;
42305   Dali::BaseHandle *argp1 ;
42306   Dali::Toolkit::ImageView result;
42307
42308   argp1 = (Dali::BaseHandle *)jarg1;
42309   if (!argp1) {
42310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42311     return 0;
42312   }
42313   arg1 = *argp1;
42314   {
42315     try {
42316       result = Dali::Toolkit::ImageView::DownCast(arg1);
42317     } CALL_CATCH_EXCEPTION(0);
42318   }
42319
42320   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
42321   return jresult;
42322 }
42323
42324
42325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
42326   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
42327   std::string *arg2 = 0 ;
42328
42329   arg1 = (Dali::Toolkit::ImageView *)jarg1;
42330   if (!jarg2) {
42331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42332     return ;
42333   }
42334   std::string arg2_str(jarg2);
42335   arg2 = &arg2_str;
42336   {
42337     try {
42338       (arg1)->SetImage((std::string const &)*arg2);
42339     } CALL_CATCH_EXCEPTION();
42340   }
42341
42342
42343   //argout typemap for const std::string&
42344
42345 }
42346
42347
42348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
42349   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
42350   std::string *arg2 = 0 ;
42351   Dali::ImageDimensions arg3 ;
42352   Dali::ImageDimensions *argp3 ;
42353
42354   arg1 = (Dali::Toolkit::ImageView *)jarg1;
42355   if (!jarg2) {
42356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42357     return ;
42358   }
42359   std::string arg2_str(jarg2);
42360   arg2 = &arg2_str;
42361   argp3 = (Dali::ImageDimensions *)jarg3;
42362   if (!argp3) {
42363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42364     return ;
42365   }
42366   arg3 = *argp3;
42367   {
42368     try {
42369       (arg1)->SetImage((std::string const &)*arg2,arg3);
42370     } CALL_CATCH_EXCEPTION();
42371   }
42372
42373
42374   //argout typemap for const std::string&
42375
42376 }
42377
42378
42379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
42380   int jresult ;
42381   int result;
42382
42383   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
42384   jresult = (int)result;
42385   return jresult;
42386 }
42387
42388
42389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
42390   int jresult ;
42391   int result;
42392
42393   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
42394   jresult = (int)result;
42395   return jresult;
42396 }
42397
42398
42399 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
42400   int jresult ;
42401   int result;
42402
42403   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
42404   jresult = (int)result;
42405   return jresult;
42406 }
42407
42408
42409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
42410   int jresult ;
42411   int result;
42412
42413   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
42414   jresult = (int)result;
42415   return jresult;
42416 }
42417
42418
42419 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
42420   int jresult ;
42421   int result;
42422
42423   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
42424   jresult = (int)result;
42425   return jresult;
42426 }
42427
42428
42429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
42430   int jresult ;
42431   int result;
42432
42433   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
42434   jresult = (int)result;
42435   return jresult;
42436 }
42437
42438
42439 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
42440   int jresult ;
42441   int result;
42442
42443   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
42444   jresult = (int)result;
42445   return jresult;
42446 }
42447
42448
42449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
42450   int jresult ;
42451   int result;
42452
42453   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
42454   jresult = (int)result;
42455   return jresult;
42456 }
42457
42458
42459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
42460   int jresult ;
42461   int result;
42462
42463   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
42464   jresult = (int)result;
42465   return jresult;
42466 }
42467
42468
42469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
42470   void * jresult ;
42471   Dali::Toolkit::ScrollBar::Property *result = 0 ;
42472
42473   {
42474     try {
42475       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
42476     } CALL_CATCH_EXCEPTION(0);
42477   }
42478
42479   jresult = (void *)result;
42480   return jresult;
42481 }
42482
42483
42484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
42485   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
42486
42487   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
42488   {
42489     try {
42490       delete arg1;
42491     } CALL_CATCH_EXCEPTION();
42492   }
42493
42494 }
42495
42496
42497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
42498   void * jresult ;
42499   Dali::Toolkit::ScrollBar *result = 0 ;
42500
42501   {
42502     try {
42503       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
42504     } CALL_CATCH_EXCEPTION(0);
42505   }
42506
42507   jresult = (void *)result;
42508   return jresult;
42509 }
42510
42511
42512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
42513   void * jresult ;
42514   Dali::Toolkit::ScrollBar *arg1 = 0 ;
42515   Dali::Toolkit::ScrollBar *result = 0 ;
42516
42517   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42518   if (!arg1) {
42519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
42520     return 0;
42521   }
42522   {
42523     try {
42524       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
42525     } CALL_CATCH_EXCEPTION(0);
42526   }
42527
42528   jresult = (void *)result;
42529   return jresult;
42530 }
42531
42532
42533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
42534   void * jresult ;
42535   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42536   Dali::Toolkit::ScrollBar *arg2 = 0 ;
42537   Dali::Toolkit::ScrollBar *result = 0 ;
42538
42539   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42540   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
42541   if (!arg2) {
42542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
42543     return 0;
42544   }
42545   {
42546     try {
42547       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
42548     } CALL_CATCH_EXCEPTION(0);
42549   }
42550
42551   jresult = (void *)result;
42552   return jresult;
42553 }
42554
42555
42556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
42557   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42558
42559   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42560   {
42561     try {
42562       delete arg1;
42563     } CALL_CATCH_EXCEPTION();
42564   }
42565
42566 }
42567
42568
42569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
42570   void * jresult ;
42571   Dali::Toolkit::ScrollBar::Direction arg1 ;
42572   Dali::Toolkit::ScrollBar result;
42573
42574   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
42575   {
42576     try {
42577       result = Dali::Toolkit::ScrollBar::New(arg1);
42578     } CALL_CATCH_EXCEPTION(0);
42579   }
42580
42581   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
42582   return jresult;
42583 }
42584
42585
42586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
42587   void * jresult ;
42588   Dali::Toolkit::ScrollBar result;
42589
42590   {
42591     try {
42592       result = Dali::Toolkit::ScrollBar::New();
42593     } CALL_CATCH_EXCEPTION(0);
42594   }
42595
42596   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
42597   return jresult;
42598 }
42599
42600
42601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
42602   void * jresult ;
42603   Dali::BaseHandle arg1 ;
42604   Dali::BaseHandle *argp1 ;
42605   Dali::Toolkit::ScrollBar result;
42606
42607   argp1 = (Dali::BaseHandle *)jarg1;
42608   if (!argp1) {
42609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42610     return 0;
42611   }
42612   arg1 = *argp1;
42613   {
42614     try {
42615       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
42616     } CALL_CATCH_EXCEPTION(0);
42617   }
42618
42619   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
42620   return jresult;
42621 }
42622
42623
42624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
42625   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42626   Dali::Handle arg2 ;
42627   Dali::Property::Index arg3 ;
42628   Dali::Property::Index arg4 ;
42629   Dali::Property::Index arg5 ;
42630   Dali::Property::Index arg6 ;
42631   Dali::Handle *argp2 ;
42632
42633   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42634   argp2 = (Dali::Handle *)jarg2;
42635   if (!argp2) {
42636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
42637     return ;
42638   }
42639   arg2 = *argp2;
42640   arg3 = (Dali::Property::Index)jarg3;
42641   arg4 = (Dali::Property::Index)jarg4;
42642   arg5 = (Dali::Property::Index)jarg5;
42643   arg6 = (Dali::Property::Index)jarg6;
42644   {
42645     try {
42646       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
42647     } CALL_CATCH_EXCEPTION();
42648   }
42649
42650 }
42651
42652
42653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
42654   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42655   Dali::Actor arg2 ;
42656   Dali::Actor *argp2 ;
42657
42658   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42659   argp2 = (Dali::Actor *)jarg2;
42660   if (!argp2) {
42661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
42662     return ;
42663   }
42664   arg2 = *argp2;
42665   {
42666     try {
42667       (arg1)->SetScrollIndicator(arg2);
42668     } CALL_CATCH_EXCEPTION();
42669   }
42670
42671 }
42672
42673
42674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
42675   void * jresult ;
42676   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42677   Dali::Actor result;
42678
42679   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42680   {
42681     try {
42682       result = (arg1)->GetScrollIndicator();
42683     } CALL_CATCH_EXCEPTION(0);
42684   }
42685
42686   jresult = new Dali::Actor((const Dali::Actor &)result);
42687   return jresult;
42688 }
42689
42690
42691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
42692   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42693   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
42694
42695   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42696   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
42697   if (!arg2) {
42698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
42699     return ;
42700   }
42701   {
42702     try {
42703       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
42704     } CALL_CATCH_EXCEPTION();
42705   }
42706
42707 }
42708
42709
42710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
42711   void * jresult ;
42712   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42713
42714   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42715   {
42716     try {
42717       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()));
42718     } CALL_CATCH_EXCEPTION(0);
42719   }
42720   return jresult;
42721 }
42722
42723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
42724   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42725   Dali::Toolkit::ScrollBar::Direction arg2 ;
42726
42727   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42728   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
42729   {
42730     try {
42731       (arg1)->SetScrollDirection(arg2);
42732     } CALL_CATCH_EXCEPTION();
42733   }
42734
42735 }
42736
42737
42738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
42739   int jresult ;
42740   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42741   Dali::Toolkit::ScrollBar::Direction result;
42742
42743   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42744   {
42745     try {
42746       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
42747     } CALL_CATCH_EXCEPTION(0);
42748   }
42749
42750   jresult = (int)result;
42751   return jresult;
42752 }
42753
42754
42755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
42756   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42757   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
42758
42759   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42760   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
42761   {
42762     try {
42763       (arg1)->SetIndicatorHeightPolicy(arg2);
42764     } CALL_CATCH_EXCEPTION();
42765   }
42766
42767 }
42768
42769
42770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
42771   int jresult ;
42772   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42773   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
42774
42775   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42776   {
42777     try {
42778       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
42779     } CALL_CATCH_EXCEPTION(0);
42780   }
42781
42782   jresult = (int)result;
42783   return jresult;
42784 }
42785
42786
42787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
42788   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42789   float arg2 ;
42790
42791   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42792   arg2 = (float)jarg2;
42793   {
42794     try {
42795       (arg1)->SetIndicatorFixedHeight(arg2);
42796     } CALL_CATCH_EXCEPTION();
42797   }
42798
42799 }
42800
42801
42802 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
42803   float jresult ;
42804   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42805   float result;
42806
42807   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42808   {
42809     try {
42810       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
42811     } CALL_CATCH_EXCEPTION(0);
42812   }
42813
42814   jresult = result;
42815   return jresult;
42816 }
42817
42818
42819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
42820   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42821   float arg2 ;
42822
42823   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42824   arg2 = (float)jarg2;
42825   {
42826     try {
42827       (arg1)->SetIndicatorShowDuration(arg2);
42828     } CALL_CATCH_EXCEPTION();
42829   }
42830
42831 }
42832
42833
42834 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
42835   float jresult ;
42836   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42837   float result;
42838
42839   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42840   {
42841     try {
42842       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
42843     } CALL_CATCH_EXCEPTION(0);
42844   }
42845
42846   jresult = result;
42847   return jresult;
42848 }
42849
42850
42851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
42852   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42853   float arg2 ;
42854
42855   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42856   arg2 = (float)jarg2;
42857   {
42858     try {
42859       (arg1)->SetIndicatorHideDuration(arg2);
42860     } CALL_CATCH_EXCEPTION();
42861   }
42862
42863 }
42864
42865
42866 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
42867   float jresult ;
42868   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42869   float result;
42870
42871   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42872   {
42873     try {
42874       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
42875     } CALL_CATCH_EXCEPTION(0);
42876   }
42877
42878   jresult = result;
42879   return jresult;
42880 }
42881
42882
42883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
42884   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42885
42886   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42887   {
42888     try {
42889       (arg1)->ShowIndicator();
42890     } CALL_CATCH_EXCEPTION();
42891   }
42892
42893 }
42894
42895
42896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
42897   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42898
42899   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42900   {
42901     try {
42902       (arg1)->HideIndicator();
42903     } CALL_CATCH_EXCEPTION();
42904   }
42905
42906 }
42907
42908
42909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
42910   void * jresult ;
42911   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42912   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
42913
42914   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42915   {
42916     try {
42917       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
42918     } CALL_CATCH_EXCEPTION(0);
42919   }
42920
42921   jresult = (void *)result;
42922   return jresult;
42923 }
42924
42925
42926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
42927   void * jresult ;
42928   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
42929   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
42930
42931   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
42932   {
42933     try {
42934       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
42935     } CALL_CATCH_EXCEPTION(0);
42936   }
42937
42938   jresult = (void *)result;
42939   return jresult;
42940 }
42941
42942
42943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
42944   int jresult ;
42945   int result;
42946
42947   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
42948   jresult = (int)result;
42949   return jresult;
42950 }
42951
42952
42953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
42954   int jresult ;
42955   int result;
42956
42957   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
42958   jresult = (int)result;
42959   return jresult;
42960 }
42961
42962
42963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
42964   int jresult ;
42965   int result;
42966
42967   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
42968   jresult = (int)result;
42969   return jresult;
42970 }
42971
42972
42973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
42974   int jresult ;
42975   int result;
42976
42977   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
42978   jresult = (int)result;
42979   return jresult;
42980 }
42981
42982
42983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
42984   int jresult ;
42985   int result;
42986
42987   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
42988   jresult = (int)result;
42989   return jresult;
42990 }
42991
42992
42993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
42994   int jresult ;
42995   int result;
42996
42997   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
42998   jresult = (int)result;
42999   return jresult;
43000 }
43001
43002
43003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
43004   int jresult ;
43005   int result;
43006
43007   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
43008   jresult = (int)result;
43009   return jresult;
43010 }
43011
43012
43013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
43014   int jresult ;
43015   int result;
43016
43017   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
43018   jresult = (int)result;
43019   return jresult;
43020 }
43021
43022
43023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
43024   int jresult ;
43025   int result;
43026
43027   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
43028   jresult = (int)result;
43029   return jresult;
43030 }
43031
43032
43033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
43034   int jresult ;
43035   int result;
43036
43037   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
43038   jresult = (int)result;
43039   return jresult;
43040 }
43041
43042
43043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
43044   int jresult ;
43045   int result;
43046
43047   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
43048   jresult = (int)result;
43049   return jresult;
43050 }
43051
43052
43053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
43054   int jresult ;
43055   int result;
43056
43057   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
43058   jresult = (int)result;
43059   return jresult;
43060 }
43061
43062
43063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
43064   int jresult ;
43065   int result;
43066
43067   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
43068   jresult = (int)result;
43069   return jresult;
43070 }
43071
43072
43073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
43074   int jresult ;
43075   int result;
43076
43077   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
43078   jresult = (int)result;
43079   return jresult;
43080 }
43081
43082
43083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
43084   void * jresult ;
43085   Dali::Toolkit::Scrollable::Property *result = 0 ;
43086
43087   {
43088     try {
43089       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
43090     } CALL_CATCH_EXCEPTION(0);
43091   }
43092
43093   jresult = (void *)result;
43094   return jresult;
43095 }
43096
43097
43098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
43099   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
43100
43101   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
43102   {
43103     try {
43104       delete arg1;
43105     } CALL_CATCH_EXCEPTION();
43106   }
43107
43108 }
43109
43110
43111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
43112   void * jresult ;
43113   Dali::Toolkit::Scrollable *result = 0 ;
43114
43115   {
43116     try {
43117       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
43118     } CALL_CATCH_EXCEPTION(0);
43119   }
43120
43121   jresult = (void *)result;
43122   return jresult;
43123 }
43124
43125
43126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
43127   void * jresult ;
43128   Dali::Toolkit::Scrollable *arg1 = 0 ;
43129   Dali::Toolkit::Scrollable *result = 0 ;
43130
43131   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
43132   if (!arg1) {
43133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
43134     return 0;
43135   }
43136   {
43137     try {
43138       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
43139     } CALL_CATCH_EXCEPTION(0);
43140   }
43141
43142   jresult = (void *)result;
43143   return jresult;
43144 }
43145
43146
43147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
43148   void * jresult ;
43149   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
43150   Dali::Toolkit::Scrollable *arg2 = 0 ;
43151   Dali::Toolkit::Scrollable *result = 0 ;
43152
43153   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
43154   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
43155   if (!arg2) {
43156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
43157     return 0;
43158   }
43159   {
43160     try {
43161       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
43162     } CALL_CATCH_EXCEPTION(0);
43163   }
43164
43165   jresult = (void *)result;
43166   return jresult;
43167 }
43168
43169
43170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
43171   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
43172
43173   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
43174   {
43175     try {
43176       delete arg1;
43177     } CALL_CATCH_EXCEPTION();
43178   }
43179
43180 }
43181
43182
43183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
43184   void * jresult ;
43185   Dali::BaseHandle arg1 ;
43186   Dali::BaseHandle *argp1 ;
43187   Dali::Toolkit::Scrollable result;
43188
43189   argp1 = (Dali::BaseHandle *)jarg1;
43190   if (!argp1) {
43191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43192     return 0;
43193   }
43194   arg1 = *argp1;
43195   {
43196     try {
43197       result = Dali::Toolkit::Scrollable::DownCast(arg1);
43198     } CALL_CATCH_EXCEPTION(0);
43199   }
43200
43201   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
43202   return jresult;
43203 }
43204
43205
43206 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
43207   bool jresult ;
43208   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
43209   bool result;
43210
43211   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
43212   {
43213     try {
43214       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
43215     } CALL_CATCH_EXCEPTION(0);
43216   }
43217
43218   jresult = result;
43219   return jresult;
43220 }
43221
43222
43223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, bool jarg2) {
43224   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
43225   bool arg2 ;
43226
43227   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
43228   arg2 = jarg2 ? true : false;
43229   {
43230     try {
43231       (arg1)->SetOvershootEnabled(arg2);
43232     } CALL_CATCH_EXCEPTION();
43233   }
43234
43235 }
43236
43237
43238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
43239   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
43240   Dali::Vector4 *arg2 = 0 ;
43241
43242   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
43243   arg2 = (Dali::Vector4 *)jarg2;
43244   if (!arg2) {
43245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
43246     return ;
43247   }
43248   {
43249     try {
43250       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
43251     } CALL_CATCH_EXCEPTION();
43252   }
43253
43254 }
43255
43256
43257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
43258   void * jresult ;
43259   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
43260   Dali::Vector4 result;
43261
43262   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
43263   {
43264     try {
43265       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
43266     } CALL_CATCH_EXCEPTION(0);
43267   }
43268
43269   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43270   return jresult;
43271 }
43272
43273
43274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
43275   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
43276   float arg2 ;
43277
43278   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
43279   arg2 = (float)jarg2;
43280   {
43281     try {
43282       (arg1)->SetOvershootAnimationSpeed(arg2);
43283     } CALL_CATCH_EXCEPTION();
43284   }
43285
43286 }
43287
43288
43289 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
43290   float jresult ;
43291   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
43292   float result;
43293
43294   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
43295   {
43296     try {
43297       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
43298     } CALL_CATCH_EXCEPTION(0);
43299   }
43300
43301   jresult = result;
43302   return jresult;
43303 }
43304
43305
43306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
43307   void * jresult ;
43308   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
43309   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
43310
43311   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
43312   {
43313     try {
43314       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
43315     } CALL_CATCH_EXCEPTION(0);
43316   }
43317
43318   jresult = (void *)result;
43319   return jresult;
43320 }
43321
43322
43323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
43324   void * jresult ;
43325   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
43326   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
43327
43328   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
43329   {
43330     try {
43331       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
43332     } CALL_CATCH_EXCEPTION(0);
43333   }
43334
43335   jresult = (void *)result;
43336   return jresult;
43337 }
43338
43339
43340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
43341   void * jresult ;
43342   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
43343   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
43344
43345   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
43346   {
43347     try {
43348       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
43349     } CALL_CATCH_EXCEPTION(0);
43350   }
43351
43352   jresult = (void *)result;
43353   return jresult;
43354 }
43355
43356
43357 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
43358   bool jresult ;
43359   Dali::Toolkit::ControlOrientation::Type arg1 ;
43360   bool result;
43361
43362   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
43363   {
43364     try {
43365       result = (bool)Dali::Toolkit::IsVertical(arg1);
43366     } CALL_CATCH_EXCEPTION(0);
43367   }
43368
43369   jresult = result;
43370   return jresult;
43371 }
43372
43373
43374 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
43375   bool jresult ;
43376   Dali::Toolkit::ControlOrientation::Type arg1 ;
43377   bool result;
43378
43379   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
43380   {
43381     try {
43382       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
43383     } CALL_CATCH_EXCEPTION(0);
43384   }
43385
43386   jresult = result;
43387   return jresult;
43388 }
43389
43390
43391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
43392   void * jresult ;
43393   unsigned int arg1 ;
43394   unsigned int arg2 ;
43395   Dali::Toolkit::ItemRange *result = 0 ;
43396
43397   arg1 = (unsigned int)jarg1;
43398   arg2 = (unsigned int)jarg2;
43399   {
43400     try {
43401       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
43402     } CALL_CATCH_EXCEPTION(0);
43403   }
43404
43405   jresult = (void *)result;
43406   return jresult;
43407 }
43408
43409
43410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
43411   void * jresult ;
43412   Dali::Toolkit::ItemRange *arg1 = 0 ;
43413   Dali::Toolkit::ItemRange *result = 0 ;
43414
43415   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
43416   if (!arg1) {
43417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
43418     return 0;
43419   }
43420   {
43421     try {
43422       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
43423     } CALL_CATCH_EXCEPTION(0);
43424   }
43425
43426   jresult = (void *)result;
43427   return jresult;
43428 }
43429
43430
43431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
43432   void * jresult ;
43433   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
43434   Dali::Toolkit::ItemRange *arg2 = 0 ;
43435   Dali::Toolkit::ItemRange *result = 0 ;
43436
43437   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
43438   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
43439   if (!arg2) {
43440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
43441     return 0;
43442   }
43443   {
43444     try {
43445       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
43446     } CALL_CATCH_EXCEPTION(0);
43447   }
43448
43449   jresult = (void *)result;
43450   return jresult;
43451 }
43452
43453
43454 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
43455   bool jresult ;
43456   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
43457   unsigned int arg2 ;
43458   bool result;
43459
43460   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
43461   arg2 = (unsigned int)jarg2;
43462   {
43463     try {
43464       result = (bool)(arg1)->Within(arg2);
43465     } CALL_CATCH_EXCEPTION(0);
43466   }
43467
43468   jresult = result;
43469   return jresult;
43470 }
43471
43472
43473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
43474   void * jresult ;
43475   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
43476   Dali::Toolkit::ItemRange *arg2 = 0 ;
43477   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
43478
43479   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
43480   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
43481   if (!arg2) {
43482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
43483     return 0;
43484   }
43485   {
43486     try {
43487       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
43488     } CALL_CATCH_EXCEPTION(0);
43489   }
43490
43491   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
43492   return jresult;
43493 }
43494
43495
43496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
43497   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
43498   unsigned int arg2 ;
43499
43500   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
43501   arg2 = (unsigned int)jarg2;
43502   if (arg1) (arg1)->begin = arg2;
43503 }
43504
43505
43506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
43507   unsigned int jresult ;
43508   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
43509   unsigned int result;
43510
43511   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
43512   result = (unsigned int) ((arg1)->begin);
43513   jresult = result;
43514   return jresult;
43515 }
43516
43517
43518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
43519   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
43520   unsigned int arg2 ;
43521
43522   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
43523   arg2 = (unsigned int)jarg2;
43524   if (arg1) (arg1)->end = arg2;
43525 }
43526
43527
43528 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
43529   unsigned int jresult ;
43530   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
43531   unsigned int result;
43532
43533   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
43534   result = (unsigned int) ((arg1)->end);
43535   jresult = result;
43536   return jresult;
43537 }
43538
43539
43540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
43541   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
43542
43543   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
43544   {
43545     try {
43546       delete arg1;
43547     } CALL_CATCH_EXCEPTION();
43548   }
43549
43550 }
43551
43552
43553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
43554   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43555
43556   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43557   {
43558     try {
43559       delete arg1;
43560     } CALL_CATCH_EXCEPTION();
43561   }
43562
43563 }
43564
43565
43566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
43567   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43568   Dali::Toolkit::ControlOrientation::Type arg2 ;
43569
43570   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43571   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
43572   {
43573     try {
43574       (arg1)->SetOrientation(arg2);
43575     } CALL_CATCH_EXCEPTION();
43576   }
43577
43578 }
43579
43580
43581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
43582   int jresult ;
43583   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43584   Dali::Toolkit::ControlOrientation::Type result;
43585
43586   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43587   {
43588     try {
43589       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
43590     } CALL_CATCH_EXCEPTION(0);
43591   }
43592
43593   jresult = (int)result;
43594   return jresult;
43595 }
43596
43597
43598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
43599   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43600   Dali::Property::Map *arg2 = 0 ;
43601
43602   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43603   arg2 = (Dali::Property::Map *)jarg2;
43604   if (!arg2) {
43605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
43606     return ;
43607   }
43608   {
43609     try {
43610       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
43611     } CALL_CATCH_EXCEPTION();
43612   }
43613
43614 }
43615
43616
43617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
43618   void * jresult ;
43619   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43620   Dali::Property::Map result;
43621
43622   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43623   {
43624     try {
43625       result = (arg1)->GetLayoutProperties();
43626     } CALL_CATCH_EXCEPTION(0);
43627   }
43628
43629   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
43630   return jresult;
43631 }
43632
43633
43634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
43635   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43636   unsigned int arg2 ;
43637   Dali::Vector3 *arg3 = 0 ;
43638   Dali::Vector3 *arg4 = 0 ;
43639
43640   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43641   arg2 = (unsigned int)jarg2;
43642   arg3 = (Dali::Vector3 *)jarg3;
43643   if (!arg3) {
43644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43645     return ;
43646   }
43647   arg4 = (Dali::Vector3 *)jarg4;
43648   if (!arg4) {
43649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43650     return ;
43651   }
43652   {
43653     try {
43654       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
43655     } CALL_CATCH_EXCEPTION();
43656   }
43657
43658 }
43659
43660
43661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
43662   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43663   Dali::Vector3 *arg2 = 0 ;
43664
43665   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43666   arg2 = (Dali::Vector3 *)jarg2;
43667   if (!arg2) {
43668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43669     return ;
43670   }
43671   {
43672     try {
43673       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
43674     } CALL_CATCH_EXCEPTION();
43675   }
43676
43677 }
43678
43679
43680 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
43681   float jresult ;
43682   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43683   unsigned int arg2 ;
43684   Dali::Vector3 arg3 ;
43685   Dali::Vector3 *argp3 ;
43686   float result;
43687
43688   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43689   arg2 = (unsigned int)jarg2;
43690   argp3 = (Dali::Vector3 *)jarg3;
43691   if (!argp3) {
43692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
43693     return 0;
43694   }
43695   arg3 = *argp3;
43696   {
43697     try {
43698       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
43699     } CALL_CATCH_EXCEPTION(0);
43700   }
43701
43702   jresult = result;
43703   return jresult;
43704 }
43705
43706
43707 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
43708   float jresult ;
43709   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43710   float arg2 ;
43711   float result;
43712
43713   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43714   arg2 = (float)jarg2;
43715   {
43716     try {
43717       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
43718     } CALL_CATCH_EXCEPTION(0);
43719   }
43720
43721   jresult = result;
43722   return jresult;
43723 }
43724
43725
43726 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
43727   float jresult ;
43728   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43729   unsigned int arg2 ;
43730   float result;
43731
43732   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43733   arg2 = (unsigned int)jarg2;
43734   {
43735     try {
43736       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
43737     } CALL_CATCH_EXCEPTION(0);
43738   }
43739
43740   jresult = result;
43741   return jresult;
43742 }
43743
43744
43745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
43746   void * jresult ;
43747   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43748   float arg2 ;
43749   Dali::Vector3 arg3 ;
43750   Dali::Vector3 *argp3 ;
43751   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
43752
43753   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43754   arg2 = (float)jarg2;
43755   argp3 = (Dali::Vector3 *)jarg3;
43756   if (!argp3) {
43757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
43758     return 0;
43759   }
43760   arg3 = *argp3;
43761   {
43762     try {
43763       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
43764     } CALL_CATCH_EXCEPTION(0);
43765   }
43766
43767   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
43768   return jresult;
43769 }
43770
43771
43772 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
43773   float jresult ;
43774   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43775   int arg2 ;
43776   float arg3 ;
43777   Dali::Vector3 *arg4 = 0 ;
43778   float result;
43779
43780   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43781   arg2 = (int)jarg2;
43782   arg3 = (float)jarg3;
43783   arg4 = (Dali::Vector3 *)jarg4;
43784   if (!arg4) {
43785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43786     return 0;
43787   }
43788   {
43789     try {
43790       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
43791     } CALL_CATCH_EXCEPTION(0);
43792   }
43793
43794   jresult = result;
43795   return jresult;
43796 }
43797
43798
43799 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
43800   unsigned int jresult ;
43801   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43802   Dali::Vector3 arg2 ;
43803   Dali::Vector3 *argp2 ;
43804   unsigned int result;
43805
43806   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43807   argp2 = (Dali::Vector3 *)jarg2;
43808   if (!argp2) {
43809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
43810     return 0;
43811   }
43812   arg2 = *argp2;
43813   {
43814     try {
43815       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
43816     } CALL_CATCH_EXCEPTION(0);
43817   }
43818
43819   jresult = result;
43820   return jresult;
43821 }
43822
43823
43824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
43825   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43826   unsigned int arg2 ;
43827   Dali::Vector3 *arg3 = 0 ;
43828   Dali::Vector3 *arg4 = 0 ;
43829
43830   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43831   arg2 = (unsigned int)jarg2;
43832   arg3 = (Dali::Vector3 *)jarg3;
43833   if (!arg3) {
43834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43835     return ;
43836   }
43837   arg4 = (Dali::Vector3 *)jarg4;
43838   if (!arg4) {
43839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43840     return ;
43841   }
43842   {
43843     try {
43844       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
43845     } CALL_CATCH_EXCEPTION();
43846   }
43847
43848 }
43849
43850
43851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
43852   void * jresult ;
43853   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43854   Dali::Degree result;
43855
43856   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43857   {
43858     try {
43859       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
43860     } CALL_CATCH_EXCEPTION(0);
43861   }
43862
43863   jresult = new Dali::Degree((const Dali::Degree &)result);
43864   return jresult;
43865 }
43866
43867
43868 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
43869   float jresult ;
43870   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43871   float result;
43872
43873   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43874   {
43875     try {
43876       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
43877     } CALL_CATCH_EXCEPTION(0);
43878   }
43879
43880   jresult = result;
43881   return jresult;
43882 }
43883
43884
43885 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
43886   float jresult ;
43887   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43888   float result;
43889
43890   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43891   {
43892     try {
43893       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
43894     } CALL_CATCH_EXCEPTION(0);
43895   }
43896
43897   jresult = result;
43898   return jresult;
43899 }
43900
43901
43902 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
43903   float jresult ;
43904   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43905   float result;
43906
43907   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43908   {
43909     try {
43910       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
43911     } CALL_CATCH_EXCEPTION(0);
43912   }
43913
43914   jresult = result;
43915   return jresult;
43916 }
43917
43918
43919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, bool jarg5) {
43920   int jresult ;
43921   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43922   int arg2 ;
43923   int arg3 ;
43924   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
43925   bool arg5 ;
43926   int result;
43927
43928   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43929   arg2 = (int)jarg2;
43930   arg3 = (int)jarg3;
43931   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
43932   arg5 = jarg5 ? true : false;
43933   {
43934     try {
43935       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
43936     } CALL_CATCH_EXCEPTION(0);
43937   }
43938
43939   jresult = result;
43940   return jresult;
43941 }
43942
43943
43944 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
43945   float jresult ;
43946   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43947   float result;
43948
43949   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43950   {
43951     try {
43952       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
43953     } CALL_CATCH_EXCEPTION(0);
43954   }
43955
43956   jresult = result;
43957   return jresult;
43958 }
43959
43960
43961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
43962   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43963   Dali::Actor *arg2 = 0 ;
43964   int arg3 ;
43965   Dali::Vector3 *arg4 = 0 ;
43966   Dali::Actor *arg5 = 0 ;
43967
43968   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
43969   arg2 = (Dali::Actor *)jarg2;
43970   if (!arg2) {
43971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
43972     return ;
43973   }
43974   arg3 = (int)jarg3;
43975   arg4 = (Dali::Vector3 *)jarg4;
43976   if (!arg4) {
43977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43978     return ;
43979   }
43980   arg5 = (Dali::Actor *)jarg5;
43981   if (!arg5) {
43982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
43983     return ;
43984   }
43985   {
43986     try {
43987       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
43988     } CALL_CATCH_EXCEPTION();
43989   }
43990
43991 }
43992
43993
43994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
43995   void * jresult ;
43996   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
43997   int arg2 ;
43998   float arg3 ;
43999   Dali::Vector3 *arg4 = 0 ;
44000   Dali::Vector3 result;
44001
44002   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
44003   arg2 = (int)jarg2;
44004   arg3 = (float)jarg3;
44005   arg4 = (Dali::Vector3 *)jarg4;
44006   if (!arg4) {
44007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44008     return 0;
44009   }
44010   {
44011     try {
44012       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
44013     } CALL_CATCH_EXCEPTION(0);
44014   }
44015
44016   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
44017   return jresult;
44018 }
44019
44020
44021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
44022   void * jresult ;
44023   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
44024   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
44025
44026   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
44027   {
44028     try {
44029       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
44030     } CALL_CATCH_EXCEPTION(0);
44031   }
44032
44033   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
44034   return jresult;
44035 }
44036
44037
44038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
44039   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
44040
44041   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
44042   {
44043     try {
44044       delete arg1;
44045     } CALL_CATCH_EXCEPTION();
44046   }
44047
44048 }
44049
44050
44051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
44052   unsigned int jresult ;
44053   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
44054   unsigned int result;
44055
44056   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
44057   {
44058     try {
44059       result = (unsigned int)(arg1)->GetNumberOfItems();
44060     } CALL_CATCH_EXCEPTION(0);
44061   }
44062
44063   jresult = result;
44064   return jresult;
44065 }
44066
44067
44068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
44069   void * jresult ;
44070   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
44071   unsigned int arg2 ;
44072   Dali::Actor result;
44073
44074   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
44075   arg2 = (unsigned int)jarg2;
44076   {
44077     try {
44078       result = (arg1)->NewItem(arg2);
44079     } CALL_CATCH_EXCEPTION(0);
44080   }
44081
44082   jresult = new Dali::Actor((const Dali::Actor &)result);
44083   return jresult;
44084 }
44085
44086
44087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
44088   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
44089   unsigned int arg2 ;
44090   Dali::Actor arg3 ;
44091   Dali::Actor *argp3 ;
44092
44093   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
44094   arg2 = (unsigned int)jarg2;
44095   argp3 = (Dali::Actor *)jarg3;
44096   if (!argp3) {
44097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
44098     return ;
44099   }
44100   arg3 = *argp3;
44101   {
44102     try {
44103       (arg1)->ItemReleased(arg2,arg3);
44104     } CALL_CATCH_EXCEPTION();
44105   }
44106
44107 }
44108
44109
44110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
44111   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
44112   unsigned int arg2 ;
44113   Dali::Actor arg3 ;
44114   Dali::Actor *argp3 ;
44115
44116   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
44117   arg2 = (unsigned int)jarg2;
44118   argp3 = (Dali::Actor *)jarg3;
44119   if (!argp3) {
44120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
44121     return ;
44122   }
44123   arg3 = *argp3;
44124   {
44125     try {
44126       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
44127     } CALL_CATCH_EXCEPTION();
44128   }
44129
44130 }
44131
44132
44133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
44134   void * jresult ;
44135   Dali::Toolkit::ItemFactory *result = 0 ;
44136
44137   {
44138     try {
44139       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
44140     } CALL_CATCH_EXCEPTION(0);
44141   }
44142
44143   jresult = (void *)result;
44144   return jresult;
44145 }
44146
44147
44148 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) {
44149   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
44150   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
44151   if (director) {
44152     director->swig_connect_director(callback0, callback1, callback2);
44153   }
44154 }
44155
44156
44157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
44158   int jresult ;
44159   int result;
44160
44161   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
44162   jresult = (int)result;
44163   return jresult;
44164 }
44165
44166
44167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
44168   int jresult ;
44169   int result;
44170
44171   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
44172   jresult = (int)result;
44173   return jresult;
44174 }
44175
44176
44177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
44178   int jresult ;
44179   int result;
44180
44181   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
44182   jresult = (int)result;
44183   return jresult;
44184 }
44185
44186
44187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
44188   int jresult ;
44189   int result;
44190
44191   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
44192   jresult = (int)result;
44193   return jresult;
44194 }
44195
44196
44197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
44198   int jresult ;
44199   int result;
44200
44201   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
44202   jresult = (int)result;
44203   return jresult;
44204 }
44205
44206
44207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
44208   int jresult ;
44209   int result;
44210
44211   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
44212   jresult = (int)result;
44213   return jresult;
44214 }
44215
44216
44217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
44218   int jresult ;
44219   int result;
44220
44221   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
44222   jresult = (int)result;
44223   return jresult;
44224 }
44225
44226
44227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
44228   int jresult ;
44229   int result;
44230
44231   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
44232   jresult = (int)result;
44233   return jresult;
44234 }
44235
44236
44237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
44238   int jresult ;
44239   int result;
44240
44241   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
44242   jresult = (int)result;
44243   return jresult;
44244 }
44245
44246
44247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
44248   int jresult ;
44249   int result;
44250
44251   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
44252   jresult = (int)result;
44253   return jresult;
44254 }
44255
44256
44257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
44258   int jresult ;
44259   int result;
44260
44261   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
44262   jresult = (int)result;
44263   return jresult;
44264 }
44265
44266
44267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
44268   void * jresult ;
44269   Dali::Toolkit::ItemView::Property *result = 0 ;
44270
44271   {
44272     try {
44273       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
44274     } CALL_CATCH_EXCEPTION(0);
44275   }
44276
44277   jresult = (void *)result;
44278   return jresult;
44279 }
44280
44281
44282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
44283   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
44284
44285   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
44286   {
44287     try {
44288       delete arg1;
44289     } CALL_CATCH_EXCEPTION();
44290   }
44291
44292 }
44293
44294
44295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
44296   void * jresult ;
44297   Dali::Toolkit::ItemView *result = 0 ;
44298
44299   {
44300     try {
44301       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
44302     } CALL_CATCH_EXCEPTION(0);
44303   }
44304
44305   jresult = (void *)result;
44306   return jresult;
44307 }
44308
44309
44310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
44311   void * jresult ;
44312   Dali::Toolkit::ItemView *arg1 = 0 ;
44313   Dali::Toolkit::ItemView *result = 0 ;
44314
44315   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44316   if (!arg1) {
44317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
44318     return 0;
44319   }
44320   {
44321     try {
44322       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
44323     } CALL_CATCH_EXCEPTION(0);
44324   }
44325
44326   jresult = (void *)result;
44327   return jresult;
44328 }
44329
44330
44331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
44332   void * jresult ;
44333   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44334   Dali::Toolkit::ItemView *arg2 = 0 ;
44335   Dali::Toolkit::ItemView *result = 0 ;
44336
44337   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44338   arg2 = (Dali::Toolkit::ItemView *)jarg2;
44339   if (!arg2) {
44340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
44341     return 0;
44342   }
44343   {
44344     try {
44345       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
44346     } CALL_CATCH_EXCEPTION(0);
44347   }
44348
44349   jresult = (void *)result;
44350   return jresult;
44351 }
44352
44353
44354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
44355   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44356
44357   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44358   {
44359     try {
44360       delete arg1;
44361     } CALL_CATCH_EXCEPTION();
44362   }
44363
44364 }
44365
44366
44367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
44368   void * jresult ;
44369   Dali::Toolkit::ItemFactory *arg1 = 0 ;
44370   Dali::Toolkit::ItemView result;
44371
44372   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
44373   if (!arg1) {
44374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
44375     return 0;
44376   }
44377   {
44378     try {
44379       result = Dali::Toolkit::ItemView::New(*arg1);
44380     } CALL_CATCH_EXCEPTION(0);
44381   }
44382
44383   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
44384   return jresult;
44385 }
44386
44387
44388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
44389   void * jresult ;
44390   Dali::BaseHandle arg1 ;
44391   Dali::BaseHandle *argp1 ;
44392   Dali::Toolkit::ItemView result;
44393
44394   argp1 = (Dali::BaseHandle *)jarg1;
44395   if (!argp1) {
44396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44397     return 0;
44398   }
44399   arg1 = *argp1;
44400   {
44401     try {
44402       result = Dali::Toolkit::ItemView::DownCast(arg1);
44403     } CALL_CATCH_EXCEPTION(0);
44404   }
44405
44406   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
44407   return jresult;
44408 }
44409
44410
44411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
44412   unsigned int jresult ;
44413   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44414   unsigned int result;
44415
44416   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44417   {
44418     try {
44419       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
44420     } CALL_CATCH_EXCEPTION(0);
44421   }
44422
44423   jresult = result;
44424   return jresult;
44425 }
44426
44427
44428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
44429   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44430   Dali::Toolkit::ItemLayout *arg2 = 0 ;
44431
44432   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44433   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
44434   if (!arg2) {
44435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
44436     return ;
44437   }
44438   {
44439     try {
44440       (arg1)->AddLayout(*arg2);
44441     } CALL_CATCH_EXCEPTION();
44442   }
44443
44444 }
44445
44446
44447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
44448   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44449   unsigned int arg2 ;
44450
44451   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44452   arg2 = (unsigned int)jarg2;
44453   {
44454     try {
44455       (arg1)->RemoveLayout(arg2);
44456     } CALL_CATCH_EXCEPTION();
44457   }
44458
44459 }
44460
44461
44462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
44463   void * jresult ;
44464   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44465   unsigned int arg2 ;
44466   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
44467
44468   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44469   arg2 = (unsigned int)jarg2;
44470   {
44471     try {
44472       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
44473     } CALL_CATCH_EXCEPTION(0);
44474   }
44475
44476   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
44477   return jresult;
44478 }
44479
44480
44481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
44482   void * jresult ;
44483   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44484   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
44485
44486   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44487   {
44488     try {
44489       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
44490     } CALL_CATCH_EXCEPTION(0);
44491   }
44492
44493   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
44494   return jresult;
44495 }
44496
44497
44498 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
44499   float jresult ;
44500   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44501   Dali::Toolkit::ItemId arg2 ;
44502   float result;
44503
44504   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44505   arg2 = (Dali::Toolkit::ItemId)jarg2;
44506   {
44507     try {
44508       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
44509     } CALL_CATCH_EXCEPTION(0);
44510   }
44511
44512   jresult = result;
44513   return jresult;
44514 }
44515
44516
44517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
44518   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44519   unsigned int arg2 ;
44520   Dali::Vector3 arg3 ;
44521   float arg4 ;
44522   Dali::Vector3 *argp3 ;
44523
44524   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44525   arg2 = (unsigned int)jarg2;
44526   argp3 = (Dali::Vector3 *)jarg3;
44527   if (!argp3) {
44528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
44529     return ;
44530   }
44531   arg3 = *argp3;
44532   arg4 = (float)jarg4;
44533   {
44534     try {
44535       (arg1)->ActivateLayout(arg2,arg3,arg4);
44536     } CALL_CATCH_EXCEPTION();
44537   }
44538
44539 }
44540
44541
44542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
44543   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44544
44545   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44546   {
44547     try {
44548       (arg1)->DeactivateCurrentLayout();
44549     } CALL_CATCH_EXCEPTION();
44550   }
44551
44552 }
44553
44554
44555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
44556   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44557   float arg2 ;
44558
44559   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44560   arg2 = (float)jarg2;
44561   {
44562     try {
44563       (arg1)->SetMinimumSwipeSpeed(arg2);
44564     } CALL_CATCH_EXCEPTION();
44565   }
44566
44567 }
44568
44569
44570 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
44571   float jresult ;
44572   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44573   float result;
44574
44575   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44576   {
44577     try {
44578       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
44579     } CALL_CATCH_EXCEPTION(0);
44580   }
44581
44582   jresult = result;
44583   return jresult;
44584 }
44585
44586
44587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
44588   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44589   float arg2 ;
44590
44591   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44592   arg2 = (float)jarg2;
44593   {
44594     try {
44595       (arg1)->SetMinimumSwipeDistance(arg2);
44596     } CALL_CATCH_EXCEPTION();
44597   }
44598
44599 }
44600
44601
44602 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
44603   float jresult ;
44604   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44605   float result;
44606
44607   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44608   {
44609     try {
44610       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
44611     } CALL_CATCH_EXCEPTION(0);
44612   }
44613
44614   jresult = result;
44615   return jresult;
44616 }
44617
44618
44619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
44620   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44621   float arg2 ;
44622
44623   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44624   arg2 = (float)jarg2;
44625   {
44626     try {
44627       (arg1)->SetWheelScrollDistanceStep(arg2);
44628     } CALL_CATCH_EXCEPTION();
44629   }
44630
44631 }
44632
44633
44634 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
44635   float jresult ;
44636   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44637   float result;
44638
44639   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44640   {
44641     try {
44642       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
44643     } CALL_CATCH_EXCEPTION(0);
44644   }
44645
44646   jresult = result;
44647   return jresult;
44648 }
44649
44650
44651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, bool jarg2) {
44652   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44653   bool arg2 ;
44654
44655   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44656   arg2 = jarg2 ? true : false;
44657   {
44658     try {
44659       (arg1)->SetAnchoring(arg2);
44660     } CALL_CATCH_EXCEPTION();
44661   }
44662
44663 }
44664
44665 //// ========================= end of part 3 =============================
44666
44667 //// ========================== start part 4 ===============================
44668
44669
44670 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
44671   bool jresult ;
44672   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44673   bool result;
44674
44675   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44676   {
44677     try {
44678       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
44679     } CALL_CATCH_EXCEPTION(0);
44680   }
44681
44682   jresult = result;
44683   return jresult;
44684 }
44685
44686
44687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
44688   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44689   float arg2 ;
44690
44691   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44692   arg2 = (float)jarg2;
44693   {
44694     try {
44695       (arg1)->SetAnchoringDuration(arg2);
44696     } CALL_CATCH_EXCEPTION();
44697   }
44698
44699 }
44700
44701
44702 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
44703   float jresult ;
44704   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44705   float result;
44706
44707   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44708   {
44709     try {
44710       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
44711     } CALL_CATCH_EXCEPTION(0);
44712   }
44713
44714   jresult = result;
44715   return jresult;
44716 }
44717
44718
44719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
44720   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44721   Dali::Toolkit::ItemId arg2 ;
44722   float arg3 ;
44723
44724   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44725   arg2 = (Dali::Toolkit::ItemId)jarg2;
44726   arg3 = (float)jarg3;
44727   {
44728     try {
44729       (arg1)->ScrollToItem(arg2,arg3);
44730     } CALL_CATCH_EXCEPTION();
44731   }
44732
44733 }
44734
44735
44736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
44737   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44738   float arg2 ;
44739
44740   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44741   arg2 = (float)jarg2;
44742   {
44743     try {
44744       (arg1)->SetRefreshInterval(arg2);
44745     } CALL_CATCH_EXCEPTION();
44746   }
44747
44748 }
44749
44750
44751 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
44752   float jresult ;
44753   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44754   float result;
44755
44756   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44757   {
44758     try {
44759       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
44760     } CALL_CATCH_EXCEPTION(0);
44761   }
44762
44763   jresult = result;
44764   return jresult;
44765 }
44766
44767
44768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
44769   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44770
44771   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44772   {
44773     try {
44774       (arg1)->Refresh();
44775     } CALL_CATCH_EXCEPTION();
44776   }
44777
44778 }
44779
44780
44781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
44782   void * jresult ;
44783   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44784   Dali::Toolkit::ItemId arg2 ;
44785   Dali::Actor result;
44786
44787   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44788   arg2 = (Dali::Toolkit::ItemId)jarg2;
44789   {
44790     try {
44791       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
44792     } CALL_CATCH_EXCEPTION(0);
44793   }
44794
44795   jresult = new Dali::Actor((const Dali::Actor &)result);
44796   return jresult;
44797 }
44798
44799
44800 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
44801   unsigned int jresult ;
44802   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44803   Dali::Actor arg2 ;
44804   Dali::Actor *argp2 ;
44805   Dali::Toolkit::ItemId result;
44806
44807   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44808   argp2 = (Dali::Actor *)jarg2;
44809   if (!argp2) {
44810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
44811     return 0;
44812   }
44813   arg2 = *argp2;
44814   {
44815     try {
44816       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
44817     } CALL_CATCH_EXCEPTION(0);
44818   }
44819
44820   jresult = result;
44821   return jresult;
44822 }
44823
44824
44825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
44826   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44827   Dali::Toolkit::Item arg2 ;
44828   float arg3 ;
44829   Dali::Toolkit::Item *argp2 ;
44830
44831   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44832   argp2 = (Dali::Toolkit::Item *)jarg2;
44833   if (!argp2) {
44834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
44835     return ;
44836   }
44837   arg2 = *argp2;
44838   arg3 = (float)jarg3;
44839   {
44840     try {
44841       (arg1)->InsertItem(arg2,arg3);
44842     } CALL_CATCH_EXCEPTION();
44843   }
44844
44845 }
44846
44847
44848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
44849   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44850   Dali::Toolkit::ItemContainer *arg2 = 0 ;
44851   float arg3 ;
44852
44853   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44854   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
44855   if (!arg2) {
44856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
44857     return ;
44858   }
44859   arg3 = (float)jarg3;
44860   {
44861     try {
44862       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
44863     } CALL_CATCH_EXCEPTION();
44864   }
44865
44866 }
44867
44868
44869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
44870   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44871   Dali::Toolkit::ItemId arg2 ;
44872   float arg3 ;
44873
44874   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44875   arg2 = (Dali::Toolkit::ItemId)jarg2;
44876   arg3 = (float)jarg3;
44877   {
44878     try {
44879       (arg1)->RemoveItem(arg2,arg3);
44880     } CALL_CATCH_EXCEPTION();
44881   }
44882
44883 }
44884
44885
44886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
44887   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44888   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
44889   float arg3 ;
44890
44891   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44892   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
44893   if (!arg2) {
44894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
44895     return ;
44896   }
44897   arg3 = (float)jarg3;
44898   {
44899     try {
44900       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
44901     } CALL_CATCH_EXCEPTION();
44902   }
44903
44904 }
44905
44906
44907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
44908   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44909   Dali::Toolkit::Item arg2 ;
44910   float arg3 ;
44911   Dali::Toolkit::Item *argp2 ;
44912
44913   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44914   argp2 = (Dali::Toolkit::Item *)jarg2;
44915   if (!argp2) {
44916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
44917     return ;
44918   }
44919   arg2 = *argp2;
44920   arg3 = (float)jarg3;
44921   {
44922     try {
44923       (arg1)->ReplaceItem(arg2,arg3);
44924     } CALL_CATCH_EXCEPTION();
44925   }
44926
44927 }
44928
44929
44930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
44931   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44932   Dali::Toolkit::ItemContainer *arg2 = 0 ;
44933   float arg3 ;
44934
44935   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44936   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
44937   if (!arg2) {
44938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
44939     return ;
44940   }
44941   arg3 = (float)jarg3;
44942   {
44943     try {
44944       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
44945     } CALL_CATCH_EXCEPTION();
44946   }
44947
44948 }
44949
44950
44951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
44952   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44953   Dali::Vector3 *arg2 = 0 ;
44954
44955   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44956   arg2 = (Dali::Vector3 *)jarg2;
44957   if (!arg2) {
44958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44959     return ;
44960   }
44961   {
44962     try {
44963       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
44964     } CALL_CATCH_EXCEPTION();
44965   }
44966
44967 }
44968
44969
44970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
44971   void * jresult ;
44972   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44973   Dali::Vector3 result;
44974
44975   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44976   {
44977     try {
44978       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
44979     } CALL_CATCH_EXCEPTION(0);
44980   }
44981
44982   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
44983   return jresult;
44984 }
44985
44986
44987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
44988   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
44989   Dali::Vector3 *arg2 = 0 ;
44990
44991   arg1 = (Dali::Toolkit::ItemView *)jarg1;
44992   arg2 = (Dali::Vector3 *)jarg2;
44993   if (!arg2) {
44994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44995     return ;
44996   }
44997   {
44998     try {
44999       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
45000     } CALL_CATCH_EXCEPTION();
45001   }
45002
45003 }
45004
45005
45006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
45007   void * jresult ;
45008   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
45009   Dali::Vector3 result;
45010
45011   arg1 = (Dali::Toolkit::ItemView *)jarg1;
45012   {
45013     try {
45014       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
45015     } CALL_CATCH_EXCEPTION(0);
45016   }
45017
45018   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
45019   return jresult;
45020 }
45021
45022
45023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
45024   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
45025   Dali::Toolkit::ItemRange *arg2 = 0 ;
45026
45027   arg1 = (Dali::Toolkit::ItemView *)jarg1;
45028   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
45029   if (!arg2) {
45030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
45031     return ;
45032   }
45033   {
45034     try {
45035       (arg1)->GetItemsRange(*arg2);
45036     } CALL_CATCH_EXCEPTION();
45037   }
45038
45039 }
45040
45041
45042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
45043   void * jresult ;
45044   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
45045   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
45046
45047   arg1 = (Dali::Toolkit::ItemView *)jarg1;
45048   {
45049     try {
45050       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
45051     } CALL_CATCH_EXCEPTION(0);
45052   }
45053
45054   jresult = (void *)result;
45055   return jresult;
45056 }
45057
45058
45059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
45060   Dali::Vector3 *arg1 = 0 ;
45061   PropertyInputContainer *arg2 = 0 ;
45062
45063   arg1 = (Dali::Vector3 *)jarg1;
45064   if (!arg1) {
45065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
45066     return ;
45067   }
45068   arg2 = (PropertyInputContainer *)jarg2;
45069   if (!arg2) {
45070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
45071     return ;
45072   }
45073   {
45074     try {
45075       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
45076     } CALL_CATCH_EXCEPTION();
45077   }
45078
45079 }
45080
45081
45082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
45083   Dali::Vector3 *arg1 = 0 ;
45084   PropertyInputContainer *arg2 = 0 ;
45085
45086   arg1 = (Dali::Vector3 *)jarg1;
45087   if (!arg1) {
45088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
45089     return ;
45090   }
45091   arg2 = (PropertyInputContainer *)jarg2;
45092   if (!arg2) {
45093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
45094     return ;
45095   }
45096   {
45097     try {
45098       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
45099     } CALL_CATCH_EXCEPTION();
45100   }
45101
45102 }
45103
45104
45105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
45106   void * jresult ;
45107   Dali::Toolkit::ScrollViewEffect *result = 0 ;
45108
45109   {
45110     try {
45111       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
45112     } CALL_CATCH_EXCEPTION(0);
45113   }
45114
45115   jresult = (void *)result;
45116   return jresult;
45117 }
45118
45119
45120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
45121   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
45122
45123   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
45124   {
45125     try {
45126       delete arg1;
45127     } CALL_CATCH_EXCEPTION();
45128   }
45129
45130 }
45131
45132
45133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
45134   void * jresult ;
45135   Dali::Path arg1 ;
45136   Dali::Vector3 *arg2 = 0 ;
45137   Dali::Property::Index arg3 ;
45138   Dali::Vector3 *arg4 = 0 ;
45139   unsigned int arg5 ;
45140   Dali::Path *argp1 ;
45141   Dali::Toolkit::ScrollViewPagePathEffect result;
45142
45143   argp1 = (Dali::Path *)jarg1;
45144   if (!argp1) {
45145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
45146     return 0;
45147   }
45148   arg1 = *argp1;
45149   arg2 = (Dali::Vector3 *)jarg2;
45150   if (!arg2) {
45151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
45152     return 0;
45153   }
45154   arg3 = (Dali::Property::Index)jarg3;
45155   arg4 = (Dali::Vector3 *)jarg4;
45156   if (!arg4) {
45157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
45158     return 0;
45159   }
45160   arg5 = (unsigned int)jarg5;
45161   {
45162     try {
45163       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
45164     } CALL_CATCH_EXCEPTION(0);
45165   }
45166
45167   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
45168   return jresult;
45169 }
45170
45171
45172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
45173   void * jresult ;
45174   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
45175
45176   {
45177     try {
45178       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
45179     } CALL_CATCH_EXCEPTION(0);
45180   }
45181
45182   jresult = (void *)result;
45183   return jresult;
45184 }
45185
45186
45187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
45188   void * jresult ;
45189   Dali::BaseHandle arg1 ;
45190   Dali::BaseHandle *argp1 ;
45191   Dali::Toolkit::ScrollViewPagePathEffect result;
45192
45193   argp1 = (Dali::BaseHandle *)jarg1;
45194   if (!argp1) {
45195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45196     return 0;
45197   }
45198   arg1 = *argp1;
45199   {
45200     try {
45201       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
45202     } CALL_CATCH_EXCEPTION(0);
45203   }
45204
45205   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
45206   return jresult;
45207 }
45208
45209
45210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
45211   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
45212   Dali::Actor arg2 ;
45213   unsigned int arg3 ;
45214   Dali::Actor *argp2 ;
45215
45216   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
45217   argp2 = (Dali::Actor *)jarg2;
45218   if (!argp2) {
45219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
45220     return ;
45221   }
45222   arg2 = *argp2;
45223   arg3 = (unsigned int)jarg3;
45224   {
45225     try {
45226       (arg1)->ApplyToPage(arg2,arg3);
45227     } CALL_CATCH_EXCEPTION();
45228   }
45229
45230 }
45231
45232
45233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
45234   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
45235
45236   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
45237   {
45238     try {
45239       delete arg1;
45240     } CALL_CATCH_EXCEPTION();
45241   }
45242
45243 }
45244
45245
45246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
45247   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
45248   Dali::Toolkit::ClampState arg2 ;
45249
45250   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
45251   arg2 = (Dali::Toolkit::ClampState)jarg2;
45252   if (arg1) (arg1)->x = arg2;
45253 }
45254
45255
45256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
45257   int jresult ;
45258   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
45259   Dali::Toolkit::ClampState result;
45260
45261   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
45262   result = (Dali::Toolkit::ClampState) ((arg1)->x);
45263   jresult = (int)result;
45264   return jresult;
45265 }
45266
45267
45268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
45269   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
45270   Dali::Toolkit::ClampState arg2 ;
45271
45272   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
45273   arg2 = (Dali::Toolkit::ClampState)jarg2;
45274   if (arg1) (arg1)->y = arg2;
45275 }
45276
45277
45278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
45279   int jresult ;
45280   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
45281   Dali::Toolkit::ClampState result;
45282
45283   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
45284   result = (Dali::Toolkit::ClampState) ((arg1)->y);
45285   jresult = (int)result;
45286   return jresult;
45287 }
45288
45289
45290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
45291   void * jresult ;
45292   Dali::Toolkit::ClampState2D *result = 0 ;
45293
45294   {
45295     try {
45296       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
45297     } CALL_CATCH_EXCEPTION(0);
45298   }
45299
45300   jresult = (void *)result;
45301   return jresult;
45302 }
45303
45304
45305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
45306   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
45307
45308   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
45309   {
45310     try {
45311       delete arg1;
45312     } CALL_CATCH_EXCEPTION();
45313   }
45314
45315 }
45316
45317
45318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, bool jarg3) {
45319   void * jresult ;
45320   float arg1 ;
45321   float arg2 ;
45322   bool arg3 ;
45323   Dali::Toolkit::RulerDomain *result = 0 ;
45324
45325   arg1 = (float)jarg1;
45326   arg2 = (float)jarg2;
45327   arg3 = jarg3 ? true : false;
45328   {
45329     try {
45330       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
45331     } CALL_CATCH_EXCEPTION(0);
45332   }
45333
45334   jresult = (void *)result;
45335   return jresult;
45336 }
45337
45338
45339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
45340   void * jresult ;
45341   float arg1 ;
45342   float arg2 ;
45343   Dali::Toolkit::RulerDomain *result = 0 ;
45344
45345   arg1 = (float)jarg1;
45346   arg2 = (float)jarg2;
45347   {
45348     try {
45349       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
45350     } CALL_CATCH_EXCEPTION(0);
45351   }
45352
45353   jresult = (void *)result;
45354   return jresult;
45355 }
45356
45357
45358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
45359   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
45360   float arg2 ;
45361
45362   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
45363   arg2 = (float)jarg2;
45364   if (arg1) (arg1)->min = arg2;
45365 }
45366
45367
45368 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
45369   float jresult ;
45370   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
45371   float result;
45372
45373   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
45374   result = (float) ((arg1)->min);
45375   jresult = result;
45376   return jresult;
45377 }
45378
45379
45380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
45381   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
45382   float arg2 ;
45383
45384   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
45385   arg2 = (float)jarg2;
45386   if (arg1) (arg1)->max = arg2;
45387 }
45388
45389
45390 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
45391   float jresult ;
45392   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
45393   float result;
45394
45395   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
45396   result = (float) ((arg1)->max);
45397   jresult = result;
45398   return jresult;
45399 }
45400
45401
45402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, bool jarg2) {
45403   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
45404   bool arg2 ;
45405
45406   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
45407   arg2 = jarg2 ? true : false;
45408   if (arg1) (arg1)->enabled = arg2;
45409 }
45410
45411
45412 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
45413   bool jresult ;
45414   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
45415   bool result;
45416
45417   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
45418   result = (bool) ((arg1)->enabled);
45419   jresult = result;
45420   return jresult;
45421 }
45422
45423
45424 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
45425   float jresult ;
45426   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
45427   float arg2 ;
45428   float arg3 ;
45429   float arg4 ;
45430   float result;
45431
45432   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
45433   arg2 = (float)jarg2;
45434   arg3 = (float)jarg3;
45435   arg4 = (float)jarg4;
45436   {
45437     try {
45438       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
45439     } CALL_CATCH_EXCEPTION(0);
45440   }
45441
45442   jresult = result;
45443   return jresult;
45444 }
45445
45446
45447 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
45448   float jresult ;
45449   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
45450   float arg2 ;
45451   float arg3 ;
45452   float result;
45453
45454   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
45455   arg2 = (float)jarg2;
45456   arg3 = (float)jarg3;
45457   {
45458     try {
45459       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
45460     } CALL_CATCH_EXCEPTION(0);
45461   }
45462
45463   jresult = result;
45464   return jresult;
45465 }
45466
45467
45468 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
45469   float jresult ;
45470   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
45471   float arg2 ;
45472   float result;
45473
45474   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
45475   arg2 = (float)jarg2;
45476   {
45477     try {
45478       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
45479     } CALL_CATCH_EXCEPTION(0);
45480   }
45481
45482   jresult = result;
45483   return jresult;
45484 }
45485
45486
45487 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
45488   float jresult ;
45489   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
45490   float arg2 ;
45491   float arg3 ;
45492   float arg4 ;
45493   Dali::Toolkit::ClampState *arg5 = 0 ;
45494   float result;
45495
45496   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
45497   arg2 = (float)jarg2;
45498   arg3 = (float)jarg3;
45499   arg4 = (float)jarg4;
45500   arg5 = (Dali::Toolkit::ClampState *)jarg5;
45501   if (!arg5) {
45502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
45503     return 0;
45504   }
45505   {
45506     try {
45507       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
45508     } CALL_CATCH_EXCEPTION(0);
45509   }
45510
45511   jresult = result;
45512   return jresult;
45513 }
45514
45515
45516 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
45517   float jresult ;
45518   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
45519   float result;
45520
45521   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
45522   {
45523     try {
45524       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
45525     } CALL_CATCH_EXCEPTION(0);
45526   }
45527
45528   jresult = result;
45529   return jresult;
45530 }
45531
45532
45533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
45534   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
45535
45536   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
45537   {
45538     try {
45539       delete arg1;
45540     } CALL_CATCH_EXCEPTION();
45541   }
45542
45543 }
45544
45545
45546 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
45547   float jresult ;
45548   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45549   float arg2 ;
45550   float arg3 ;
45551   float result;
45552
45553   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45554   arg2 = (float)jarg2;
45555   arg3 = (float)jarg3;
45556   {
45557     try {
45558       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
45559     } CALL_CATCH_EXCEPTION(0);
45560   }
45561
45562   jresult = result;
45563   return jresult;
45564 }
45565
45566
45567 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
45568   float jresult ;
45569   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45570   float arg2 ;
45571   float result;
45572
45573   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45574   arg2 = (float)jarg2;
45575   {
45576     try {
45577       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
45578     } CALL_CATCH_EXCEPTION(0);
45579   }
45580
45581   jresult = result;
45582   return jresult;
45583 }
45584
45585
45586 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) {
45587   float jresult ;
45588   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45589   unsigned int arg2 ;
45590   unsigned int *arg3 = 0 ;
45591   bool arg4 ;
45592   float result;
45593
45594   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45595   arg2 = (unsigned int)jarg2;
45596   arg3 = (unsigned int *)jarg3;
45597   arg4 = jarg4 ? true : false;
45598   {
45599     try {
45600       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
45601     } CALL_CATCH_EXCEPTION(0);
45602   }
45603
45604   jresult = result;
45605   return jresult;
45606 }
45607
45608
45609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) {
45610   unsigned int jresult ;
45611   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45612   float arg2 ;
45613   bool arg3 ;
45614   unsigned int result;
45615
45616   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45617   arg2 = (float)jarg2;
45618   arg3 = jarg3 ? true : false;
45619   {
45620     try {
45621       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
45622     } CALL_CATCH_EXCEPTION(0);
45623   }
45624
45625   jresult = result;
45626   return jresult;
45627 }
45628
45629
45630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
45631   unsigned int jresult ;
45632   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45633   unsigned int result;
45634
45635   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45636   {
45637     try {
45638       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
45639     } CALL_CATCH_EXCEPTION(0);
45640   }
45641
45642   jresult = result;
45643   return jresult;
45644 }
45645
45646
45647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
45648   int jresult ;
45649   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45650   Dali::Toolkit::Ruler::RulerType result;
45651
45652   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45653   {
45654     try {
45655       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
45656     } CALL_CATCH_EXCEPTION(0);
45657   }
45658
45659   jresult = (int)result;
45660   return jresult;
45661 }
45662
45663
45664 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
45665   bool jresult ;
45666   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45667   bool result;
45668
45669   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45670   {
45671     try {
45672       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
45673     } CALL_CATCH_EXCEPTION(0);
45674   }
45675
45676   jresult = result;
45677   return jresult;
45678 }
45679
45680
45681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
45682   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45683
45684   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45685   {
45686     try {
45687       (arg1)->Enable();
45688     } CALL_CATCH_EXCEPTION();
45689   }
45690
45691 }
45692
45693
45694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
45695   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45696
45697   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45698   {
45699     try {
45700       (arg1)->Disable();
45701     } CALL_CATCH_EXCEPTION();
45702   }
45703
45704 }
45705
45706
45707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
45708   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45709   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
45710   Dali::Toolkit::RulerDomain *argp2 ;
45711
45712   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45713   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
45714   if (!argp2) {
45715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
45716     return ;
45717   }
45718   arg2 = *argp2;
45719   {
45720     try {
45721       (arg1)->SetDomain(arg2);
45722     } CALL_CATCH_EXCEPTION();
45723   }
45724
45725 }
45726
45727
45728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
45729   void * jresult ;
45730   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45731   Dali::Toolkit::RulerDomain *result = 0 ;
45732
45733   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45734   {
45735     try {
45736       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
45737     } CALL_CATCH_EXCEPTION(0);
45738   }
45739
45740   jresult = (void *)result;
45741   return jresult;
45742 }
45743
45744
45745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
45746   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45747
45748   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45749   {
45750     try {
45751       (arg1)->DisableDomain();
45752     } CALL_CATCH_EXCEPTION();
45753   }
45754
45755 }
45756
45757
45758 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
45759   float jresult ;
45760   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45761   float arg2 ;
45762   float arg3 ;
45763   float arg4 ;
45764   float result;
45765
45766   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45767   arg2 = (float)jarg2;
45768   arg3 = (float)jarg3;
45769   arg4 = (float)jarg4;
45770   {
45771     try {
45772       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
45773     } CALL_CATCH_EXCEPTION(0);
45774   }
45775
45776   jresult = result;
45777   return jresult;
45778 }
45779
45780
45781 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
45782   float jresult ;
45783   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45784   float arg2 ;
45785   float arg3 ;
45786   float result;
45787
45788   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45789   arg2 = (float)jarg2;
45790   arg3 = (float)jarg3;
45791   {
45792     try {
45793       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
45794     } CALL_CATCH_EXCEPTION(0);
45795   }
45796
45797   jresult = result;
45798   return jresult;
45799 }
45800
45801
45802 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
45803   float jresult ;
45804   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45805   float arg2 ;
45806   float result;
45807
45808   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45809   arg2 = (float)jarg2;
45810   {
45811     try {
45812       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
45813     } CALL_CATCH_EXCEPTION(0);
45814   }
45815
45816   jresult = result;
45817   return jresult;
45818 }
45819
45820
45821 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
45822   float jresult ;
45823   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45824   float arg2 ;
45825   float arg3 ;
45826   float arg4 ;
45827   Dali::Toolkit::ClampState *arg5 = 0 ;
45828   float result;
45829
45830   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45831   arg2 = (float)jarg2;
45832   arg3 = (float)jarg3;
45833   arg4 = (float)jarg4;
45834   arg5 = (Dali::Toolkit::ClampState *)jarg5;
45835   if (!arg5) {
45836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
45837     return 0;
45838   }
45839   {
45840     try {
45841       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
45842     } CALL_CATCH_EXCEPTION(0);
45843   }
45844
45845   jresult = result;
45846   return jresult;
45847 }
45848
45849
45850 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
45851   float jresult ;
45852   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45853   float arg2 ;
45854   float arg3 ;
45855   float arg4 ;
45856   float arg5 ;
45857   float result;
45858
45859   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45860   arg2 = (float)jarg2;
45861   arg3 = (float)jarg3;
45862   arg4 = (float)jarg4;
45863   arg5 = (float)jarg5;
45864   {
45865     try {
45866       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
45867     } CALL_CATCH_EXCEPTION(0);
45868   }
45869
45870   jresult = result;
45871   return jresult;
45872 }
45873
45874
45875 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
45876   float jresult ;
45877   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45878   float arg2 ;
45879   float arg3 ;
45880   float arg4 ;
45881   float result;
45882
45883   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45884   arg2 = (float)jarg2;
45885   arg3 = (float)jarg3;
45886   arg4 = (float)jarg4;
45887   {
45888     try {
45889       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
45890     } CALL_CATCH_EXCEPTION(0);
45891   }
45892
45893   jresult = result;
45894   return jresult;
45895 }
45896
45897
45898 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
45899   float jresult ;
45900   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45901   float arg2 ;
45902   float arg3 ;
45903   float result;
45904
45905   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45906   arg2 = (float)jarg2;
45907   arg3 = (float)jarg3;
45908   {
45909     try {
45910       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
45911     } CALL_CATCH_EXCEPTION(0);
45912   }
45913
45914   jresult = result;
45915   return jresult;
45916 }
45917
45918
45919 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
45920   float jresult ;
45921   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45922   float arg2 ;
45923   float result;
45924
45925   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45926   arg2 = (float)jarg2;
45927   {
45928     try {
45929       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
45930     } CALL_CATCH_EXCEPTION(0);
45931   }
45932
45933   jresult = result;
45934   return jresult;
45935 }
45936
45937
45938 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
45939   float jresult ;
45940   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
45941   float arg2 ;
45942   float arg3 ;
45943   float arg4 ;
45944   float arg5 ;
45945   Dali::Toolkit::ClampState *arg6 = 0 ;
45946   float result;
45947
45948   arg1 = (Dali::Toolkit::Ruler *)jarg1;
45949   arg2 = (float)jarg2;
45950   arg3 = (float)jarg3;
45951   arg4 = (float)jarg4;
45952   arg5 = (float)jarg5;
45953   arg6 = (Dali::Toolkit::ClampState *)jarg6;
45954   if (!arg6) {
45955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
45956     return 0;
45957   }
45958   {
45959     try {
45960       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
45961     } CALL_CATCH_EXCEPTION(0);
45962   }
45963
45964   jresult = result;
45965   return jresult;
45966 }
45967
45968
45969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
45970   void * jresult ;
45971   Dali::Toolkit::DefaultRuler *result = 0 ;
45972
45973   {
45974     try {
45975       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
45976     } CALL_CATCH_EXCEPTION(0);
45977   }
45978
45979   jresult = (void *)result;
45980   return jresult;
45981 }
45982
45983
45984 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
45985   float jresult ;
45986   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
45987   float arg2 ;
45988   float arg3 ;
45989   float result;
45990
45991   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
45992   arg2 = (float)jarg2;
45993   arg3 = (float)jarg3;
45994   {
45995     try {
45996       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
45997     } CALL_CATCH_EXCEPTION(0);
45998   }
45999
46000   jresult = result;
46001   return jresult;
46002 }
46003
46004
46005 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) {
46006   float jresult ;
46007   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
46008   unsigned int arg2 ;
46009   unsigned int *arg3 = 0 ;
46010   bool arg4 ;
46011   float result;
46012
46013   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
46014   arg2 = (unsigned int)jarg2;
46015   arg3 = (unsigned int *)jarg3;
46016   arg4 = jarg4 ? true : false;
46017   {
46018     try {
46019       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
46020     } CALL_CATCH_EXCEPTION(0);
46021   }
46022
46023   jresult = result;
46024   return jresult;
46025 }
46026
46027
46028 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) {
46029   unsigned int jresult ;
46030   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
46031   float arg2 ;
46032   bool arg3 ;
46033   unsigned int result;
46034
46035   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
46036   arg2 = (float)jarg2;
46037   arg3 = jarg3 ? true : false;
46038   {
46039     try {
46040       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
46041     } CALL_CATCH_EXCEPTION(0);
46042   }
46043
46044   jresult = result;
46045   return jresult;
46046 }
46047
46048
46049 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
46050   unsigned int jresult ;
46051   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
46052   unsigned int result;
46053
46054   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
46055   {
46056     try {
46057       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
46058     } CALL_CATCH_EXCEPTION(0);
46059   }
46060
46061   jresult = result;
46062   return jresult;
46063 }
46064
46065
46066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
46067   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
46068
46069   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
46070   {
46071     try {
46072       delete arg1;
46073     } CALL_CATCH_EXCEPTION();
46074   }
46075
46076 }
46077
46078
46079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
46080   void * jresult ;
46081   float arg1 ;
46082   Dali::Toolkit::FixedRuler *result = 0 ;
46083
46084   arg1 = (float)jarg1;
46085   {
46086     try {
46087       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
46088     } CALL_CATCH_EXCEPTION(0);
46089   }
46090
46091   jresult = (void *)result;
46092   return jresult;
46093 }
46094
46095
46096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
46097   void * jresult ;
46098   Dali::Toolkit::FixedRuler *result = 0 ;
46099
46100   {
46101     try {
46102       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
46103     } CALL_CATCH_EXCEPTION(0);
46104   }
46105
46106   jresult = (void *)result;
46107   return jresult;
46108 }
46109
46110
46111 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
46112   float jresult ;
46113   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
46114   float arg2 ;
46115   float arg3 ;
46116   float result;
46117
46118   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
46119   arg2 = (float)jarg2;
46120   arg3 = (float)jarg3;
46121   {
46122     try {
46123       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
46124     } CALL_CATCH_EXCEPTION(0);
46125   }
46126
46127   jresult = result;
46128   return jresult;
46129 }
46130
46131
46132 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) {
46133   float jresult ;
46134   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
46135   unsigned int arg2 ;
46136   unsigned int *arg3 = 0 ;
46137   bool arg4 ;
46138   float result;
46139
46140   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
46141   arg2 = (unsigned int)jarg2;
46142   arg3 = (unsigned int *)jarg3;
46143   arg4 = jarg4 ? true : false;
46144   {
46145     try {
46146       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
46147     } CALL_CATCH_EXCEPTION(0);
46148   }
46149
46150   jresult = result;
46151   return jresult;
46152 }
46153
46154
46155 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) {
46156   unsigned int jresult ;
46157   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
46158   float arg2 ;
46159   bool arg3 ;
46160   unsigned int result;
46161
46162   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
46163   arg2 = (float)jarg2;
46164   arg3 = jarg3 ? true : false;
46165   {
46166     try {
46167       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
46168     } CALL_CATCH_EXCEPTION(0);
46169   }
46170
46171   jresult = result;
46172   return jresult;
46173 }
46174
46175
46176 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
46177   unsigned int jresult ;
46178   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
46179   unsigned int result;
46180
46181   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
46182   {
46183     try {
46184       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
46185     } CALL_CATCH_EXCEPTION(0);
46186   }
46187
46188   jresult = result;
46189   return jresult;
46190 }
46191
46192
46193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
46194   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
46195
46196   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
46197   {
46198     try {
46199       delete arg1;
46200     } CALL_CATCH_EXCEPTION();
46201   }
46202
46203 }
46204
46205
46206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
46207   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
46208   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
46209
46210   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
46211   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
46212   if (arg1) (arg1)->scale = *arg2;
46213 }
46214
46215
46216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
46217   void * jresult ;
46218   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
46219   Dali::Toolkit::ClampState2D *result = 0 ;
46220
46221   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
46222   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
46223   jresult = (void *)result;
46224   return jresult;
46225 }
46226
46227
46228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
46229   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
46230   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
46231
46232   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
46233   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
46234   if (arg1) (arg1)->position = *arg2;
46235 }
46236
46237
46238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
46239   void * jresult ;
46240   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
46241   Dali::Toolkit::ClampState2D *result = 0 ;
46242
46243   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
46244   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
46245   jresult = (void *)result;
46246   return jresult;
46247 }
46248
46249
46250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
46251   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
46252   Dali::Toolkit::ClampState arg2 ;
46253
46254   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
46255   arg2 = (Dali::Toolkit::ClampState)jarg2;
46256   if (arg1) (arg1)->rotation = arg2;
46257 }
46258
46259
46260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
46261   int jresult ;
46262   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
46263   Dali::Toolkit::ClampState result;
46264
46265   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
46266   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
46267   jresult = (int)result;
46268   return jresult;
46269 }
46270
46271
46272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
46273   void * jresult ;
46274   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
46275
46276   {
46277     try {
46278       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
46279     } CALL_CATCH_EXCEPTION(0);
46280   }
46281
46282   jresult = (void *)result;
46283   return jresult;
46284 }
46285
46286
46287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
46288   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
46289
46290   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
46291   {
46292     try {
46293       delete arg1;
46294     } CALL_CATCH_EXCEPTION();
46295   }
46296
46297 }
46298
46299
46300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
46301   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
46302   Dali::Toolkit::SnapType arg2 ;
46303
46304   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
46305   arg2 = (Dali::Toolkit::SnapType)jarg2;
46306   if (arg1) (arg1)->type = arg2;
46307 }
46308
46309
46310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
46311   int jresult ;
46312   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
46313   Dali::Toolkit::SnapType result;
46314
46315   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
46316   result = (Dali::Toolkit::SnapType) ((arg1)->type);
46317   jresult = (int)result;
46318   return jresult;
46319 }
46320
46321
46322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
46323   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
46324   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
46325
46326   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
46327   arg2 = (Dali::Vector2 *)jarg2;
46328   if (arg1) (arg1)->position = *arg2;
46329 }
46330
46331
46332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
46333   void * jresult ;
46334   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
46335   Dali::Vector2 *result = 0 ;
46336
46337   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
46338   result = (Dali::Vector2 *)& ((arg1)->position);
46339   jresult = (void *)result;
46340   return jresult;
46341 }
46342
46343
46344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
46345   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
46346   float arg2 ;
46347
46348   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
46349   arg2 = (float)jarg2;
46350   if (arg1) (arg1)->duration = arg2;
46351 }
46352
46353
46354 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
46355   float jresult ;
46356   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
46357   float result;
46358
46359   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
46360   result = (float) ((arg1)->duration);
46361   jresult = result;
46362   return jresult;
46363 }
46364
46365
46366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
46367   void * jresult ;
46368   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
46369
46370   {
46371     try {
46372       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
46373     } CALL_CATCH_EXCEPTION(0);
46374   }
46375
46376   jresult = (void *)result;
46377   return jresult;
46378 }
46379
46380
46381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
46382   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
46383
46384   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
46385   {
46386     try {
46387       delete arg1;
46388     } CALL_CATCH_EXCEPTION();
46389   }
46390
46391 }
46392
46393
46394 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
46395   int jresult ;
46396   int result;
46397
46398   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
46399   jresult = (int)result;
46400   return jresult;
46401 }
46402
46403
46404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
46405   int jresult ;
46406   int result;
46407
46408   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
46409   jresult = (int)result;
46410   return jresult;
46411 }
46412
46413
46414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
46415   int jresult ;
46416   int result;
46417
46418   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
46419   jresult = (int)result;
46420   return jresult;
46421 }
46422
46423
46424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
46425   int jresult ;
46426   int result;
46427
46428   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
46429   jresult = (int)result;
46430   return jresult;
46431 }
46432
46433
46434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
46435   int jresult ;
46436   int result;
46437
46438   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
46439   jresult = (int)result;
46440   return jresult;
46441 }
46442
46443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
46444   int jresult ;
46445   int result;
46446
46447   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
46448   jresult = (int)result;
46449   return jresult;
46450 }
46451
46452
46453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
46454   int jresult ;
46455   int result;
46456
46457   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
46458   jresult = (int)result;
46459   return jresult;
46460 }
46461
46462
46463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
46464   int jresult ;
46465   int result;
46466
46467   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
46468   jresult = (int)result;
46469   return jresult;
46470 }
46471
46472
46473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
46474   int jresult ;
46475   int result;
46476
46477   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
46478   jresult = (int)result;
46479   return jresult;
46480 }
46481
46482
46483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
46484   int jresult ;
46485   int result;
46486
46487   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
46488   jresult = (int)result;
46489   return jresult;
46490 }
46491
46492
46493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
46494   int jresult ;
46495   int result;
46496
46497   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
46498   jresult = (int)result;
46499   return jresult;
46500 }
46501
46502
46503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
46504   int jresult ;
46505   int result;
46506
46507   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
46508   jresult = (int)result;
46509   return jresult;
46510 }
46511
46512
46513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
46514   int jresult ;
46515   int result;
46516
46517   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
46518   jresult = (int)result;
46519   return jresult;
46520 }
46521
46522
46523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
46524   int jresult ;
46525   int result;
46526
46527   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
46528   jresult = (int)result;
46529   return jresult;
46530 }
46531
46532
46533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
46534   int jresult ;
46535   int result;
46536
46537   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
46538   jresult = (int)result;
46539   return jresult;
46540 }
46541
46542
46543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
46544   int jresult ;
46545   int result;
46546
46547   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
46548   jresult = (int)result;
46549   return jresult;
46550 }
46551
46552
46553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
46554   int jresult ;
46555   int result;
46556
46557   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
46558   jresult = (int)result;
46559   return jresult;
46560 }
46561
46562
46563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
46564   int jresult ;
46565   int result;
46566
46567   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
46568   jresult = (int)result;
46569   return jresult;
46570 }
46571
46572
46573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
46574   int jresult ;
46575   int result;
46576
46577   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
46578   jresult = (int)result;
46579   return jresult;
46580 }
46581
46582
46583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
46584   int jresult ;
46585   int result;
46586
46587   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
46588   jresult = (int)result;
46589   return jresult;
46590 }
46591
46592
46593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
46594   int jresult ;
46595   int result;
46596
46597   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
46598   jresult = (int)result;
46599   return jresult;
46600 }
46601
46602
46603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
46604   int jresult ;
46605   int result;
46606
46607   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
46608   jresult = (int)result;
46609   return jresult;
46610 }
46611
46612
46613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
46614   int jresult ;
46615   int result;
46616
46617   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
46618   jresult = (int)result;
46619   return jresult;
46620 }
46621
46622
46623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
46624   int jresult ;
46625   int result;
46626
46627   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
46628   jresult = (int)result;
46629   return jresult;
46630 }
46631
46632
46633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
46634   int jresult ;
46635   int result;
46636
46637   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
46638   jresult = (int)result;
46639   return jresult;
46640 }
46641
46642
46643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
46644   int jresult ;
46645   int result;
46646
46647   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
46648   jresult = (int)result;
46649   return jresult;
46650 }
46651
46652
46653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
46654   void * jresult ;
46655   Dali::Toolkit::ScrollView::Property *result = 0 ;
46656
46657   {
46658     try {
46659       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
46660     } CALL_CATCH_EXCEPTION(0);
46661   }
46662
46663   jresult = (void *)result;
46664   return jresult;
46665 }
46666
46667
46668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
46669   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
46670
46671   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
46672   {
46673     try {
46674       delete arg1;
46675     } CALL_CATCH_EXCEPTION();
46676   }
46677
46678 }
46679
46680
46681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
46682   void * jresult ;
46683   Dali::Toolkit::ScrollView *result = 0 ;
46684
46685   {
46686     try {
46687       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
46688     } CALL_CATCH_EXCEPTION(0);
46689   }
46690
46691   jresult = (void *)result;
46692   return jresult;
46693 }
46694
46695
46696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
46697   void * jresult ;
46698   Dali::Toolkit::ScrollView *arg1 = 0 ;
46699   Dali::Toolkit::ScrollView *result = 0 ;
46700
46701   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46702   if (!arg1) {
46703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
46704     return 0;
46705   }
46706   {
46707     try {
46708       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
46709     } CALL_CATCH_EXCEPTION(0);
46710   }
46711
46712   jresult = (void *)result;
46713   return jresult;
46714 }
46715
46716
46717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
46718   void * jresult ;
46719   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46720   Dali::Toolkit::ScrollView *arg2 = 0 ;
46721   Dali::Toolkit::ScrollView *result = 0 ;
46722
46723   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46724   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
46725   if (!arg2) {
46726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
46727     return 0;
46728   }
46729   {
46730     try {
46731       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
46732     } CALL_CATCH_EXCEPTION(0);
46733   }
46734
46735   jresult = (void *)result;
46736   return jresult;
46737 }
46738
46739
46740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
46741   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46742
46743   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46744   {
46745     try {
46746       delete arg1;
46747     } CALL_CATCH_EXCEPTION();
46748   }
46749
46750 }
46751
46752
46753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
46754   void * jresult ;
46755   Dali::Toolkit::ScrollView result;
46756
46757   {
46758     try {
46759       result = Dali::Toolkit::ScrollView::New();
46760     } CALL_CATCH_EXCEPTION(0);
46761   }
46762
46763   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
46764   return jresult;
46765 }
46766
46767
46768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
46769   void * jresult ;
46770   Dali::BaseHandle arg1 ;
46771   Dali::BaseHandle *argp1 ;
46772   Dali::Toolkit::ScrollView result;
46773
46774   argp1 = (Dali::BaseHandle *)jarg1;
46775   if (!argp1) {
46776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46777     return 0;
46778   }
46779   arg1 = *argp1;
46780   {
46781     try {
46782       result = Dali::Toolkit::ScrollView::DownCast(arg1);
46783     } CALL_CATCH_EXCEPTION(0);
46784   }
46785
46786   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
46787   return jresult;
46788 }
46789
46790
46791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
46792   void * jresult ;
46793   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46794   Dali::AlphaFunction result;
46795
46796   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46797   {
46798     try {
46799       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
46800     } CALL_CATCH_EXCEPTION(0);
46801   }
46802
46803   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
46804   return jresult;
46805 }
46806
46807
46808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
46809   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46810   Dali::AlphaFunction arg2 ;
46811   Dali::AlphaFunction *argp2 ;
46812
46813   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46814   argp2 = (Dali::AlphaFunction *)jarg2;
46815   if (!argp2) {
46816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
46817     return ;
46818   }
46819   arg2 = *argp2;
46820   {
46821     try {
46822       (arg1)->SetScrollSnapAlphaFunction(arg2);
46823     } CALL_CATCH_EXCEPTION();
46824   }
46825
46826 }
46827
46828
46829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
46830   void * jresult ;
46831   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46832   Dali::AlphaFunction result;
46833
46834   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46835   {
46836     try {
46837       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
46838     } CALL_CATCH_EXCEPTION(0);
46839   }
46840
46841   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
46842   return jresult;
46843 }
46844
46845
46846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
46847   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46848   Dali::AlphaFunction arg2 ;
46849   Dali::AlphaFunction *argp2 ;
46850
46851   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46852   argp2 = (Dali::AlphaFunction *)jarg2;
46853   if (!argp2) {
46854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
46855     return ;
46856   }
46857   arg2 = *argp2;
46858   {
46859     try {
46860       (arg1)->SetScrollFlickAlphaFunction(arg2);
46861     } CALL_CATCH_EXCEPTION();
46862   }
46863
46864 }
46865
46866
46867 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
46868   float jresult ;
46869   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46870   float result;
46871
46872   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46873   {
46874     try {
46875       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
46876     } CALL_CATCH_EXCEPTION(0);
46877   }
46878
46879   jresult = result;
46880   return jresult;
46881 }
46882
46883
46884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
46885   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46886   float arg2 ;
46887
46888   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46889   arg2 = (float)jarg2;
46890   {
46891     try {
46892       (arg1)->SetScrollSnapDuration(arg2);
46893     } CALL_CATCH_EXCEPTION();
46894   }
46895
46896 }
46897
46898
46899 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
46900   float jresult ;
46901   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46902   float result;
46903
46904   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46905   {
46906     try {
46907       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
46908     } CALL_CATCH_EXCEPTION(0);
46909   }
46910
46911   jresult = result;
46912   return jresult;
46913 }
46914
46915
46916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
46917   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46918   float arg2 ;
46919
46920   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46921   arg2 = (float)jarg2;
46922   {
46923     try {
46924       (arg1)->SetScrollFlickDuration(arg2);
46925     } CALL_CATCH_EXCEPTION();
46926   }
46927
46928 }
46929
46930
46931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
46932   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46933   Dali::Toolkit::RulerPtr arg2 ;
46934   Dali::Toolkit::RulerPtr *argp2 ;
46935
46936   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46937   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
46938   if (!argp2) {
46939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
46940     return ;
46941   }
46942   arg2 = *argp2;
46943   {
46944     try {
46945       (arg1)->SetRulerX(arg2);
46946     } CALL_CATCH_EXCEPTION();
46947   }
46948
46949 }
46950
46951
46952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
46953   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46954   Dali::Toolkit::RulerPtr arg2 ;
46955   Dali::Toolkit::RulerPtr *argp2 ;
46956
46957   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46958   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
46959   if (!argp2) {
46960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
46961     return ;
46962   }
46963   arg2 = *argp2;
46964   {
46965     try {
46966       (arg1)->SetRulerY(arg2);
46967     } CALL_CATCH_EXCEPTION();
46968   }
46969
46970 }
46971
46972
46973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, bool jarg2) {
46974   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46975   bool arg2 ;
46976
46977   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46978   arg2 = jarg2 ? true : false;
46979   {
46980     try {
46981       (arg1)->SetScrollSensitive(arg2);
46982     } CALL_CATCH_EXCEPTION();
46983   }
46984
46985 }
46986
46987
46988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
46989   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46990   float arg2 ;
46991   float arg3 ;
46992
46993   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46994   arg2 = (float)jarg2;
46995   arg3 = (float)jarg3;
46996   {
46997     try {
46998       (arg1)->SetMaxOvershoot(arg2,arg3);
46999     } CALL_CATCH_EXCEPTION();
47000   }
47001
47002 }
47003
47004
47005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
47006   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47007   Dali::AlphaFunction arg2 ;
47008   Dali::AlphaFunction *argp2 ;
47009
47010   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47011   argp2 = (Dali::AlphaFunction *)jarg2;
47012   if (!argp2) {
47013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
47014     return ;
47015   }
47016   arg2 = *argp2;
47017   {
47018     try {
47019       (arg1)->SetSnapOvershootAlphaFunction(arg2);
47020     } CALL_CATCH_EXCEPTION();
47021   }
47022
47023 }
47024
47025
47026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
47027   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47028   float arg2 ;
47029
47030   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47031   arg2 = (float)jarg2;
47032   {
47033     try {
47034       (arg1)->SetSnapOvershootDuration(arg2);
47035     } CALL_CATCH_EXCEPTION();
47036   }
47037
47038 }
47039
47040
47041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, bool jarg2) {
47042   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47043   bool arg2 ;
47044
47045   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47046   arg2 = jarg2 ? true : false;
47047   {
47048     try {
47049       (arg1)->SetActorAutoSnap(arg2);
47050     } CALL_CATCH_EXCEPTION();
47051   }
47052
47053 }
47054
47055
47056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, bool jarg2) {
47057   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47058   bool arg2 ;
47059
47060   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47061   arg2 = jarg2 ? true : false;
47062   {
47063     try {
47064       (arg1)->SetWrapMode(arg2);
47065     } CALL_CATCH_EXCEPTION();
47066   }
47067
47068 }
47069
47070
47071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
47072   int jresult ;
47073   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47074   int result;
47075
47076   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47077   {
47078     try {
47079       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
47080     } CALL_CATCH_EXCEPTION(0);
47081   }
47082
47083   jresult = result;
47084   return jresult;
47085 }
47086
47087
47088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
47089   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47090   int arg2 ;
47091
47092   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47093   arg2 = (int)jarg2;
47094   {
47095     try {
47096       (arg1)->SetScrollUpdateDistance(arg2);
47097     } CALL_CATCH_EXCEPTION();
47098   }
47099
47100 }
47101
47102
47103 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
47104   bool jresult ;
47105   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47106   bool result;
47107
47108   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47109   {
47110     try {
47111       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
47112     } CALL_CATCH_EXCEPTION(0);
47113   }
47114
47115   jresult = result;
47116   return jresult;
47117 }
47118
47119
47120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, bool jarg2) {
47121   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47122   bool arg2 ;
47123
47124   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47125   arg2 = jarg2 ? true : false;
47126   {
47127     try {
47128       (arg1)->SetAxisAutoLock(arg2);
47129     } CALL_CATCH_EXCEPTION();
47130   }
47131
47132 }
47133
47134
47135 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
47136   float jresult ;
47137   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47138   float result;
47139
47140   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47141   {
47142     try {
47143       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
47144     } CALL_CATCH_EXCEPTION(0);
47145   }
47146
47147   jresult = result;
47148   return jresult;
47149 }
47150
47151
47152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
47153   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47154   float arg2 ;
47155
47156   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47157   arg2 = (float)jarg2;
47158   {
47159     try {
47160       (arg1)->SetAxisAutoLockGradient(arg2);
47161     } CALL_CATCH_EXCEPTION();
47162   }
47163
47164 }
47165
47166
47167 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
47168   float jresult ;
47169   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47170   float result;
47171
47172   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47173   {
47174     try {
47175       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
47176     } CALL_CATCH_EXCEPTION(0);
47177   }
47178
47179   jresult = result;
47180   return jresult;
47181 }
47182
47183
47184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
47185   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47186   float arg2 ;
47187
47188   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47189   arg2 = (float)jarg2;
47190   {
47191     try {
47192       (arg1)->SetFrictionCoefficient(arg2);
47193     } CALL_CATCH_EXCEPTION();
47194   }
47195
47196 }
47197
47198
47199 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
47200   float jresult ;
47201   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47202   float result;
47203
47204   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47205   {
47206     try {
47207       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
47208     } CALL_CATCH_EXCEPTION(0);
47209   }
47210
47211   jresult = result;
47212   return jresult;
47213 }
47214
47215
47216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
47217   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47218   float arg2 ;
47219
47220   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47221   arg2 = (float)jarg2;
47222   {
47223     try {
47224       (arg1)->SetFlickSpeedCoefficient(arg2);
47225     } CALL_CATCH_EXCEPTION();
47226   }
47227
47228 }
47229
47230
47231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
47232   void * jresult ;
47233   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47234   Dali::Vector2 result;
47235
47236   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47237   {
47238     try {
47239       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
47240     } CALL_CATCH_EXCEPTION(0);
47241   }
47242
47243   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
47244   return jresult;
47245 }
47246
47247
47248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
47249   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47250   Dali::Vector2 *arg2 = 0 ;
47251
47252   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47253   arg2 = (Dali::Vector2 *)jarg2;
47254   if (!arg2) {
47255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
47256     return ;
47257   }
47258   {
47259     try {
47260       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
47261     } CALL_CATCH_EXCEPTION();
47262   }
47263
47264 }
47265
47266
47267 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
47268   float jresult ;
47269   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47270   float result;
47271
47272   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47273   {
47274     try {
47275       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
47276     } CALL_CATCH_EXCEPTION(0);
47277   }
47278
47279   jresult = result;
47280   return jresult;
47281 }
47282
47283
47284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
47285   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47286   float arg2 ;
47287
47288   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47289   arg2 = (float)jarg2;
47290   {
47291     try {
47292       (arg1)->SetMinimumSpeedForFlick(arg2);
47293     } CALL_CATCH_EXCEPTION();
47294   }
47295
47296 }
47297
47298
47299 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
47300   float jresult ;
47301   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47302   float result;
47303
47304   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47305   {
47306     try {
47307       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
47308     } CALL_CATCH_EXCEPTION(0);
47309   }
47310
47311   jresult = result;
47312   return jresult;
47313 }
47314
47315
47316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
47317   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47318   float arg2 ;
47319
47320   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47321   arg2 = (float)jarg2;
47322   {
47323     try {
47324       (arg1)->SetMaxFlickSpeed(arg2);
47325     } CALL_CATCH_EXCEPTION();
47326   }
47327
47328 }
47329
47330
47331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
47332   void * jresult ;
47333   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47334   Dali::Vector2 result;
47335
47336   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47337   {
47338     try {
47339       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
47340     } CALL_CATCH_EXCEPTION(0);
47341   }
47342
47343   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
47344   return jresult;
47345 }
47346
47347
47348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
47349   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47350   Dali::Vector2 arg2 ;
47351   Dali::Vector2 *argp2 ;
47352
47353   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47354   argp2 = (Dali::Vector2 *)jarg2;
47355   if (!argp2) {
47356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
47357     return ;
47358   }
47359   arg2 = *argp2;
47360   {
47361     try {
47362       (arg1)->SetWheelScrollDistanceStep(arg2);
47363     } CALL_CATCH_EXCEPTION();
47364   }
47365
47366 }
47367
47368
47369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
47370   void * jresult ;
47371   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47372   Dali::Vector2 result;
47373
47374   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47375   {
47376     try {
47377       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
47378     } CALL_CATCH_EXCEPTION(0);
47379   }
47380
47381   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
47382   return jresult;
47383 }
47384
47385
47386 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
47387   unsigned int jresult ;
47388   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47389   unsigned int result;
47390
47391   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47392   {
47393     try {
47394       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
47395     } CALL_CATCH_EXCEPTION(0);
47396   }
47397
47398   jresult = result;
47399   return jresult;
47400 }
47401
47402
47403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
47404   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47405   Dali::Vector2 *arg2 = 0 ;
47406
47407   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47408   arg2 = (Dali::Vector2 *)jarg2;
47409   if (!arg2) {
47410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
47411     return ;
47412   }
47413   {
47414     try {
47415       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
47416     } CALL_CATCH_EXCEPTION();
47417   }
47418
47419 }
47420
47421
47422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
47423   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47424   Dali::Vector2 *arg2 = 0 ;
47425   float arg3 ;
47426
47427   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47428   arg2 = (Dali::Vector2 *)jarg2;
47429   if (!arg2) {
47430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
47431     return ;
47432   }
47433   arg3 = (float)jarg3;
47434   {
47435     try {
47436       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
47437     } CALL_CATCH_EXCEPTION();
47438   }
47439
47440 }
47441
47442
47443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
47444   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47445   Dali::Vector2 *arg2 = 0 ;
47446   float arg3 ;
47447   Dali::AlphaFunction arg4 ;
47448   Dali::AlphaFunction *argp4 ;
47449
47450   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47451   arg2 = (Dali::Vector2 *)jarg2;
47452   if (!arg2) {
47453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
47454     return ;
47455   }
47456   arg3 = (float)jarg3;
47457   argp4 = (Dali::AlphaFunction *)jarg4;
47458   if (!argp4) {
47459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
47460     return ;
47461   }
47462   arg4 = *argp4;
47463   {
47464     try {
47465       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
47466     } CALL_CATCH_EXCEPTION();
47467   }
47468
47469 }
47470
47471
47472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
47473   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47474   Dali::Vector2 *arg2 = 0 ;
47475   float arg3 ;
47476   Dali::Toolkit::DirectionBias arg4 ;
47477   Dali::Toolkit::DirectionBias arg5 ;
47478
47479   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47480   arg2 = (Dali::Vector2 *)jarg2;
47481   if (!arg2) {
47482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
47483     return ;
47484   }
47485   arg3 = (float)jarg3;
47486   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
47487   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
47488   {
47489     try {
47490       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
47491     } CALL_CATCH_EXCEPTION();
47492   }
47493
47494 }
47495
47496
47497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
47498   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47499   Dali::Vector2 *arg2 = 0 ;
47500   float arg3 ;
47501   Dali::AlphaFunction arg4 ;
47502   Dali::Toolkit::DirectionBias arg5 ;
47503   Dali::Toolkit::DirectionBias arg6 ;
47504   Dali::AlphaFunction *argp4 ;
47505
47506   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47507   arg2 = (Dali::Vector2 *)jarg2;
47508   if (!arg2) {
47509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
47510     return ;
47511   }
47512   arg3 = (float)jarg3;
47513   argp4 = (Dali::AlphaFunction *)jarg4;
47514   if (!argp4) {
47515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
47516     return ;
47517   }
47518   arg4 = *argp4;
47519   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
47520   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
47521   {
47522     try {
47523       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
47524     } CALL_CATCH_EXCEPTION();
47525   }
47526
47527 }
47528
47529
47530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
47531   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47532   unsigned int arg2 ;
47533
47534   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47535   arg2 = (unsigned int)jarg2;
47536   {
47537     try {
47538       (arg1)->ScrollTo(arg2);
47539     } CALL_CATCH_EXCEPTION();
47540   }
47541
47542 }
47543
47544
47545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
47546   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47547   unsigned int arg2 ;
47548   float arg3 ;
47549
47550   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47551   arg2 = (unsigned int)jarg2;
47552   arg3 = (float)jarg3;
47553   {
47554     try {
47555       (arg1)->ScrollTo(arg2,arg3);
47556     } CALL_CATCH_EXCEPTION();
47557   }
47558
47559 }
47560
47561
47562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
47563   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47564   unsigned int arg2 ;
47565   float arg3 ;
47566   Dali::Toolkit::DirectionBias arg4 ;
47567
47568   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47569   arg2 = (unsigned int)jarg2;
47570   arg3 = (float)jarg3;
47571   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
47572   {
47573     try {
47574       (arg1)->ScrollTo(arg2,arg3,arg4);
47575     } CALL_CATCH_EXCEPTION();
47576   }
47577
47578 }
47579
47580
47581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
47582   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47583   Dali::Actor *arg2 = 0 ;
47584
47585   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47586   arg2 = (Dali::Actor *)jarg2;
47587   if (!arg2) {
47588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
47589     return ;
47590   }
47591   {
47592     try {
47593       (arg1)->ScrollTo(*arg2);
47594     } CALL_CATCH_EXCEPTION();
47595   }
47596
47597 }
47598
47599
47600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
47601   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47602   Dali::Actor *arg2 = 0 ;
47603   float arg3 ;
47604
47605   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47606   arg2 = (Dali::Actor *)jarg2;
47607   if (!arg2) {
47608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
47609     return ;
47610   }
47611   arg3 = (float)jarg3;
47612   {
47613     try {
47614       (arg1)->ScrollTo(*arg2,arg3);
47615     } CALL_CATCH_EXCEPTION();
47616   }
47617
47618 }
47619
47620
47621 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
47622   bool jresult ;
47623   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47624   bool result;
47625
47626   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47627   {
47628     try {
47629       result = (bool)(arg1)->ScrollToSnapPoint();
47630     } CALL_CATCH_EXCEPTION(0);
47631   }
47632
47633   jresult = result;
47634   return jresult;
47635 }
47636
47637
47638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
47639   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47640   Dali::Constraint arg2 ;
47641   Dali::Constraint *argp2 ;
47642
47643   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47644   argp2 = (Dali::Constraint *)jarg2;
47645   if (!argp2) {
47646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
47647     return ;
47648   }
47649   arg2 = *argp2;
47650   {
47651     try {
47652       (arg1)->ApplyConstraintToChildren(arg2);
47653     } CALL_CATCH_EXCEPTION();
47654   }
47655
47656 }
47657
47658
47659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
47660   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47661
47662   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47663   {
47664     try {
47665       (arg1)->RemoveConstraintsFromChildren();
47666     } CALL_CATCH_EXCEPTION();
47667   }
47668
47669 }
47670
47671
47672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
47673   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47674   Dali::Toolkit::ScrollViewEffect arg2 ;
47675   Dali::Toolkit::ScrollViewEffect *argp2 ;
47676
47677   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47678   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
47679   if (!argp2) {
47680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
47681     return ;
47682   }
47683   arg2 = *argp2;
47684   {
47685     try {
47686       (arg1)->ApplyEffect(arg2);
47687     } CALL_CATCH_EXCEPTION();
47688   }
47689
47690 }
47691
47692
47693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
47694   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47695   Dali::Toolkit::ScrollViewEffect arg2 ;
47696   Dali::Toolkit::ScrollViewEffect *argp2 ;
47697
47698   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47699   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
47700   if (!argp2) {
47701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
47702     return ;
47703   }
47704   arg2 = *argp2;
47705   {
47706     try {
47707       (arg1)->RemoveEffect(arg2);
47708     } CALL_CATCH_EXCEPTION();
47709   }
47710
47711 }
47712
47713
47714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
47715   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47716
47717   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47718   {
47719     try {
47720       (arg1)->RemoveAllEffects();
47721     } CALL_CATCH_EXCEPTION();
47722   }
47723
47724 }
47725
47726
47727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
47728   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47729   Dali::Actor arg2 ;
47730   Dali::Actor *argp2 ;
47731
47732   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47733   argp2 = (Dali::Actor *)jarg2;
47734   if (!argp2) {
47735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47736     return ;
47737   }
47738   arg2 = *argp2;
47739   {
47740     try {
47741       (arg1)->BindActor(arg2);
47742     } CALL_CATCH_EXCEPTION();
47743   }
47744
47745 }
47746
47747
47748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
47749   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47750   Dali::Actor arg2 ;
47751   Dali::Actor *argp2 ;
47752
47753   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47754   argp2 = (Dali::Actor *)jarg2;
47755   if (!argp2) {
47756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47757     return ;
47758   }
47759   arg2 = *argp2;
47760   {
47761     try {
47762       (arg1)->UnbindActor(arg2);
47763     } CALL_CATCH_EXCEPTION();
47764   }
47765
47766 }
47767
47768
47769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
47770   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47771   Dali::Radian arg2 ;
47772   Dali::Radian arg3 ;
47773   Dali::Radian *argp2 ;
47774   Dali::Radian *argp3 ;
47775
47776   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47777   argp2 = (Dali::Radian *)jarg2;
47778   if (!argp2) {
47779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
47780     return ;
47781   }
47782   arg2 = *argp2;
47783   argp3 = (Dali::Radian *)jarg3;
47784   if (!argp3) {
47785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
47786     return ;
47787   }
47788   arg3 = *argp3;
47789   {
47790     try {
47791       (arg1)->SetScrollingDirection(arg2,arg3);
47792     } CALL_CATCH_EXCEPTION();
47793   }
47794
47795 }
47796
47797
47798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
47799   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47800   Dali::Radian arg2 ;
47801   Dali::Radian *argp2 ;
47802
47803   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47804   argp2 = (Dali::Radian *)jarg2;
47805   if (!argp2) {
47806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
47807     return ;
47808   }
47809   arg2 = *argp2;
47810   {
47811     try {
47812       (arg1)->SetScrollingDirection(arg2);
47813     } CALL_CATCH_EXCEPTION();
47814   }
47815
47816 }
47817
47818
47819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
47820   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47821   Dali::Radian arg2 ;
47822   Dali::Radian *argp2 ;
47823
47824   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47825   argp2 = (Dali::Radian *)jarg2;
47826   if (!argp2) {
47827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
47828     return ;
47829   }
47830   arg2 = *argp2;
47831   {
47832     try {
47833       (arg1)->RemoveScrollingDirection(arg2);
47834     } CALL_CATCH_EXCEPTION();
47835   }
47836
47837 }
47838
47839
47840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
47841   void * jresult ;
47842   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
47843   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
47844
47845   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
47846   {
47847     try {
47848       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
47849     } CALL_CATCH_EXCEPTION(0);
47850   }
47851
47852   jresult = (void *)result;
47853   return jresult;
47854 }
47855
47856
47857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
47858   int jresult ;
47859   int result;
47860
47861   result = (int)Dali::Toolkit::TableView::Property::ROWS;
47862   jresult = (int)result;
47863   return jresult;
47864 }
47865
47866
47867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
47868   int jresult ;
47869   int result;
47870
47871   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
47872   jresult = (int)result;
47873   return jresult;
47874 }
47875
47876
47877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
47878   int jresult ;
47879   int result;
47880
47881   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
47882   jresult = (int)result;
47883   return jresult;
47884 }
47885
47886
47887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
47888   int jresult ;
47889   int result;
47890
47891   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
47892   jresult = (int)result;
47893   return jresult;
47894 }
47895
47896
47897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
47898   int jresult ;
47899   int result;
47900
47901   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
47902   jresult = (int)result;
47903   return jresult;
47904 }
47905
47906
47907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
47908   void * jresult ;
47909   Dali::Toolkit::TableView::Property *result = 0 ;
47910
47911   {
47912     try {
47913       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
47914     } CALL_CATCH_EXCEPTION(0);
47915   }
47916
47917   jresult = (void *)result;
47918   return jresult;
47919 }
47920
47921
47922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
47923   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
47924
47925   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
47926   {
47927     try {
47928       delete arg1;
47929     } CALL_CATCH_EXCEPTION();
47930   }
47931
47932 }
47933
47934
47935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
47936   int jresult ;
47937   int result;
47938
47939   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
47940   jresult = (int)result;
47941   return jresult;
47942 }
47943
47944
47945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
47946   int jresult ;
47947   int result;
47948
47949   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
47950   jresult = (int)result;
47951   return jresult;
47952 }
47953
47954
47955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
47956   int jresult ;
47957   int result;
47958
47959   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
47960   jresult = (int)result;
47961   return jresult;
47962 }
47963
47964
47965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
47966   int jresult ;
47967   int result;
47968
47969   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
47970   jresult = (int)result;
47971   return jresult;
47972 }
47973
47974
47975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
47976   int jresult ;
47977   int result;
47978
47979   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
47980   jresult = (int)result;
47981   return jresult;
47982 }
47983
47984
47985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
47986   void * jresult ;
47987   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
47988
47989   {
47990     try {
47991       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
47992     } CALL_CATCH_EXCEPTION(0);
47993   }
47994
47995   jresult = (void *)result;
47996   return jresult;
47997 }
47998
47999
48000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
48001   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
48002
48003   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
48004   {
48005     try {
48006       delete arg1;
48007     } CALL_CATCH_EXCEPTION();
48008   }
48009
48010 }
48011
48012
48013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
48014   void * jresult ;
48015   unsigned int arg1 ;
48016   unsigned int arg2 ;
48017   unsigned int arg3 ;
48018   unsigned int arg4 ;
48019   Dali::Toolkit::TableView::CellPosition *result = 0 ;
48020
48021   arg1 = (unsigned int)jarg1;
48022   arg2 = (unsigned int)jarg2;
48023   arg3 = (unsigned int)jarg3;
48024   arg4 = (unsigned int)jarg4;
48025   {
48026     try {
48027       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
48028     } CALL_CATCH_EXCEPTION(0);
48029   }
48030
48031   jresult = (void *)result;
48032   return jresult;
48033 }
48034
48035
48036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
48037   void * jresult ;
48038   unsigned int arg1 ;
48039   unsigned int arg2 ;
48040   unsigned int arg3 ;
48041   Dali::Toolkit::TableView::CellPosition *result = 0 ;
48042
48043   arg1 = (unsigned int)jarg1;
48044   arg2 = (unsigned int)jarg2;
48045   arg3 = (unsigned int)jarg3;
48046   {
48047     try {
48048       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
48049     } CALL_CATCH_EXCEPTION(0);
48050   }
48051
48052   jresult = (void *)result;
48053   return jresult;
48054 }
48055
48056
48057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
48058   void * jresult ;
48059   unsigned int arg1 ;
48060   unsigned int arg2 ;
48061   Dali::Toolkit::TableView::CellPosition *result = 0 ;
48062
48063   arg1 = (unsigned int)jarg1;
48064   arg2 = (unsigned int)jarg2;
48065   {
48066     try {
48067       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
48068     } CALL_CATCH_EXCEPTION(0);
48069   }
48070
48071   jresult = (void *)result;
48072   return jresult;
48073 }
48074
48075
48076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
48077   void * jresult ;
48078   unsigned int arg1 ;
48079   Dali::Toolkit::TableView::CellPosition *result = 0 ;
48080
48081   arg1 = (unsigned int)jarg1;
48082   {
48083     try {
48084       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
48085     } CALL_CATCH_EXCEPTION(0);
48086   }
48087
48088   jresult = (void *)result;
48089   return jresult;
48090 }
48091
48092
48093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
48094   void * jresult ;
48095   Dali::Toolkit::TableView::CellPosition *result = 0 ;
48096
48097   {
48098     try {
48099       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
48100     } CALL_CATCH_EXCEPTION(0);
48101   }
48102
48103   jresult = (void *)result;
48104   return jresult;
48105 }
48106
48107
48108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
48109   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
48110   unsigned int arg2 ;
48111
48112   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
48113   arg2 = (unsigned int)jarg2;
48114   if (arg1) (arg1)->rowIndex = arg2;
48115 }
48116
48117
48118 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
48119   unsigned int jresult ;
48120   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
48121   unsigned int result;
48122
48123   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
48124   result = (unsigned int) ((arg1)->rowIndex);
48125   jresult = result;
48126   return jresult;
48127 }
48128
48129
48130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
48131   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
48132   unsigned int arg2 ;
48133
48134   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
48135   arg2 = (unsigned int)jarg2;
48136   if (arg1) (arg1)->columnIndex = arg2;
48137 }
48138
48139
48140 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
48141   unsigned int jresult ;
48142   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
48143   unsigned int result;
48144
48145   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
48146   result = (unsigned int) ((arg1)->columnIndex);
48147   jresult = result;
48148   return jresult;
48149 }
48150
48151
48152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
48153   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
48154   unsigned int arg2 ;
48155
48156   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
48157   arg2 = (unsigned int)jarg2;
48158   if (arg1) (arg1)->rowSpan = arg2;
48159 }
48160
48161
48162 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
48163   unsigned int jresult ;
48164   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
48165   unsigned int result;
48166
48167   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
48168   result = (unsigned int) ((arg1)->rowSpan);
48169   jresult = result;
48170   return jresult;
48171 }
48172
48173
48174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
48175   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
48176   unsigned int arg2 ;
48177
48178   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
48179   arg2 = (unsigned int)jarg2;
48180   if (arg1) (arg1)->columnSpan = arg2;
48181 }
48182
48183
48184 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
48185   unsigned int jresult ;
48186   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
48187   unsigned int result;
48188
48189   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
48190   result = (unsigned int) ((arg1)->columnSpan);
48191   jresult = result;
48192   return jresult;
48193 }
48194
48195
48196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
48197   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
48198
48199   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
48200   {
48201     try {
48202       delete arg1;
48203     } CALL_CATCH_EXCEPTION();
48204   }
48205
48206 }
48207
48208
48209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
48210   void * jresult ;
48211   Dali::Toolkit::TableView *result = 0 ;
48212
48213   {
48214     try {
48215       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
48216     } CALL_CATCH_EXCEPTION(0);
48217   }
48218
48219   jresult = (void *)result;
48220   return jresult;
48221 }
48222
48223
48224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
48225   void * jresult ;
48226   Dali::Toolkit::TableView *arg1 = 0 ;
48227   Dali::Toolkit::TableView *result = 0 ;
48228
48229   arg1 = (Dali::Toolkit::TableView *)jarg1;
48230   if (!arg1) {
48231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
48232     return 0;
48233   }
48234   {
48235     try {
48236       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
48237     } CALL_CATCH_EXCEPTION(0);
48238   }
48239
48240   jresult = (void *)result;
48241   return jresult;
48242 }
48243
48244
48245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
48246   void * jresult ;
48247   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48248   Dali::Toolkit::TableView *arg2 = 0 ;
48249   Dali::Toolkit::TableView *result = 0 ;
48250
48251   arg1 = (Dali::Toolkit::TableView *)jarg1;
48252   arg2 = (Dali::Toolkit::TableView *)jarg2;
48253   if (!arg2) {
48254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
48255     return 0;
48256   }
48257   {
48258     try {
48259       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
48260     } CALL_CATCH_EXCEPTION(0);
48261   }
48262
48263   jresult = (void *)result;
48264   return jresult;
48265 }
48266
48267
48268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
48269   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48270
48271   arg1 = (Dali::Toolkit::TableView *)jarg1;
48272   {
48273     try {
48274       delete arg1;
48275     } CALL_CATCH_EXCEPTION();
48276   }
48277
48278 }
48279
48280
48281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
48282   void * jresult ;
48283   unsigned int arg1 ;
48284   unsigned int arg2 ;
48285   Dali::Toolkit::TableView result;
48286
48287   arg1 = (unsigned int)jarg1;
48288   arg2 = (unsigned int)jarg2;
48289   {
48290     try {
48291       result = Dali::Toolkit::TableView::New(arg1,arg2);
48292     } CALL_CATCH_EXCEPTION(0);
48293   }
48294
48295   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
48296   return jresult;
48297 }
48298
48299
48300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
48301   void * jresult ;
48302   Dali::BaseHandle arg1 ;
48303   Dali::BaseHandle *argp1 ;
48304   Dali::Toolkit::TableView result;
48305
48306   argp1 = (Dali::BaseHandle *)jarg1;
48307   if (!argp1) {
48308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48309     return 0;
48310   }
48311   arg1 = *argp1;
48312   {
48313     try {
48314       result = Dali::Toolkit::TableView::DownCast(arg1);
48315     } CALL_CATCH_EXCEPTION(0);
48316   }
48317
48318   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
48319   return jresult;
48320 }
48321
48322
48323 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
48324   bool jresult ;
48325   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48326   Dali::Actor arg2 ;
48327   Dali::Toolkit::TableView::CellPosition arg3 ;
48328   Dali::Actor *argp2 ;
48329   Dali::Toolkit::TableView::CellPosition *argp3 ;
48330   bool result;
48331
48332   arg1 = (Dali::Toolkit::TableView *)jarg1;
48333   argp2 = (Dali::Actor *)jarg2;
48334   if (!argp2) {
48335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48336     return 0;
48337   }
48338   arg2 = *argp2;
48339   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
48340   if (!argp3) {
48341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
48342     return 0;
48343   }
48344   arg3 = *argp3;
48345   {
48346     try {
48347       result = (bool)(arg1)->AddChild(arg2,arg3);
48348     } CALL_CATCH_EXCEPTION(0);
48349   }
48350
48351   jresult = result;
48352   return jresult;
48353 }
48354
48355
48356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
48357   void * jresult ;
48358   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48359   Dali::Toolkit::TableView::CellPosition arg2 ;
48360   Dali::Toolkit::TableView::CellPosition *argp2 ;
48361   Dali::Actor result;
48362
48363   arg1 = (Dali::Toolkit::TableView *)jarg1;
48364   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
48365   if (!argp2) {
48366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
48367     return 0;
48368   }
48369   arg2 = *argp2;
48370   {
48371     try {
48372       result = (arg1)->GetChildAt(arg2);
48373     } CALL_CATCH_EXCEPTION(0);
48374   }
48375
48376   jresult = new Dali::Actor((const Dali::Actor &)result);
48377   return jresult;
48378 }
48379
48380
48381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
48382   void * jresult ;
48383   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48384   Dali::Toolkit::TableView::CellPosition arg2 ;
48385   Dali::Toolkit::TableView::CellPosition *argp2 ;
48386   Dali::Actor result;
48387
48388   arg1 = (Dali::Toolkit::TableView *)jarg1;
48389   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
48390   if (!argp2) {
48391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
48392     return 0;
48393   }
48394   arg2 = *argp2;
48395   {
48396     try {
48397       result = (arg1)->RemoveChildAt(arg2);
48398     } CALL_CATCH_EXCEPTION(0);
48399   }
48400
48401   jresult = new Dali::Actor((const Dali::Actor &)result);
48402   return jresult;
48403 }
48404
48405
48406 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
48407   bool jresult ;
48408   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48409   Dali::Actor arg2 ;
48410   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
48411   Dali::Actor *argp2 ;
48412   bool result;
48413
48414   arg1 = (Dali::Toolkit::TableView *)jarg1;
48415   argp2 = (Dali::Actor *)jarg2;
48416   if (!argp2) {
48417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48418     return 0;
48419   }
48420   arg2 = *argp2;
48421   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
48422   if (!arg3) {
48423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
48424     return 0;
48425   }
48426   {
48427     try {
48428       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
48429     } CALL_CATCH_EXCEPTION(0);
48430   }
48431
48432   jresult = result;
48433   return jresult;
48434 }
48435
48436
48437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
48438   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48439   unsigned int arg2 ;
48440
48441   arg1 = (Dali::Toolkit::TableView *)jarg1;
48442   arg2 = (unsigned int)jarg2;
48443   {
48444     try {
48445       (arg1)->InsertRow(arg2);
48446     } CALL_CATCH_EXCEPTION();
48447   }
48448
48449 }
48450
48451
48452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
48453   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48454   unsigned int arg2 ;
48455
48456   arg1 = (Dali::Toolkit::TableView *)jarg1;
48457   arg2 = (unsigned int)jarg2;
48458   {
48459     try {
48460       (arg1)->DeleteRow(arg2);
48461     } CALL_CATCH_EXCEPTION();
48462   }
48463
48464 }
48465
48466
48467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
48468   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48469   unsigned int arg2 ;
48470   std::vector< Dali::Actor > *arg3 = 0 ;
48471
48472   arg1 = (Dali::Toolkit::TableView *)jarg1;
48473   arg2 = (unsigned int)jarg2;
48474   arg3 = (std::vector< Dali::Actor > *)jarg3;
48475   if (!arg3) {
48476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
48477     return ;
48478   }
48479   {
48480     try {
48481       (arg1)->DeleteRow(arg2,*arg3);
48482     } CALL_CATCH_EXCEPTION();
48483   }
48484
48485 }
48486
48487
48488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
48489   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48490   unsigned int arg2 ;
48491
48492   arg1 = (Dali::Toolkit::TableView *)jarg1;
48493   arg2 = (unsigned int)jarg2;
48494   {
48495     try {
48496       (arg1)->InsertColumn(arg2);
48497     } CALL_CATCH_EXCEPTION();
48498   }
48499
48500 }
48501
48502
48503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
48504   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48505   unsigned int arg2 ;
48506
48507   arg1 = (Dali::Toolkit::TableView *)jarg1;
48508   arg2 = (unsigned int)jarg2;
48509   {
48510     try {
48511       (arg1)->DeleteColumn(arg2);
48512     } CALL_CATCH_EXCEPTION();
48513   }
48514
48515 }
48516
48517
48518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
48519   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48520   unsigned int arg2 ;
48521   std::vector< Dali::Actor > *arg3 = 0 ;
48522
48523   arg1 = (Dali::Toolkit::TableView *)jarg1;
48524   arg2 = (unsigned int)jarg2;
48525   arg3 = (std::vector< Dali::Actor > *)jarg3;
48526   if (!arg3) {
48527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
48528     return ;
48529   }
48530   {
48531     try {
48532       (arg1)->DeleteColumn(arg2,*arg3);
48533     } CALL_CATCH_EXCEPTION();
48534   }
48535
48536 }
48537
48538
48539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
48540   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48541   unsigned int arg2 ;
48542   unsigned int arg3 ;
48543
48544   arg1 = (Dali::Toolkit::TableView *)jarg1;
48545   arg2 = (unsigned int)jarg2;
48546   arg3 = (unsigned int)jarg3;
48547   {
48548     try {
48549       (arg1)->Resize(arg2,arg3);
48550     } CALL_CATCH_EXCEPTION();
48551   }
48552
48553 }
48554
48555
48556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
48557   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48558   unsigned int arg2 ;
48559   unsigned int arg3 ;
48560   std::vector< Dali::Actor > *arg4 = 0 ;
48561
48562   arg1 = (Dali::Toolkit::TableView *)jarg1;
48563   arg2 = (unsigned int)jarg2;
48564   arg3 = (unsigned int)jarg3;
48565   arg4 = (std::vector< Dali::Actor > *)jarg4;
48566   if (!arg4) {
48567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
48568     return ;
48569   }
48570   {
48571     try {
48572       (arg1)->Resize(arg2,arg3,*arg4);
48573     } CALL_CATCH_EXCEPTION();
48574   }
48575
48576 }
48577
48578
48579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
48580   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48581   Dali::Size arg2 ;
48582   Dali::Size *argp2 ;
48583
48584   arg1 = (Dali::Toolkit::TableView *)jarg1;
48585   argp2 = (Dali::Size *)jarg2;
48586   if (!argp2) {
48587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
48588     return ;
48589   }
48590   arg2 = *argp2;
48591   {
48592     try {
48593       (arg1)->SetCellPadding(arg2);
48594     } CALL_CATCH_EXCEPTION();
48595   }
48596
48597 }
48598
48599
48600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
48601   void * jresult ;
48602   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48603   Dali::Size result;
48604
48605   arg1 = (Dali::Toolkit::TableView *)jarg1;
48606   {
48607     try {
48608       result = (arg1)->GetCellPadding();
48609     } CALL_CATCH_EXCEPTION(0);
48610   }
48611
48612   jresult = new Dali::Size((const Dali::Size &)result);
48613   return jresult;
48614 }
48615
48616
48617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
48618   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48619   unsigned int arg2 ;
48620
48621   arg1 = (Dali::Toolkit::TableView *)jarg1;
48622   arg2 = (unsigned int)jarg2;
48623   {
48624     try {
48625       (arg1)->SetFitHeight(arg2);
48626     } CALL_CATCH_EXCEPTION();
48627   }
48628
48629 }
48630
48631
48632 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
48633   bool jresult ;
48634   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48635   unsigned int arg2 ;
48636   bool result;
48637
48638   arg1 = (Dali::Toolkit::TableView *)jarg1;
48639   arg2 = (unsigned int)jarg2;
48640   {
48641     try {
48642       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
48643     } CALL_CATCH_EXCEPTION(0);
48644   }
48645
48646   jresult = result;
48647   return jresult;
48648 }
48649
48650
48651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
48652   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48653   unsigned int arg2 ;
48654
48655   arg1 = (Dali::Toolkit::TableView *)jarg1;
48656   arg2 = (unsigned int)jarg2;
48657   {
48658     try {
48659       (arg1)->SetFitWidth(arg2);
48660     } CALL_CATCH_EXCEPTION();
48661   }
48662
48663 }
48664
48665
48666 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
48667   bool jresult ;
48668   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48669   unsigned int arg2 ;
48670   bool result;
48671
48672   arg1 = (Dali::Toolkit::TableView *)jarg1;
48673   arg2 = (unsigned int)jarg2;
48674   {
48675     try {
48676       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
48677     } CALL_CATCH_EXCEPTION(0);
48678   }
48679
48680   jresult = result;
48681   return jresult;
48682 }
48683
48684
48685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
48686   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48687   unsigned int arg2 ;
48688   float arg3 ;
48689
48690   arg1 = (Dali::Toolkit::TableView *)jarg1;
48691   arg2 = (unsigned int)jarg2;
48692   arg3 = (float)jarg3;
48693   {
48694     try {
48695       (arg1)->SetFixedHeight(arg2,arg3);
48696     } CALL_CATCH_EXCEPTION();
48697   }
48698
48699 }
48700
48701
48702 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
48703   float jresult ;
48704   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48705   unsigned int arg2 ;
48706   float result;
48707
48708   arg1 = (Dali::Toolkit::TableView *)jarg1;
48709   arg2 = (unsigned int)jarg2;
48710   {
48711     try {
48712       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
48713     } CALL_CATCH_EXCEPTION(0);
48714   }
48715
48716   jresult = result;
48717   return jresult;
48718 }
48719
48720
48721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
48722   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48723   unsigned int arg2 ;
48724   float arg3 ;
48725
48726   arg1 = (Dali::Toolkit::TableView *)jarg1;
48727   arg2 = (unsigned int)jarg2;
48728   arg3 = (float)jarg3;
48729   {
48730     try {
48731       (arg1)->SetRelativeHeight(arg2,arg3);
48732     } CALL_CATCH_EXCEPTION();
48733   }
48734
48735 }
48736
48737
48738 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
48739   float jresult ;
48740   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48741   unsigned int arg2 ;
48742   float result;
48743
48744   arg1 = (Dali::Toolkit::TableView *)jarg1;
48745   arg2 = (unsigned int)jarg2;
48746   {
48747     try {
48748       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
48749     } CALL_CATCH_EXCEPTION(0);
48750   }
48751
48752   jresult = result;
48753   return jresult;
48754 }
48755
48756
48757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
48758   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48759   unsigned int arg2 ;
48760   float arg3 ;
48761
48762   arg1 = (Dali::Toolkit::TableView *)jarg1;
48763   arg2 = (unsigned int)jarg2;
48764   arg3 = (float)jarg3;
48765   {
48766     try {
48767       (arg1)->SetFixedWidth(arg2,arg3);
48768     } CALL_CATCH_EXCEPTION();
48769   }
48770
48771 }
48772
48773
48774 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
48775   float jresult ;
48776   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48777   unsigned int arg2 ;
48778   float result;
48779
48780   arg1 = (Dali::Toolkit::TableView *)jarg1;
48781   arg2 = (unsigned int)jarg2;
48782   {
48783     try {
48784       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
48785     } CALL_CATCH_EXCEPTION(0);
48786   }
48787
48788   jresult = result;
48789   return jresult;
48790 }
48791
48792
48793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
48794   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48795   unsigned int arg2 ;
48796   float arg3 ;
48797
48798   arg1 = (Dali::Toolkit::TableView *)jarg1;
48799   arg2 = (unsigned int)jarg2;
48800   arg3 = (float)jarg3;
48801   {
48802     try {
48803       (arg1)->SetRelativeWidth(arg2,arg3);
48804     } CALL_CATCH_EXCEPTION();
48805   }
48806
48807 }
48808
48809
48810 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
48811   float jresult ;
48812   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48813   unsigned int arg2 ;
48814   float result;
48815
48816   arg1 = (Dali::Toolkit::TableView *)jarg1;
48817   arg2 = (unsigned int)jarg2;
48818   {
48819     try {
48820       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
48821     } CALL_CATCH_EXCEPTION(0);
48822   }
48823
48824   jresult = result;
48825   return jresult;
48826 }
48827
48828
48829 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
48830   unsigned int jresult ;
48831   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48832   unsigned int result;
48833
48834   arg1 = (Dali::Toolkit::TableView *)jarg1;
48835   {
48836     try {
48837       result = (unsigned int)(arg1)->GetRows();
48838     } CALL_CATCH_EXCEPTION(0);
48839   }
48840
48841   jresult = result;
48842   return jresult;
48843 }
48844
48845
48846 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
48847   unsigned int jresult ;
48848   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48849   unsigned int result;
48850
48851   arg1 = (Dali::Toolkit::TableView *)jarg1;
48852   {
48853     try {
48854       result = (unsigned int)(arg1)->GetColumns();
48855     } CALL_CATCH_EXCEPTION(0);
48856   }
48857
48858   jresult = result;
48859   return jresult;
48860 }
48861
48862
48863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
48864   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
48865   Dali::Toolkit::TableView::CellPosition arg2 ;
48866   Dali::HorizontalAlignment::Type arg3 ;
48867   Dali::VerticalAlignment::Type arg4 ;
48868   Dali::Toolkit::TableView::CellPosition *argp2 ;
48869
48870   arg1 = (Dali::Toolkit::TableView *)jarg1;
48871   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
48872   if (!argp2) {
48873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
48874     return ;
48875   }
48876   arg2 = *argp2;
48877   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
48878   arg4 = (Dali::VerticalAlignment::Type)jarg4;
48879   {
48880     try {
48881       (arg1)->SetCellAlignment(arg2,arg3,arg4);
48882     } CALL_CATCH_EXCEPTION();
48883   }
48884
48885 }
48886
48887
48888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
48889   unsigned int jresult ;
48890   unsigned int result;
48891
48892   result = (unsigned int)(unsigned int)Dali::Toolkit::DevelText::DEFAULT_RENDERING_BACKEND;
48893   jresult = result;
48894   return jresult;
48895 }
48896
48897
48898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
48899   int jresult ;
48900   int result;
48901
48902   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
48903   jresult = (int)result;
48904   return jresult;
48905 }
48906
48907
48908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
48909   int jresult ;
48910   int result;
48911
48912   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
48913   jresult = (int)result;
48914   return jresult;
48915 }
48916
48917
48918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
48919   int jresult ;
48920   int result;
48921
48922   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
48923   jresult = (int)result;
48924   return jresult;
48925 }
48926
48927
48928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
48929   int jresult ;
48930   int result;
48931
48932   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
48933   jresult = (int)result;
48934   return jresult;
48935 }
48936
48937
48938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
48939   int jresult ;
48940   int result;
48941
48942   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
48943   jresult = (int)result;
48944   return jresult;
48945 }
48946
48947
48948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
48949   int jresult ;
48950   int result;
48951
48952   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
48953   jresult = (int)result;
48954   return jresult;
48955 }
48956
48957
48958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
48959   int jresult ;
48960   int result;
48961
48962   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
48963   jresult = (int)result;
48964   return jresult;
48965 }
48966
48967
48968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
48969   int jresult ;
48970   int result;
48971
48972   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
48973   jresult = (int)result;
48974   return jresult;
48975 }
48976
48977
48978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
48979   int jresult ;
48980   int result;
48981
48982   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
48983   jresult = (int)result;
48984   return jresult;
48985 }
48986
48987
48988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
48989   int jresult ;
48990   int result;
48991
48992   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
48993   jresult = (int)result;
48994   return jresult;
48995 }
48996
48997
48998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
48999   int jresult ;
49000   int result;
49001
49002   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
49003   jresult = (int)result;
49004   return jresult;
49005 }
49006
49007
49008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
49009   int jresult ;
49010   int result;
49011
49012   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
49013   jresult = (int)result;
49014   return jresult;
49015 }
49016
49017
49018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
49019   int jresult ;
49020   int result;
49021
49022   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
49023   jresult = (int)result;
49024   return jresult;
49025 }
49026
49027
49028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
49029   int jresult ;
49030   int result;
49031
49032   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
49033   jresult = (int)result;
49034   return jresult;
49035 }
49036
49037
49038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
49039   int jresult ;
49040   int result;
49041
49042   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
49043   jresult = (int)result;
49044   return jresult;
49045 }
49046
49047
49048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
49049   int jresult ;
49050   int result;
49051
49052   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
49053   jresult = (int)result;
49054   return jresult;
49055 }
49056
49057
49058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
49059   int jresult ;
49060   int result;
49061
49062   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
49063   jresult = (int)result;
49064   return jresult;
49065 }
49066
49067
49068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
49069   int jresult ;
49070   int result;
49071
49072   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
49073   jresult = (int)result;
49074   return jresult;
49075 }
49076
49077
49078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
49079   void * jresult ;
49080   Dali::Toolkit::TextLabel::Property *result = 0 ;
49081
49082   {
49083     try {
49084       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
49085     } CALL_CATCH_EXCEPTION(0);
49086   }
49087
49088   jresult = (void *)result;
49089   return jresult;
49090 }
49091
49092
49093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
49094   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
49095
49096   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
49097   {
49098     try {
49099       delete arg1;
49100     } CALL_CATCH_EXCEPTION();
49101   }
49102
49103 }
49104
49105
49106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
49107   void * jresult ;
49108   Dali::Toolkit::TextLabel result;
49109
49110   {
49111     try {
49112       result = Dali::Toolkit::TextLabel::New();
49113     } CALL_CATCH_EXCEPTION(0);
49114   }
49115
49116   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
49117   return jresult;
49118 }
49119
49120
49121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * text) {
49122   void * jresult ;
49123   std::string *arg1 = 0 ;
49124   Dali::Toolkit::TextLabel result;
49125
49126   if (!text) {
49127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49128     return 0;
49129   }
49130   std::string arg1_str(text);
49131   arg1 = &arg1_str;
49132   {
49133     try {
49134       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
49135     } CALL_CATCH_EXCEPTION(0);
49136   }
49137
49138   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
49139
49140   //argout typemap for const std::string&
49141
49142   return jresult;
49143 }
49144
49145
49146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New_With_Style(bool hasStyle) {
49147   void * jresult ;
49148   Dali::Toolkit::TextLabel result;
49149
49150   {
49151     try {
49152       if (hasStyle) {
49153         result = Dali::Toolkit::TextLabel::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
49154       } else {
49155         result = Dali::Toolkit::TextLabel::New();
49156       }
49157     } CALL_CATCH_EXCEPTION(0);
49158   }
49159
49160   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
49161   return jresult;
49162 }
49163
49164
49165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New_With_String_Style(char * text, bool hasStyle) {
49166   void * jresult ;
49167   std::string *arg1 = 0 ;
49168   Dali::Toolkit::TextLabel result;
49169
49170   if (!text) {
49171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49172     return 0;
49173   }
49174   std::string arg1_str(text);
49175   arg1 = &arg1_str;
49176   {
49177     try {
49178       if (hasStyle) {
49179         result = Dali::Toolkit::TextLabel::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS, (std::string const &)*arg1);
49180       } else {
49181         result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
49182       }
49183     } CALL_CATCH_EXCEPTION(0);
49184   }
49185
49186   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
49187
49188   //argout typemap for const std::string&
49189
49190   return jresult;
49191 }
49192
49193
49194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
49195   void * jresult ;
49196   Dali::Toolkit::TextLabel *result = 0 ;
49197
49198   {
49199     try {
49200       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
49201     } CALL_CATCH_EXCEPTION(0);
49202   }
49203
49204   jresult = (void *)result;
49205   return jresult;
49206 }
49207
49208
49209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
49210   void * jresult ;
49211   Dali::Toolkit::TextLabel *arg1 = 0 ;
49212   Dali::Toolkit::TextLabel *result = 0 ;
49213
49214   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
49215   if (!arg1) {
49216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
49217     return 0;
49218   }
49219   {
49220     try {
49221       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
49222     } CALL_CATCH_EXCEPTION(0);
49223   }
49224
49225   jresult = (void *)result;
49226   return jresult;
49227 }
49228
49229
49230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
49231   void * jresult ;
49232   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
49233   Dali::Toolkit::TextLabel *arg2 = 0 ;
49234   Dali::Toolkit::TextLabel *result = 0 ;
49235
49236   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
49237   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
49238   if (!arg2) {
49239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
49240     return 0;
49241   }
49242   {
49243     try {
49244       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
49245     } CALL_CATCH_EXCEPTION(0);
49246   }
49247
49248   jresult = (void *)result;
49249   return jresult;
49250 }
49251
49252
49253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
49254   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
49255
49256   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
49257   {
49258     try {
49259       delete arg1;
49260     } CALL_CATCH_EXCEPTION();
49261   }
49262
49263 }
49264
49265
49266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
49267   void * jresult ;
49268   Dali::BaseHandle arg1 ;
49269   Dali::BaseHandle *argp1 ;
49270   Dali::Toolkit::TextLabel result;
49271
49272   argp1 = (Dali::BaseHandle *)jarg1;
49273   if (!argp1) {
49274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49275     return 0;
49276   }
49277   arg1 = *argp1;
49278   {
49279     try {
49280       result = Dali::Toolkit::TextLabel::DownCast(arg1);
49281     } CALL_CATCH_EXCEPTION(0);
49282   }
49283
49284   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
49285   return jresult;
49286 }
49287
49288
49289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
49290   void * jresult ;
49291   Dali::Toolkit::AccessibilityManager *result = 0 ;
49292
49293   {
49294     try {
49295       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
49296     } CALL_CATCH_EXCEPTION(0);
49297   }
49298
49299   jresult = (void *)result;
49300   return jresult;
49301 }
49302
49303
49304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
49305   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49306
49307   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49308   {
49309     try {
49310       delete arg1;
49311     } CALL_CATCH_EXCEPTION();
49312   }
49313
49314 }
49315
49316
49317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
49318   void * jresult ;
49319   Dali::Toolkit::AccessibilityManager result;
49320
49321   {
49322     try {
49323       result = Dali::Toolkit::AccessibilityManager::Get();
49324     } CALL_CATCH_EXCEPTION(0);
49325   }
49326
49327   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
49328   return jresult;
49329 }
49330
49331
49332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
49333   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49334   Dali::Actor arg2 ;
49335   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
49336   std::string *arg4 = 0 ;
49337   Dali::Actor *argp2 ;
49338
49339   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49340   argp2 = (Dali::Actor *)jarg2;
49341   if (!argp2) {
49342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49343     return ;
49344   }
49345   arg2 = *argp2;
49346   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
49347   if (!jarg4) {
49348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49349     return ;
49350   }
49351   std::string arg4_str(jarg4);
49352   arg4 = &arg4_str;
49353   {
49354     try {
49355       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
49356     } CALL_CATCH_EXCEPTION();
49357   }
49358
49359
49360   //argout typemap for const std::string&
49361
49362 }
49363
49364
49365 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
49366   char * jresult ;
49367   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49368   Dali::Actor arg2 ;
49369   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
49370   Dali::Actor *argp2 ;
49371   std::string result;
49372
49373   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49374   argp2 = (Dali::Actor *)jarg2;
49375   if (!argp2) {
49376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49377     return 0;
49378   }
49379   arg2 = *argp2;
49380   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
49381   {
49382     try {
49383       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
49384     } CALL_CATCH_EXCEPTION(0);
49385   }
49386
49387   jresult = SWIG_csharp_string_callback((&result)->c_str());
49388   return jresult;
49389 }
49390
49391
49392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
49393   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49394   Dali::Actor arg2 ;
49395   unsigned int arg3 ;
49396   Dali::Actor *argp2 ;
49397
49398   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49399   argp2 = (Dali::Actor *)jarg2;
49400   if (!argp2) {
49401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49402     return ;
49403   }
49404   arg2 = *argp2;
49405   arg3 = (unsigned int)jarg3;
49406   {
49407     try {
49408       (arg1)->SetFocusOrder(arg2,arg3);
49409     } CALL_CATCH_EXCEPTION();
49410   }
49411
49412 }
49413
49414
49415 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
49416   unsigned int jresult ;
49417   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49418   Dali::Actor arg2 ;
49419   Dali::Actor *argp2 ;
49420   unsigned int result;
49421
49422   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49423   argp2 = (Dali::Actor *)jarg2;
49424   if (!argp2) {
49425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49426     return 0;
49427   }
49428   arg2 = *argp2;
49429   {
49430     try {
49431       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
49432     } CALL_CATCH_EXCEPTION(0);
49433   }
49434
49435   jresult = result;
49436   return jresult;
49437 }
49438
49439
49440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
49441   unsigned int jresult ;
49442   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49443   unsigned int result;
49444
49445   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49446   {
49447     try {
49448       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
49449     } CALL_CATCH_EXCEPTION(0);
49450   }
49451
49452   jresult = result;
49453   return jresult;
49454 }
49455
49456
49457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
49458   void * jresult ;
49459   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49460   unsigned int arg2 ;
49461   Dali::Actor result;
49462
49463   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49464   arg2 = (unsigned int)jarg2;
49465   {
49466     try {
49467       result = (arg1)->GetActorByFocusOrder(arg2);
49468     } CALL_CATCH_EXCEPTION(0);
49469   }
49470
49471   jresult = new Dali::Actor((const Dali::Actor &)result);
49472   return jresult;
49473 }
49474
49475
49476 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
49477   bool jresult ;
49478   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49479   Dali::Actor arg2 ;
49480   Dali::Actor *argp2 ;
49481   bool result;
49482
49483   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49484   argp2 = (Dali::Actor *)jarg2;
49485   if (!argp2) {
49486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49487     return 0;
49488   }
49489   arg2 = *argp2;
49490   {
49491     try {
49492       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
49493     } CALL_CATCH_EXCEPTION(0);
49494   }
49495
49496   jresult = result;
49497   return jresult;
49498 }
49499
49500
49501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
49502   void * jresult ;
49503   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49504   Dali::Actor result;
49505
49506   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49507   {
49508     try {
49509       result = (arg1)->GetCurrentFocusActor();
49510     } CALL_CATCH_EXCEPTION(0);
49511   }
49512
49513   jresult = new Dali::Actor((const Dali::Actor &)result);
49514   return jresult;
49515 }
49516
49517
49518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
49519   void * jresult ;
49520   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49521   Dali::Actor result;
49522
49523   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49524   {
49525     try {
49526       result = (arg1)->GetCurrentFocusGroup();
49527     } CALL_CATCH_EXCEPTION(0);
49528   }
49529
49530   jresult = new Dali::Actor((const Dali::Actor &)result);
49531   return jresult;
49532 }
49533
49534
49535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
49536   unsigned int jresult ;
49537   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49538   unsigned int result;
49539
49540   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49541   {
49542     try {
49543       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
49544     } CALL_CATCH_EXCEPTION(0);
49545   }
49546
49547   jresult = result;
49548   return jresult;
49549 }
49550
49551
49552 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
49553   bool jresult ;
49554   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49555   bool result;
49556
49557   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49558   {
49559     try {
49560       result = (bool)(arg1)->MoveFocusForward();
49561     } CALL_CATCH_EXCEPTION(0);
49562   }
49563
49564   jresult = result;
49565   return jresult;
49566 }
49567
49568
49569 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
49570   bool jresult ;
49571   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49572   bool result;
49573
49574   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49575   {
49576     try {
49577       result = (bool)(arg1)->MoveFocusBackward();
49578     } CALL_CATCH_EXCEPTION(0);
49579   }
49580
49581   jresult = result;
49582   return jresult;
49583 }
49584
49585
49586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
49587   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49588
49589   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49590   {
49591     try {
49592       (arg1)->ClearFocus();
49593     } CALL_CATCH_EXCEPTION();
49594   }
49595
49596 }
49597
49598
49599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
49600   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49601
49602   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49603   {
49604     try {
49605       (arg1)->Reset();
49606     } CALL_CATCH_EXCEPTION();
49607   }
49608
49609 }
49610
49611
49612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, bool jarg3) {
49613   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49614   Dali::Actor arg2 ;
49615   bool arg3 ;
49616   Dali::Actor *argp2 ;
49617
49618   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49619   argp2 = (Dali::Actor *)jarg2;
49620   if (!argp2) {
49621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49622     return ;
49623   }
49624   arg2 = *argp2;
49625   arg3 = jarg3 ? true : false;
49626   {
49627     try {
49628       (arg1)->SetFocusGroup(arg2,arg3);
49629     } CALL_CATCH_EXCEPTION();
49630   }
49631
49632 }
49633
49634
49635 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
49636   bool jresult ;
49637   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49638   Dali::Actor arg2 ;
49639   Dali::Actor *argp2 ;
49640   bool result;
49641
49642   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49643   argp2 = (Dali::Actor *)jarg2;
49644   if (!argp2) {
49645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49646     return 0;
49647   }
49648   arg2 = *argp2;
49649   {
49650     try {
49651       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
49652     } CALL_CATCH_EXCEPTION(0);
49653   }
49654
49655   jresult = result;
49656   return jresult;
49657 }
49658
49659
49660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, bool jarg2) {
49661   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49662   bool arg2 ;
49663
49664   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49665   arg2 = jarg2 ? true : false;
49666   {
49667     try {
49668       (arg1)->SetGroupMode(arg2);
49669     } CALL_CATCH_EXCEPTION();
49670   }
49671
49672 }
49673
49674
49675 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
49676   bool jresult ;
49677   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49678   bool result;
49679
49680   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49681   {
49682     try {
49683       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
49684     } CALL_CATCH_EXCEPTION(0);
49685   }
49686
49687   jresult = result;
49688   return jresult;
49689 }
49690
49691
49692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, bool jarg2) {
49693   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49694   bool arg2 ;
49695
49696   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49697   arg2 = jarg2 ? true : false;
49698   {
49699     try {
49700       (arg1)->SetWrapMode(arg2);
49701     } CALL_CATCH_EXCEPTION();
49702   }
49703
49704 }
49705
49706
49707 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
49708   bool jresult ;
49709   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49710   bool result;
49711
49712   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49713   {
49714     try {
49715       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
49716     } CALL_CATCH_EXCEPTION(0);
49717   }
49718
49719   jresult = result;
49720   return jresult;
49721 }
49722
49723
49724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
49725   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49726   Dali::Actor arg2 ;
49727   Dali::Actor *argp2 ;
49728
49729   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49730   argp2 = (Dali::Actor *)jarg2;
49731   if (!argp2) {
49732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49733     return ;
49734   }
49735   arg2 = *argp2;
49736   {
49737     try {
49738       (arg1)->SetFocusIndicatorActor(arg2);
49739     } CALL_CATCH_EXCEPTION();
49740   }
49741
49742 }
49743
49744
49745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
49746   void * jresult ;
49747   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49748   Dali::Actor result;
49749
49750   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49751   {
49752     try {
49753       result = (arg1)->GetFocusIndicatorActor();
49754     } CALL_CATCH_EXCEPTION(0);
49755   }
49756
49757   jresult = new Dali::Actor((const Dali::Actor &)result);
49758   return jresult;
49759 }
49760
49761
49762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
49763   void * jresult ;
49764   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49765   Dali::Actor arg2 ;
49766   Dali::Actor *argp2 ;
49767   Dali::Actor result;
49768
49769   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49770   argp2 = (Dali::Actor *)jarg2;
49771   if (!argp2) {
49772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49773     return 0;
49774   }
49775   arg2 = *argp2;
49776   {
49777     try {
49778       result = (arg1)->GetFocusGroup(arg2);
49779     } CALL_CATCH_EXCEPTION(0);
49780   }
49781
49782   jresult = new Dali::Actor((const Dali::Actor &)result);
49783   return jresult;
49784 }
49785
49786
49787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
49788   void * jresult ;
49789   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49790   Dali::Vector2 result;
49791
49792   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49793   {
49794     try {
49795       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
49796     } CALL_CATCH_EXCEPTION(0);
49797   }
49798
49799   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
49800   return jresult;
49801 }
49802
49803
49804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
49805   void * jresult ;
49806   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49807   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
49808
49809   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49810   {
49811     try {
49812       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
49813     } CALL_CATCH_EXCEPTION(0);
49814   }
49815
49816   jresult = (void *)result;
49817   return jresult;
49818 }
49819
49820
49821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
49822   void * jresult ;
49823   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49824   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
49825
49826   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49827   {
49828     try {
49829       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
49830     } CALL_CATCH_EXCEPTION(0);
49831   }
49832
49833   jresult = (void *)result;
49834   return jresult;
49835 }
49836
49837
49838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
49839   void * jresult ;
49840   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49841   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
49842
49843   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49844   {
49845     try {
49846       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
49847     } CALL_CATCH_EXCEPTION(0);
49848   }
49849
49850   jresult = (void *)result;
49851   return jresult;
49852 }
49853
49854
49855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
49856   void * jresult ;
49857   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49858   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49859
49860   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49861   {
49862     try {
49863       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
49864     } CALL_CATCH_EXCEPTION(0);
49865   }
49866
49867   jresult = (void *)result;
49868   return jresult;
49869 }
49870
49871
49872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
49873   void * jresult ;
49874   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49875   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49876
49877   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49878   {
49879     try {
49880       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
49881     } CALL_CATCH_EXCEPTION(0);
49882   }
49883
49884   jresult = (void *)result;
49885   return jresult;
49886 }
49887
49888
49889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
49890   void * jresult ;
49891   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49892   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49893
49894   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49895   {
49896     try {
49897       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
49898     } CALL_CATCH_EXCEPTION(0);
49899   }
49900
49901   jresult = (void *)result;
49902   return jresult;
49903 }
49904
49905
49906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
49907   void * jresult ;
49908   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49909   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49910
49911   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49912   {
49913     try {
49914       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
49915     } CALL_CATCH_EXCEPTION(0);
49916   }
49917
49918   jresult = (void *)result;
49919   return jresult;
49920 }
49921
49922
49923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
49924   void * jresult ;
49925   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49926   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49927
49928   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49929   {
49930     try {
49931       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
49932     } CALL_CATCH_EXCEPTION(0);
49933   }
49934
49935   jresult = (void *)result;
49936   return jresult;
49937 }
49938
49939
49940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
49941   void * jresult ;
49942   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49943   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49944
49945   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49946   {
49947     try {
49948       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
49949     } CALL_CATCH_EXCEPTION(0);
49950   }
49951
49952   jresult = (void *)result;
49953   return jresult;
49954 }
49955
49956
49957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
49958   void * jresult ;
49959   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49960   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49961
49962   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49963   {
49964     try {
49965       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
49966     } CALL_CATCH_EXCEPTION(0);
49967   }
49968
49969   jresult = (void *)result;
49970   return jresult;
49971 }
49972
49973
49974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
49975   void * jresult ;
49976   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49977   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49978
49979   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49980   {
49981     try {
49982       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
49983     } CALL_CATCH_EXCEPTION(0);
49984   }
49985
49986   jresult = (void *)result;
49987   return jresult;
49988 }
49989
49990
49991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
49992   void * jresult ;
49993   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
49994   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
49995
49996   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
49997   {
49998     try {
49999       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
50000     } CALL_CATCH_EXCEPTION(0);
50001   }
50002
50003   jresult = (void *)result;
50004   return jresult;
50005 }
50006
50007
50008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
50009   void * jresult ;
50010   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50011   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50012
50013   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50014   {
50015     try {
50016       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
50017     } CALL_CATCH_EXCEPTION(0);
50018   }
50019
50020   jresult = (void *)result;
50021   return jresult;
50022 }
50023
50024
50025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
50026   void * jresult ;
50027   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50028   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50029
50030   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50031   {
50032     try {
50033       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
50034     } CALL_CATCH_EXCEPTION(0);
50035   }
50036
50037   jresult = (void *)result;
50038   return jresult;
50039 }
50040
50041
50042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
50043   void * jresult ;
50044   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50045   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50046
50047   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50048   {
50049     try {
50050       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
50051     } CALL_CATCH_EXCEPTION(0);
50052   }
50053
50054   jresult = (void *)result;
50055   return jresult;
50056 }
50057
50058
50059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
50060   void * jresult ;
50061   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50062   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50063
50064   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50065   {
50066     try {
50067       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
50068     } CALL_CATCH_EXCEPTION(0);
50069   }
50070
50071   jresult = (void *)result;
50072   return jresult;
50073 }
50074
50075
50076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
50077   void * jresult ;
50078   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50079   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50080
50081   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50082   {
50083     try {
50084       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
50085     } CALL_CATCH_EXCEPTION(0);
50086   }
50087
50088   jresult = (void *)result;
50089   return jresult;
50090 }
50091
50092
50093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
50094   void * jresult ;
50095   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50096   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50097
50098   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50099   {
50100     try {
50101       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
50102     } CALL_CATCH_EXCEPTION(0);
50103   }
50104
50105   jresult = (void *)result;
50106   return jresult;
50107 }
50108
50109
50110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
50111   void * jresult ;
50112   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50113   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50114
50115   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50116   {
50117     try {
50118       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
50119     } CALL_CATCH_EXCEPTION(0);
50120   }
50121
50122   jresult = (void *)result;
50123   return jresult;
50124 }
50125
50126
50127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
50128   void * jresult ;
50129   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50130   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50131
50132   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50133   {
50134     try {
50135       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
50136     } CALL_CATCH_EXCEPTION(0);
50137   }
50138
50139   jresult = (void *)result;
50140   return jresult;
50141 }
50142
50143
50144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
50145   void * jresult ;
50146   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50147   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50148
50149   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50150   {
50151     try {
50152       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
50153     } CALL_CATCH_EXCEPTION(0);
50154   }
50155
50156   jresult = (void *)result;
50157   return jresult;
50158 }
50159
50160
50161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
50162   void * jresult ;
50163   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50164   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50165
50166   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50167   {
50168     try {
50169       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
50170     } CALL_CATCH_EXCEPTION(0);
50171   }
50172
50173   jresult = (void *)result;
50174   return jresult;
50175 }
50176
50177
50178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
50179   void * jresult ;
50180   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50181   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50182
50183   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50184   {
50185     try {
50186       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
50187     } CALL_CATCH_EXCEPTION(0);
50188   }
50189
50190   jresult = (void *)result;
50191   return jresult;
50192 }
50193
50194
50195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
50196   void * jresult ;
50197   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50198   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50199
50200   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50201   {
50202     try {
50203       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
50204     } CALL_CATCH_EXCEPTION(0);
50205   }
50206
50207   jresult = (void *)result;
50208   return jresult;
50209 }
50210
50211
50212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
50213   void * jresult ;
50214   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50215   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50216
50217   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50218   {
50219     try {
50220       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
50221     } CALL_CATCH_EXCEPTION(0);
50222   }
50223
50224   jresult = (void *)result;
50225   return jresult;
50226 }
50227
50228
50229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
50230   void * jresult ;
50231   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50232   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50233
50234   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50235   {
50236     try {
50237       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
50238     } CALL_CATCH_EXCEPTION(0);
50239   }
50240
50241   jresult = (void *)result;
50242   return jresult;
50243 }
50244
50245
50246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
50247   void * jresult ;
50248   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50249   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50250
50251   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50252   {
50253     try {
50254       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
50255     } CALL_CATCH_EXCEPTION(0);
50256   }
50257
50258   jresult = (void *)result;
50259   return jresult;
50260 }
50261
50262
50263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
50264   void * jresult ;
50265   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50266   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
50267
50268   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50269   {
50270     try {
50271       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
50272     } CALL_CATCH_EXCEPTION(0);
50273   }
50274
50275   jresult = (void *)result;
50276   return jresult;
50277 }
50278
50279
50280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
50281   void * jresult ;
50282   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
50283   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
50284
50285   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
50286   {
50287     try {
50288       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
50289     } CALL_CATCH_EXCEPTION(0);
50290   }
50291
50292   jresult = (void *)result;
50293   return jresult;
50294 }
50295
50296
50297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
50298   void * jresult ;
50299   Dali::Toolkit::StyleManager *result = 0 ;
50300
50301   {
50302     try {
50303       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
50304     } CALL_CATCH_EXCEPTION(0);
50305   }
50306
50307   jresult = (void *)result;
50308   return jresult;
50309 }
50310
50311
50312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
50313   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
50314
50315   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
50316   {
50317     try {
50318       delete arg1;
50319     } CALL_CATCH_EXCEPTION();
50320   }
50321
50322 }
50323
50324
50325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
50326   void * jresult ;
50327   Dali::Toolkit::StyleManager result;
50328
50329   {
50330     try {
50331       result = Dali::Toolkit::StyleManager::Get();
50332     } CALL_CATCH_EXCEPTION(0);
50333   }
50334
50335   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
50336   return jresult;
50337 }
50338
50339
50340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
50341   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
50342   std::string *arg2 = 0 ;
50343
50344   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
50345   if (!jarg2) {
50346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
50347     return ;
50348   }
50349   std::string arg2_str(jarg2);
50350   arg2 = &arg2_str;
50351   {
50352     try {
50353       (arg1)->ApplyTheme((std::string const &)*arg2);
50354     } CALL_CATCH_EXCEPTION();
50355   }
50356
50357
50358   //argout typemap for const std::string&
50359
50360 }
50361
50362
50363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
50364   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
50365
50366   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
50367   {
50368     try {
50369       (arg1)->ApplyDefaultTheme();
50370     } CALL_CATCH_EXCEPTION();
50371   }
50372
50373 }
50374
50375
50376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
50377   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
50378   std::string *arg2 = 0 ;
50379   Dali::Property::Value *arg3 = 0 ;
50380
50381   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
50382   if (!jarg2) {
50383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
50384     return ;
50385   }
50386   std::string arg2_str(jarg2);
50387   arg2 = &arg2_str;
50388   arg3 = (Dali::Property::Value *)jarg3;
50389   if (!arg3) {
50390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
50391     return ;
50392   }
50393   {
50394     try {
50395       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
50396     } CALL_CATCH_EXCEPTION();
50397   }
50398
50399
50400   //argout typemap for const std::string&
50401
50402 }
50403
50404
50405 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
50406   bool jresult ;
50407   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
50408   std::string *arg2 = 0 ;
50409   Dali::Property::Value *arg3 = 0 ;
50410   bool result;
50411
50412   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
50413   if (!jarg2) {
50414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
50415     return 0;
50416   }
50417   std::string arg2_str(jarg2);
50418   arg2 = &arg2_str;
50419   arg3 = (Dali::Property::Value *)jarg3;
50420   if (!arg3) {
50421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
50422     return 0;
50423   }
50424   {
50425     try {
50426       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
50427     } CALL_CATCH_EXCEPTION(0);
50428   }
50429
50430   jresult = result;
50431
50432   //argout typemap for const std::string&
50433
50434   return jresult;
50435 }
50436
50437
50438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
50439   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
50440   Dali::Toolkit::Control arg2 ;
50441   std::string *arg3 = 0 ;
50442   std::string *arg4 = 0 ;
50443   Dali::Toolkit::Control *argp2 ;
50444
50445   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
50446   argp2 = (Dali::Toolkit::Control *)jarg2;
50447   if (!argp2) {
50448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
50449     return ;
50450   }
50451   arg2 = *argp2;
50452   if (!jarg3) {
50453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
50454     return ;
50455   }
50456   std::string arg3_str(jarg3);
50457   arg3 = &arg3_str;
50458   if (!jarg4) {
50459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
50460     return ;
50461   }
50462   std::string arg4_str(jarg4);
50463   arg4 = &arg4_str;
50464   {
50465     try {
50466       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
50467     } CALL_CATCH_EXCEPTION();
50468   }
50469
50470
50471   //argout typemap for const std::string&
50472
50473
50474   //argout typemap for const std::string&
50475
50476 }
50477
50478
50479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
50480   void * jresult ;
50481   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
50482   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
50483
50484   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
50485   {
50486     try {
50487       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
50488     } CALL_CATCH_EXCEPTION(0);
50489   }
50490
50491   jresult = (void *)result;
50492   return jresult;
50493 }
50494
50495
50496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
50497   int jresult ;
50498   int result;
50499
50500   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
50501   jresult = (int)result;
50502   return jresult;
50503 }
50504
50505
50506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
50507   int jresult ;
50508   int result;
50509
50510   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
50511   jresult = (int)result;
50512   return jresult;
50513 }
50514
50515
50516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
50517   int jresult ;
50518   int result;
50519
50520   result = (int)Dali::Toolkit::Slider::Property::VALUE;
50521   jresult = (int)result;
50522   return jresult;
50523 }
50524
50525
50526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
50527   int jresult ;
50528   int result;
50529
50530   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
50531   jresult = (int)result;
50532   return jresult;
50533 }
50534
50535
50536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
50537   int jresult ;
50538   int result;
50539
50540   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
50541   jresult = (int)result;
50542   return jresult;
50543 }
50544
50545
50546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
50547   int jresult ;
50548   int result;
50549
50550   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
50551   jresult = (int)result;
50552   return jresult;
50553 }
50554
50555
50556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
50557   int jresult ;
50558   int result;
50559
50560   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
50561   jresult = (int)result;
50562   return jresult;
50563 }
50564
50565
50566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
50567   int jresult ;
50568   int result;
50569
50570   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
50571   jresult = (int)result;
50572   return jresult;
50573 }
50574
50575
50576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
50577   int jresult ;
50578   int result;
50579
50580   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
50581   jresult = (int)result;
50582   return jresult;
50583 }
50584
50585
50586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
50587   int jresult ;
50588   int result;
50589
50590   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
50591   jresult = (int)result;
50592   return jresult;
50593 }
50594
50595
50596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
50597   int jresult ;
50598   int result;
50599
50600   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
50601   jresult = (int)result;
50602   return jresult;
50603 }
50604
50605
50606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
50607   int jresult ;
50608   int result;
50609
50610   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
50611   jresult = (int)result;
50612   return jresult;
50613 }
50614
50615
50616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
50617   int jresult ;
50618   int result;
50619
50620   result = (int)Dali::Toolkit::Slider::Property::MARKS;
50621   jresult = (int)result;
50622   return jresult;
50623 }
50624
50625
50626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
50627   int jresult ;
50628   int result;
50629
50630   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
50631   jresult = (int)result;
50632   return jresult;
50633 }
50634
50635
50636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
50637   int jresult ;
50638   int result;
50639
50640   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
50641   jresult = (int)result;
50642   return jresult;
50643 }
50644
50645
50646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
50647   void * jresult ;
50648   Dali::Toolkit::Slider::Property *result = 0 ;
50649
50650   {
50651     try {
50652       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
50653     } CALL_CATCH_EXCEPTION(0);
50654   }
50655
50656   jresult = (void *)result;
50657   return jresult;
50658 }
50659
50660
50661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
50662   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
50663
50664   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
50665   {
50666     try {
50667       delete arg1;
50668     } CALL_CATCH_EXCEPTION();
50669   }
50670
50671 }
50672
50673
50674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
50675   void * jresult ;
50676   Dali::Toolkit::Slider result;
50677
50678   {
50679     try {
50680       result = Dali::Toolkit::Slider::New();
50681     } CALL_CATCH_EXCEPTION(0);
50682   }
50683
50684   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
50685   return jresult;
50686 }
50687
50688
50689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
50690   void * jresult ;
50691   Dali::Toolkit::Slider *result = 0 ;
50692
50693   {
50694     try {
50695       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
50696     } CALL_CATCH_EXCEPTION(0);
50697   }
50698
50699   jresult = (void *)result;
50700   return jresult;
50701 }
50702
50703
50704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
50705   void * jresult ;
50706   Dali::Toolkit::Slider *arg1 = 0 ;
50707   Dali::Toolkit::Slider *result = 0 ;
50708
50709   arg1 = (Dali::Toolkit::Slider *)jarg1;
50710   if (!arg1) {
50711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
50712     return 0;
50713   }
50714   {
50715     try {
50716       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
50717     } CALL_CATCH_EXCEPTION(0);
50718   }
50719
50720   jresult = (void *)result;
50721   return jresult;
50722 }
50723
50724
50725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
50726   void * jresult ;
50727   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
50728   Dali::Toolkit::Slider *arg2 = 0 ;
50729   Dali::Toolkit::Slider *result = 0 ;
50730
50731   arg1 = (Dali::Toolkit::Slider *)jarg1;
50732   arg2 = (Dali::Toolkit::Slider *)jarg2;
50733   if (!arg2) {
50734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
50735     return 0;
50736   }
50737   {
50738     try {
50739       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
50740     } CALL_CATCH_EXCEPTION(0);
50741   }
50742
50743   jresult = (void *)result;
50744   return jresult;
50745 }
50746
50747
50748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
50749   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
50750
50751   arg1 = (Dali::Toolkit::Slider *)jarg1;
50752   {
50753     try {
50754       delete arg1;
50755     } CALL_CATCH_EXCEPTION();
50756   }
50757
50758 }
50759
50760
50761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
50762   void * jresult ;
50763   Dali::BaseHandle arg1 ;
50764   Dali::BaseHandle *argp1 ;
50765   Dali::Toolkit::Slider result;
50766
50767   argp1 = (Dali::BaseHandle *)jarg1;
50768   if (!argp1) {
50769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50770     return 0;
50771   }
50772   arg1 = *argp1;
50773   {
50774     try {
50775       result = Dali::Toolkit::Slider::DownCast(arg1);
50776     } CALL_CATCH_EXCEPTION(0);
50777   }
50778
50779   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
50780   return jresult;
50781 }
50782
50783
50784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
50785   void * jresult ;
50786   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
50787   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
50788
50789   arg1 = (Dali::Toolkit::Slider *)jarg1;
50790   {
50791     try {
50792       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
50793     } CALL_CATCH_EXCEPTION(0);
50794   }
50795
50796   jresult = (void *)result;
50797   return jresult;
50798 }
50799
50800
50801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
50802   void * jresult ;
50803   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
50804   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
50805
50806   arg1 = (Dali::Toolkit::Slider *)jarg1;
50807   {
50808     try {
50809       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
50810     } CALL_CATCH_EXCEPTION(0);
50811   }
50812
50813   jresult = (void *)result;
50814   return jresult;
50815 }
50816
50817
50818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
50819   void * jresult ;
50820   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
50821   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
50822
50823   arg1 = (Dali::Toolkit::Slider *)jarg1;
50824   {
50825     try {
50826       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
50827     } CALL_CATCH_EXCEPTION(0);
50828   }
50829
50830   jresult = (void *)result;
50831   return jresult;
50832 }
50833
50834
50835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
50836   int jresult ;
50837   int result;
50838
50839   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
50840   jresult = (int)result;
50841   return jresult;
50842 }
50843
50844
50845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
50846   int jresult ;
50847   int result;
50848
50849   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
50850   jresult = (int)result;
50851   return jresult;
50852 }
50853
50854
50855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
50856   int jresult ;
50857   int result;
50858
50859   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
50860   jresult = (int)result;
50861   return jresult;
50862 }
50863
50864
50865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
50866   int jresult ;
50867   int result;
50868
50869   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
50870   jresult = (int)result;
50871   return jresult;
50872 }
50873
50874
50875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
50876   int result;
50877
50878   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
50879
50880   return result;
50881 }
50882
50883
50884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
50885   void * jresult ;
50886   Dali::Toolkit::VideoView::Property *result = 0 ;
50887
50888   {
50889     try {
50890       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
50891     } CALL_CATCH_EXCEPTION(0);
50892   }
50893
50894   jresult = (void *)result;
50895   return jresult;
50896 }
50897
50898
50899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
50900   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
50901
50902   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
50903   {
50904     try {
50905       delete arg1;
50906     } CALL_CATCH_EXCEPTION();
50907   }
50908
50909 }
50910
50911
50912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
50913   void * jresult ;
50914   Dali::Toolkit::VideoView result;
50915
50916   {
50917     try {
50918       result = Dali::Toolkit::VideoView::New();
50919     } CALL_CATCH_EXCEPTION(0);
50920   }
50921
50922   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
50923   return jresult;
50924 }
50925
50926
50927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
50928   void * jresult ;
50929   std::string *arg1 = 0 ;
50930   Dali::Toolkit::VideoView result;
50931
50932   if (!jarg1) {
50933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
50934     return 0;
50935   }
50936   std::string arg1_str(jarg1);
50937   arg1 = &arg1_str;
50938   {
50939     try {
50940       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
50941     } CALL_CATCH_EXCEPTION(0);
50942   }
50943
50944   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
50945
50946   //argout typemap for const std::string&
50947
50948   return jresult;
50949 }
50950
50951
50952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
50953   void * jresult ;
50954   Dali::Toolkit::VideoView result;
50955   {
50956     try {
50957       result = Dali::Toolkit::VideoView::New(swCodec);
50958     } CALL_CATCH_EXCEPTION(0);
50959   }
50960
50961   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
50962
50963   //argout typemap for const std::string&
50964
50965   return jresult;
50966 }
50967
50968
50969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
50970   void * jresult ;
50971   std::string *arg1 = 0 ;
50972   Dali::Toolkit::VideoView result;
50973
50974   if (!jarg1) {
50975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
50976     return 0;
50977   }
50978   std::string arg1_str(jarg1);
50979   arg1 = &arg1_str;
50980   {
50981     try {
50982       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
50983     } CALL_CATCH_EXCEPTION(0);
50984   }
50985
50986   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
50987
50988   //argout typemap for const std::string&
50989
50990   return jresult;
50991 }
50992
50993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_4(unsigned int jarg1) {
50994   void * jresult ;
50995   Dali::VideoSyncMode syncMode;
50996   Dali::Toolkit::VideoView result;
50997
50998   syncMode = static_cast<Dali::VideoSyncMode>(jarg1);
50999
51000   {
51001     try {
51002       result = Dali::Toolkit::DevelVideoView::New(syncMode);
51003     } CALL_CATCH_EXCEPTION(0);
51004   }
51005
51006   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
51007
51008   return jresult;
51009 }
51010
51011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
51012   void * jresult ;
51013   Dali::Toolkit::VideoView *result = 0 ;
51014
51015   {
51016     try {
51017       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
51018     } CALL_CATCH_EXCEPTION(0);
51019   }
51020
51021   jresult = (void *)result;
51022   return jresult;
51023 }
51024
51025
51026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
51027   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
51028
51029   arg1 = (Dali::Toolkit::VideoView *)jarg1;
51030   {
51031     try {
51032       delete arg1;
51033     } CALL_CATCH_EXCEPTION();
51034   }
51035
51036 }
51037
51038
51039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
51040   void * jresult ;
51041   Dali::Toolkit::VideoView *arg1 = 0 ;
51042   Dali::Toolkit::VideoView *result = 0 ;
51043
51044   arg1 = (Dali::Toolkit::VideoView *)jarg1;
51045   if (!arg1) {
51046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
51047     return 0;
51048   }
51049   {
51050     try {
51051       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
51052     } CALL_CATCH_EXCEPTION(0);
51053   }
51054
51055   jresult = (void *)result;
51056   return jresult;
51057 }
51058
51059
51060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
51061   void * jresult ;
51062   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
51063   Dali::Toolkit::VideoView *arg2 = 0 ;
51064   Dali::Toolkit::VideoView *result = 0 ;
51065
51066   arg1 = (Dali::Toolkit::VideoView *)jarg1;
51067   arg2 = (Dali::Toolkit::VideoView *)jarg2;
51068   if (!arg2) {
51069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
51070     return 0;
51071   }
51072   {
51073     try {
51074       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
51075     } CALL_CATCH_EXCEPTION(0);
51076   }
51077
51078   jresult = (void *)result;
51079   return jresult;
51080 }
51081
51082
51083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
51084   void * jresult ;
51085   Dali::BaseHandle arg1 ;
51086   Dali::BaseHandle *argp1 ;
51087   Dali::Toolkit::VideoView result;
51088
51089   argp1 = (Dali::BaseHandle *)jarg1;
51090   if (!argp1) {
51091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51092     return 0;
51093   }
51094   arg1 = *argp1;
51095   {
51096     try {
51097       result = Dali::Toolkit::VideoView::DownCast(arg1);
51098     } CALL_CATCH_EXCEPTION(0);
51099   }
51100
51101   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
51102   return jresult;
51103 }
51104
51105
51106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
51107   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
51108
51109   arg1 = (Dali::Toolkit::VideoView *)jarg1;
51110   {
51111     try {
51112       (arg1)->Play();
51113     } CALL_CATCH_EXCEPTION();
51114   }
51115
51116 }
51117
51118
51119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
51120   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
51121
51122   arg1 = (Dali::Toolkit::VideoView *)jarg1;
51123   {
51124     try {
51125       (arg1)->Pause();
51126     } CALL_CATCH_EXCEPTION();
51127   }
51128
51129 }
51130
51131
51132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
51133   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
51134
51135   arg1 = (Dali::Toolkit::VideoView *)jarg1;
51136   {
51137     try {
51138       (arg1)->Stop();
51139     } CALL_CATCH_EXCEPTION();
51140   }
51141
51142 }
51143
51144
51145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
51146   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
51147   int arg2 ;
51148
51149   arg1 = (Dali::Toolkit::VideoView *)jarg1;
51150   arg2 = (int)jarg2;
51151   {
51152     try {
51153       (arg1)->Forward(arg2);
51154     } CALL_CATCH_EXCEPTION();
51155   }
51156
51157 }
51158
51159
51160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
51161   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
51162   int arg2 ;
51163
51164   arg1 = (Dali::Toolkit::VideoView *)jarg1;
51165   arg2 = (int)jarg2;
51166   {
51167     try {
51168       (arg1)->Backward(arg2);
51169     } CALL_CATCH_EXCEPTION();
51170   }
51171
51172 }
51173
51174
51175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
51176   void * jresult ;
51177   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
51178   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
51179
51180   arg1 = (Dali::Toolkit::VideoView *)jarg1;
51181   {
51182     try {
51183       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
51184     } CALL_CATCH_EXCEPTION(0);
51185   }
51186
51187   jresult = (void *)result;
51188   return jresult;
51189 }
51190
51191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle(void * jarg1)
51192 {
51193   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
51194   if( arg1 == nullptr )
51195   {
51196     DALI_LOG_ERROR("VideoView is nullptr!");
51197     return nullptr;
51198   }
51199   void * ret = nullptr;
51200   {
51201     try{
51202
51203       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
51204       ret = Dali::AnyCast< void * >( result );
51205
51206     } CALL_CATCH_EXCEPTION(0);
51207   }
51208   return ret;
51209 }
51210
51211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraView_New__SWIG_0(void * jarg1, int jarg2) {
51212   void * jresult ;
51213   Dali::Toolkit::CameraView result;
51214
51215   Dali::Any arg1(jarg1);
51216   Dali::Toolkit::CameraView::DisplayType arg2 = static_cast<Dali::Toolkit::CameraView::DisplayType>(jarg2);
51217   {
51218     try {
51219       result = Dali::Toolkit::CameraView::New(arg1, arg2);
51220     } CALL_CATCH_EXCEPTION(0);
51221   }
51222
51223   jresult = new Dali::Toolkit::CameraView((const Dali::Toolkit::CameraView &)result);
51224   return jresult;
51225 }
51226
51227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraView__SWIG_0() {
51228   void * jresult ;
51229   Dali::Toolkit::CameraView *result = 0 ;
51230
51231   {
51232     try {
51233       result = (Dali::Toolkit::CameraView *)new Dali::Toolkit::CameraView();
51234     } CALL_CATCH_EXCEPTION(0);
51235   }
51236
51237   jresult = (void *)result;
51238   return jresult;
51239 }
51240
51241
51242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraView(void * jarg1) {
51243   Dali::Toolkit::CameraView *arg1 = (Dali::Toolkit::CameraView *) 0 ;
51244
51245   arg1 = (Dali::Toolkit::CameraView *)jarg1;
51246   {
51247     try {
51248       delete arg1;
51249     } CALL_CATCH_EXCEPTION();
51250   }
51251
51252 }
51253
51254
51255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraView__SWIG_1(void * jarg1) {
51256   void * jresult ;
51257   Dali::Toolkit::CameraView *arg1 = 0 ;
51258   Dali::Toolkit::CameraView *result = 0 ;
51259
51260   arg1 = (Dali::Toolkit::CameraView *)jarg1;
51261   if (!arg1) {
51262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CameraView const & type is null", 0);
51263     return 0;
51264   }
51265   {
51266     try {
51267       result = (Dali::Toolkit::CameraView *)new Dali::Toolkit::CameraView((Dali::Toolkit::CameraView const &)*arg1);
51268     } CALL_CATCH_EXCEPTION(0);
51269   }
51270
51271   jresult = (void *)result;
51272   return jresult;
51273 }
51274
51275
51276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraView_Assign(void * jarg1, void * jarg2) {
51277   void * jresult ;
51278   Dali::Toolkit::CameraView *arg1 = (Dali::Toolkit::CameraView *) 0 ;
51279   Dali::Toolkit::CameraView *arg2 = 0 ;
51280   Dali::Toolkit::CameraView *result = 0 ;
51281
51282   arg1 = (Dali::Toolkit::CameraView *)jarg1;
51283   arg2 = (Dali::Toolkit::CameraView *)jarg2;
51284   if (!arg2) {
51285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CameraView const & type is null", 0);
51286     return 0;
51287   }
51288   {
51289     try {
51290       result = (Dali::Toolkit::CameraView *) &(arg1)->operator =((Dali::Toolkit::CameraView const &)*arg2);
51291     } CALL_CATCH_EXCEPTION(0);
51292   }
51293
51294   jresult = (void *)result;
51295   return jresult;
51296 }
51297
51298
51299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraView_DownCast(void * jarg1) {
51300   void * jresult ;
51301   Dali::BaseHandle arg1 ;
51302   Dali::BaseHandle *argp1 ;
51303   Dali::Toolkit::CameraView result;
51304
51305   argp1 = (Dali::BaseHandle *)jarg1;
51306   if (!argp1) {
51307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51308     return 0;
51309   }
51310   arg1 = *argp1;
51311   {
51312     try {
51313       result = Dali::Toolkit::CameraView::DownCast(arg1);
51314     } CALL_CATCH_EXCEPTION(0);
51315   }
51316
51317   jresult = new Dali::Toolkit::CameraView((const Dali::Toolkit::CameraView &)result);
51318   return jresult;
51319 }
51320
51321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraView_Update(void * jarg1) {
51322   Dali::Toolkit::CameraView *arg1 = (Dali::Toolkit::CameraView *) 0 ;
51323
51324   arg1 = (Dali::Toolkit::CameraView *)jarg1;
51325   {
51326     try {
51327       (arg1)->Update();
51328     } CALL_CATCH_EXCEPTION();
51329   }
51330 }
51331
51332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_PlayAnimation(void * jarg1, void * jarg2)
51333 {
51334   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView*)jarg1;
51335   if(arg1 == nullptr)
51336   {
51337     DALI_LOG_ERROR("VideoView is nullptr!");
51338     return;
51339   }
51340   Dali::Animation *arg2 = (Dali::Animation*)jarg2;
51341   if(arg2 == nullptr)
51342   {
51343     DALI_LOG_ERROR("Animation is nullptr!");
51344     return;
51345   }
51346
51347   {
51348     try{
51349
51350       Toolkit::DevelVideoView::PlayAnimation(*arg1, *arg2);
51351     } CALL_CATCH_EXCEPTION();
51352   }
51353
51354 }
51355
51356
51357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
51358   int jresult ;
51359   int result;
51360
51361   result = (int)Dali::Toolkit::Popup::Property::TITLE;
51362   jresult = (int)result;
51363   return jresult;
51364 }
51365
51366
51367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
51368   int jresult ;
51369   int result;
51370
51371   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
51372   jresult = (int)result;
51373   return jresult;
51374 }
51375
51376
51377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
51378   int jresult ;
51379   int result;
51380
51381   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
51382   jresult = (int)result;
51383   return jresult;
51384 }
51385
51386
51387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
51388   int jresult ;
51389   int result;
51390
51391   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
51392   jresult = (int)result;
51393   return jresult;
51394 }
51395
51396
51397 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
51398   int jresult ;
51399   int result;
51400
51401   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
51402   jresult = (int)result;
51403   return jresult;
51404 }
51405
51406
51407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
51408   int jresult ;
51409   int result;
51410
51411   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
51412   jresult = (int)result;
51413   return jresult;
51414 }
51415
51416
51417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
51418   int jresult ;
51419   int result;
51420
51421   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
51422   jresult = (int)result;
51423   return jresult;
51424 }
51425
51426
51427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
51428   int jresult ;
51429   int result;
51430
51431   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
51432   jresult = (int)result;
51433   return jresult;
51434 }
51435
51436
51437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
51438   int jresult ;
51439   int result;
51440
51441   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
51442   jresult = (int)result;
51443   return jresult;
51444 }
51445
51446
51447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
51448   int jresult ;
51449   int result;
51450
51451   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
51452   jresult = (int)result;
51453   return jresult;
51454 }
51455
51456
51457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
51458   int jresult ;
51459   int result;
51460
51461   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
51462   jresult = (int)result;
51463   return jresult;
51464 }
51465
51466
51467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
51468   int jresult ;
51469   int result;
51470
51471   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
51472   jresult = (int)result;
51473   return jresult;
51474 }
51475
51476
51477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
51478   int jresult ;
51479   int result;
51480
51481   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
51482   jresult = (int)result;
51483   return jresult;
51484 }
51485
51486
51487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
51488   int jresult ;
51489   int result;
51490
51491   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
51492   jresult = (int)result;
51493   return jresult;
51494 }
51495
51496
51497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
51498   int jresult ;
51499   int result;
51500
51501   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
51502   jresult = (int)result;
51503   return jresult;
51504 }
51505
51506
51507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
51508   int jresult ;
51509   int result;
51510
51511   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
51512   jresult = (int)result;
51513   return jresult;
51514 }
51515
51516
51517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
51518   int jresult ;
51519   int result;
51520
51521   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
51522   jresult = (int)result;
51523   return jresult;
51524 }
51525
51526
51527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
51528   int jresult ;
51529   int result;
51530
51531   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
51532   jresult = (int)result;
51533   return jresult;
51534 }
51535
51536
51537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
51538   int jresult ;
51539   int result;
51540
51541   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
51542   jresult = (int)result;
51543   return jresult;
51544 }
51545
51546
51547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
51548   int jresult ;
51549   int result;
51550
51551   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
51552   jresult = (int)result;
51553   return jresult;
51554 }
51555
51556
51557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
51558   int jresult ;
51559   int result;
51560
51561   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
51562   jresult = (int)result;
51563   return jresult;
51564 }
51565
51566
51567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
51568   void * jresult ;
51569   Dali::Toolkit::Popup::Property *result = 0 ;
51570
51571   {
51572     try {
51573       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
51574     } CALL_CATCH_EXCEPTION(0);
51575   }
51576
51577   jresult = (void *)result;
51578   return jresult;
51579 }
51580
51581
51582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
51583   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
51584
51585   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
51586   {
51587     try {
51588       delete arg1;
51589     } CALL_CATCH_EXCEPTION();
51590   }
51591
51592 }
51593
51594
51595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
51596   void * jresult ;
51597   Dali::Toolkit::Popup *result = 0 ;
51598
51599   {
51600     try {
51601       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
51602     } CALL_CATCH_EXCEPTION(0);
51603   }
51604
51605   jresult = (void *)result;
51606   return jresult;
51607 }
51608
51609
51610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
51611   void * jresult ;
51612   Dali::Toolkit::Popup result;
51613
51614   {
51615     try {
51616       result = Dali::Toolkit::Popup::New();
51617     } CALL_CATCH_EXCEPTION(0);
51618   }
51619
51620   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
51621   return jresult;
51622 }
51623
51624
51625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
51626   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51627
51628   arg1 = (Dali::Toolkit::Popup *)jarg1;
51629   {
51630     try {
51631       delete arg1;
51632     } CALL_CATCH_EXCEPTION();
51633   }
51634
51635 }
51636
51637
51638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
51639   void * jresult ;
51640   Dali::Toolkit::Popup *arg1 = 0 ;
51641   Dali::Toolkit::Popup *result = 0 ;
51642
51643   arg1 = (Dali::Toolkit::Popup *)jarg1;
51644   if (!arg1) {
51645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
51646     return 0;
51647   }
51648   {
51649     try {
51650       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
51651     } CALL_CATCH_EXCEPTION(0);
51652   }
51653
51654   jresult = (void *)result;
51655   return jresult;
51656 }
51657
51658
51659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
51660   void * jresult ;
51661   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51662   Dali::Toolkit::Popup *arg2 = 0 ;
51663   Dali::Toolkit::Popup *result = 0 ;
51664
51665   arg1 = (Dali::Toolkit::Popup *)jarg1;
51666   arg2 = (Dali::Toolkit::Popup *)jarg2;
51667   if (!arg2) {
51668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
51669     return 0;
51670   }
51671   {
51672     try {
51673       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
51674     } CALL_CATCH_EXCEPTION(0);
51675   }
51676
51677   jresult = (void *)result;
51678   return jresult;
51679 }
51680
51681
51682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
51683   void * jresult ;
51684   Dali::BaseHandle arg1 ;
51685   Dali::BaseHandle *argp1 ;
51686   Dali::Toolkit::Popup result;
51687
51688   argp1 = (Dali::BaseHandle *)jarg1;
51689   if (!argp1) {
51690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51691     return 0;
51692   }
51693   arg1 = *argp1;
51694   {
51695     try {
51696       result = Dali::Toolkit::Popup::DownCast(arg1);
51697     } CALL_CATCH_EXCEPTION(0);
51698   }
51699
51700   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
51701   return jresult;
51702 }
51703
51704
51705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
51706   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51707   Dali::Actor arg2 ;
51708   Dali::Actor *argp2 ;
51709
51710   arg1 = (Dali::Toolkit::Popup *)jarg1;
51711   argp2 = (Dali::Actor *)jarg2;
51712   if (!argp2) {
51713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51714     return ;
51715   }
51716   arg2 = *argp2;
51717   {
51718     try {
51719       (arg1)->SetTitle(arg2);
51720     } CALL_CATCH_EXCEPTION();
51721   }
51722
51723 }
51724
51725
51726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
51727   void * jresult ;
51728   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51729   Dali::Actor result;
51730
51731   arg1 = (Dali::Toolkit::Popup *)jarg1;
51732   {
51733     try {
51734       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
51735     } CALL_CATCH_EXCEPTION(0);
51736   }
51737
51738   jresult = new Dali::Actor((const Dali::Actor &)result);
51739   return jresult;
51740 }
51741
51742
51743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
51744   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51745   Dali::Actor arg2 ;
51746   Dali::Actor *argp2 ;
51747
51748   arg1 = (Dali::Toolkit::Popup *)jarg1;
51749   argp2 = (Dali::Actor *)jarg2;
51750   if (!argp2) {
51751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51752     return ;
51753   }
51754   arg2 = *argp2;
51755   {
51756     try {
51757       (arg1)->SetContent(arg2);
51758     } CALL_CATCH_EXCEPTION();
51759   }
51760
51761 }
51762
51763
51764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
51765   void * jresult ;
51766   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51767   Dali::Actor result;
51768
51769   arg1 = (Dali::Toolkit::Popup *)jarg1;
51770   {
51771     try {
51772       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
51773     } CALL_CATCH_EXCEPTION(0);
51774   }
51775
51776   jresult = new Dali::Actor((const Dali::Actor &)result);
51777   return jresult;
51778 }
51779
51780
51781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
51782   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51783   Dali::Actor arg2 ;
51784   Dali::Actor *argp2 ;
51785
51786   arg1 = (Dali::Toolkit::Popup *)jarg1;
51787   argp2 = (Dali::Actor *)jarg2;
51788   if (!argp2) {
51789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51790     return ;
51791   }
51792   arg2 = *argp2;
51793   {
51794     try {
51795       (arg1)->SetFooter(arg2);
51796     } CALL_CATCH_EXCEPTION();
51797   }
51798
51799 }
51800
51801
51802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
51803   void * jresult ;
51804   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51805   Dali::Actor result;
51806
51807   arg1 = (Dali::Toolkit::Popup *)jarg1;
51808   {
51809     try {
51810       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
51811     } CALL_CATCH_EXCEPTION(0);
51812   }
51813
51814   jresult = new Dali::Actor((const Dali::Actor &)result);
51815   return jresult;
51816 }
51817
51818
51819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
51820   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51821   Dali::Toolkit::Popup::DisplayState arg2 ;
51822
51823   arg1 = (Dali::Toolkit::Popup *)jarg1;
51824   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
51825   {
51826     try {
51827       (arg1)->SetDisplayState(arg2);
51828     } CALL_CATCH_EXCEPTION();
51829   }
51830
51831 }
51832
51833
51834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
51835   int jresult ;
51836   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51837   Dali::Toolkit::Popup::DisplayState result;
51838
51839   arg1 = (Dali::Toolkit::Popup *)jarg1;
51840   {
51841     try {
51842       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
51843     } CALL_CATCH_EXCEPTION(0);
51844   }
51845
51846   jresult = (int)result;
51847   return jresult;
51848 }
51849
51850
51851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
51852   void * jresult ;
51853   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51854   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
51855
51856   arg1 = (Dali::Toolkit::Popup *)jarg1;
51857   {
51858     try {
51859       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
51860     } CALL_CATCH_EXCEPTION(0);
51861   }
51862
51863   jresult = (void *)result;
51864   return jresult;
51865 }
51866
51867
51868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
51869   void * jresult ;
51870   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51871   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
51872
51873   arg1 = (Dali::Toolkit::Popup *)jarg1;
51874   {
51875     try {
51876       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
51877     } CALL_CATCH_EXCEPTION(0);
51878   }
51879
51880   jresult = (void *)result;
51881   return jresult;
51882 }
51883
51884
51885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
51886   void * jresult ;
51887   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51888   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
51889
51890   arg1 = (Dali::Toolkit::Popup *)jarg1;
51891   {
51892     try {
51893       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
51894     } CALL_CATCH_EXCEPTION(0);
51895   }
51896
51897   jresult = (void *)result;
51898   return jresult;
51899 }
51900
51901
51902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
51903   void * jresult ;
51904   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51905   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
51906
51907   arg1 = (Dali::Toolkit::Popup *)jarg1;
51908   {
51909     try {
51910       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
51911     } CALL_CATCH_EXCEPTION(0);
51912   }
51913
51914   jresult = (void *)result;
51915   return jresult;
51916 }
51917
51918
51919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
51920   void * jresult ;
51921   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
51922   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
51923
51924   arg1 = (Dali::Toolkit::Popup *)jarg1;
51925   {
51926     try {
51927       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
51928     } CALL_CATCH_EXCEPTION(0);
51929   }
51930
51931   jresult = (void *)result;
51932   return jresult;
51933 }
51934
51935
51936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
51937   int jresult ;
51938   int result;
51939
51940   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
51941   jresult = (int)result;
51942   return jresult;
51943 }
51944
51945
51946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
51947   int jresult ;
51948   int result;
51949
51950   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
51951   jresult = (int)result;
51952   return jresult;
51953 }
51954
51955
51956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
51957   int jresult ;
51958   int result;
51959
51960   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
51961   jresult = (int)result;
51962   return jresult;
51963 }
51964
51965
51966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
51967   int jresult ;
51968   int result;
51969
51970   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
51971   jresult = (int)result;
51972   return jresult;
51973 }
51974
51975
51976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
51977   int jresult ;
51978   int result;
51979
51980   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
51981   jresult = (int)result;
51982   return jresult;
51983 }
51984
51985
51986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
51987   int jresult ;
51988   int result;
51989
51990   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
51991   jresult = (int)result;
51992   return jresult;
51993 }
51994
51995
51996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
51997   int jresult ;
51998   int result;
51999
52000   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
52001   jresult = (int)result;
52002   return jresult;
52003 }
52004
52005
52006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
52007   int jresult ;
52008   int result;
52009
52010   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
52011   jresult = (int)result;
52012   return jresult;
52013 }
52014
52015
52016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
52017   int jresult ;
52018   int result;
52019
52020   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
52021   jresult = (int)result;
52022   return jresult;
52023 }
52024
52025
52026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
52027   void * jresult ;
52028   Dali::Toolkit::ProgressBar::Property *result = 0 ;
52029
52030   {
52031     try {
52032       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
52033     } CALL_CATCH_EXCEPTION(0);
52034   }
52035
52036   jresult = (void *)result;
52037   return jresult;
52038 }
52039
52040
52041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
52042   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
52043
52044   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
52045   {
52046     try {
52047       delete arg1;
52048     } CALL_CATCH_EXCEPTION();
52049   }
52050
52051 }
52052
52053
52054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
52055   void * jresult ;
52056   Dali::Toolkit::ProgressBar result;
52057
52058   {
52059     try {
52060       result = Dali::Toolkit::ProgressBar::New();
52061     } CALL_CATCH_EXCEPTION(0);
52062   }
52063
52064   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
52065   return jresult;
52066 }
52067
52068
52069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
52070   void * jresult ;
52071   Dali::Toolkit::ProgressBar *result = 0 ;
52072
52073   {
52074     try {
52075       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
52076     } CALL_CATCH_EXCEPTION(0);
52077   }
52078
52079   jresult = (void *)result;
52080   return jresult;
52081 }
52082
52083
52084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
52085   void * jresult ;
52086   Dali::Toolkit::ProgressBar *arg1 = 0 ;
52087   Dali::Toolkit::ProgressBar *result = 0 ;
52088
52089   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
52090   if (!arg1) {
52091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
52092     return 0;
52093   }
52094   {
52095     try {
52096       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
52097     } CALL_CATCH_EXCEPTION(0);
52098   }
52099
52100   jresult = (void *)result;
52101   return jresult;
52102 }
52103
52104
52105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
52106   void * jresult ;
52107   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
52108   Dali::Toolkit::ProgressBar *arg2 = 0 ;
52109   Dali::Toolkit::ProgressBar *result = 0 ;
52110
52111   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
52112   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
52113   if (!arg2) {
52114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
52115     return 0;
52116   }
52117   {
52118     try {
52119       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
52120     } CALL_CATCH_EXCEPTION(0);
52121   }
52122
52123   jresult = (void *)result;
52124   return jresult;
52125 }
52126
52127
52128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
52129   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
52130
52131   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
52132   {
52133     try {
52134       delete arg1;
52135     } CALL_CATCH_EXCEPTION();
52136   }
52137
52138 }
52139
52140
52141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
52142   void * jresult ;
52143   Dali::BaseHandle arg1 ;
52144   Dali::BaseHandle *argp1 ;
52145   Dali::Toolkit::ProgressBar result;
52146
52147   argp1 = (Dali::BaseHandle *)jarg1;
52148   if (!argp1) {
52149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52150     return 0;
52151   }
52152   arg1 = *argp1;
52153   {
52154     try {
52155       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
52156     } CALL_CATCH_EXCEPTION(0);
52157   }
52158
52159   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
52160   return jresult;
52161 }
52162
52163
52164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
52165   void * jresult ;
52166   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
52167   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
52168
52169   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
52170   {
52171     try {
52172       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
52173     } CALL_CATCH_EXCEPTION(0);
52174   }
52175
52176   jresult = (void *)result;
52177   return jresult;
52178 }
52179
52180
52181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
52182   void * jresult ;
52183   Dali::Toolkit::GaussianBlurView *result = 0 ;
52184
52185   {
52186     try {
52187       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
52188     } CALL_CATCH_EXCEPTION(0);
52189   }
52190
52191   jresult = (void *)result;
52192   return jresult;
52193 }
52194
52195
52196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
52197   void * jresult ;
52198   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
52199   Dali::Toolkit::GaussianBlurView *result = 0 ;
52200
52201   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
52202   if (!arg1) {
52203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
52204     return 0;
52205   }
52206   {
52207     try {
52208       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
52209     } CALL_CATCH_EXCEPTION(0);
52210   }
52211
52212   jresult = (void *)result;
52213   return jresult;
52214 }
52215
52216
52217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
52218   void * jresult ;
52219   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
52220   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
52221   Dali::Toolkit::GaussianBlurView *result = 0 ;
52222
52223   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
52224   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
52225   if (!arg2) {
52226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
52227     return 0;
52228   }
52229   {
52230     try {
52231       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
52232     } CALL_CATCH_EXCEPTION(0);
52233   }
52234
52235   jresult = (void *)result;
52236   return jresult;
52237 }
52238
52239
52240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
52241   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
52242
52243   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
52244   {
52245     try {
52246       delete arg1;
52247     } CALL_CATCH_EXCEPTION();
52248   }
52249
52250 }
52251
52252
52253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
52254   void * jresult ;
52255   Dali::BaseHandle arg1 ;
52256   Dali::BaseHandle *argp1 ;
52257   Dali::Toolkit::GaussianBlurView result;
52258
52259   argp1 = (Dali::BaseHandle *)jarg1;
52260   if (!argp1) {
52261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52262     return 0;
52263   }
52264   arg1 = *argp1;
52265   {
52266     try {
52267       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
52268     } CALL_CATCH_EXCEPTION(0);
52269   }
52270
52271   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
52272   return jresult;
52273 }
52274
52275
52276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
52277   void * jresult ;
52278   Dali::Toolkit::GaussianBlurView result;
52279
52280   {
52281     try {
52282       result = Dali::Toolkit::GaussianBlurView::New();
52283     } CALL_CATCH_EXCEPTION(0);
52284   }
52285
52286   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
52287   return jresult;
52288 }
52289
52290
52291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, bool jarg6) {
52292   void * jresult ;
52293   unsigned int arg1 ;
52294   float arg2 ;
52295   Dali::Pixel::Format arg3 ;
52296   float arg4 ;
52297   float arg5 ;
52298   bool arg6 ;
52299   Dali::Toolkit::GaussianBlurView result;
52300
52301   arg1 = (unsigned int)jarg1;
52302   arg2 = (float)jarg2;
52303   arg3 = (Dali::Pixel::Format)jarg3;
52304   arg4 = (float)jarg4;
52305   arg5 = (float)jarg5;
52306   arg6 = jarg6 ? true : false;
52307   {
52308     try {
52309       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
52310     } CALL_CATCH_EXCEPTION(0);
52311   }
52312
52313   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
52314   return jresult;
52315 }
52316
52317
52318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
52319   void * jresult ;
52320   unsigned int arg1 ;
52321   float arg2 ;
52322   Dali::Pixel::Format arg3 ;
52323   float arg4 ;
52324   float arg5 ;
52325   Dali::Toolkit::GaussianBlurView result;
52326
52327   arg1 = (unsigned int)jarg1;
52328   arg2 = (float)jarg2;
52329   arg3 = (Dali::Pixel::Format)jarg3;
52330   arg4 = (float)jarg4;
52331   arg5 = (float)jarg5;
52332   {
52333     try {
52334       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
52335     } CALL_CATCH_EXCEPTION(0);
52336   }
52337
52338   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
52339   return jresult;
52340 }
52341
52342
52343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
52344   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
52345   Dali::Actor arg2 ;
52346   Dali::Actor *argp2 ;
52347
52348   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
52349   argp2 = (Dali::Actor *)jarg2;
52350   if (!argp2) {
52351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52352     return ;
52353   }
52354   arg2 = *argp2;
52355   {
52356     try {
52357       (arg1)->Add(arg2);
52358     } CALL_CATCH_EXCEPTION();
52359   }
52360
52361 }
52362
52363
52364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
52365   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
52366   Dali::Actor arg2 ;
52367   Dali::Actor *argp2 ;
52368
52369   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
52370   argp2 = (Dali::Actor *)jarg2;
52371   if (!argp2) {
52372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52373     return ;
52374   }
52375   arg2 = *argp2;
52376   {
52377     try {
52378       (arg1)->Remove(arg2);
52379     } CALL_CATCH_EXCEPTION();
52380   }
52381
52382 }
52383
52384
52385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
52386   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
52387
52388   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
52389   {
52390     try {
52391       (arg1)->Activate();
52392     } CALL_CATCH_EXCEPTION();
52393   }
52394
52395 }
52396
52397
52398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
52399   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
52400
52401   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
52402   {
52403     try {
52404       (arg1)->ActivateOnce();
52405     } CALL_CATCH_EXCEPTION();
52406   }
52407
52408 }
52409
52410
52411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
52412   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
52413
52414   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
52415   {
52416     try {
52417       (arg1)->Deactivate();
52418     } CALL_CATCH_EXCEPTION();
52419   }
52420
52421 }
52422
52423
52424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
52425   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
52426   Dali::Texture arg2 ;
52427   Dali::FrameBuffer arg3 ;
52428   Dali::Texture *argp2 ;
52429   Dali::FrameBuffer *argp3 ;
52430
52431   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
52432   argp2 = (Dali::Texture *)jarg2;
52433   if (!argp2) {
52434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
52435     return ;
52436   }
52437   arg2 = *argp2;
52438   argp3 = (Dali::FrameBuffer *)jarg3;
52439   if (!argp3) {
52440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
52441     return ;
52442   }
52443   arg3 = *argp3;
52444   {
52445     try {
52446       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
52447     } CALL_CATCH_EXCEPTION();
52448   }
52449
52450 }
52451
52452
52453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
52454   int jresult ;
52455   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
52456   Dali::Property::Index result;
52457
52458   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
52459   {
52460     try {
52461       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
52462     } CALL_CATCH_EXCEPTION(0);
52463   }
52464
52465   jresult = result;
52466   return jresult;
52467 }
52468
52469
52470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
52471   void * jresult ;
52472   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
52473   Dali::FrameBuffer result;
52474
52475   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
52476   {
52477     try {
52478       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
52479     } CALL_CATCH_EXCEPTION(0);
52480   }
52481
52482   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
52483   return jresult;
52484 }
52485
52486
52487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
52488   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
52489   Dali::Vector4 *arg2 = 0 ;
52490
52491   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
52492   arg2 = (Dali::Vector4 *)jarg2;
52493   if (!arg2) {
52494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
52495     return ;
52496   }
52497   {
52498     try {
52499       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
52500     } CALL_CATCH_EXCEPTION();
52501   }
52502
52503 }
52504
52505
52506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
52507   void * jresult ;
52508   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
52509   Dali::Vector4 result;
52510
52511   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
52512   {
52513     try {
52514       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
52515     } CALL_CATCH_EXCEPTION(0);
52516   }
52517
52518   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
52519   return jresult;
52520 }
52521
52522
52523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
52524   void * jresult ;
52525   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
52526   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
52527
52528   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
52529   {
52530     try {
52531       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
52532     } CALL_CATCH_EXCEPTION(0);
52533   }
52534
52535   jresult = (void *)result;
52536   return jresult;
52537 }
52538
52539
52540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
52541   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
52542
52543   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
52544   {
52545     try {
52546       delete arg1;
52547     } CALL_CATCH_EXCEPTION();
52548   }
52549
52550 }
52551
52552
52553 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
52554   unsigned int jresult ;
52555   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
52556   unsigned int result;
52557
52558   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
52559   {
52560     try {
52561       result = (unsigned int)(arg1)->GetNumberOfPages();
52562     } CALL_CATCH_EXCEPTION(0);
52563   }
52564
52565   jresult = result;
52566   return jresult;
52567 }
52568
52569
52570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
52571   void * jresult ;
52572   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
52573   unsigned int arg2 ;
52574   Dali::Texture result;
52575
52576   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
52577   arg2 = (unsigned int)jarg2;
52578   {
52579     try {
52580       result = (arg1)->NewPage(arg2);
52581     } CALL_CATCH_EXCEPTION(0);
52582   }
52583
52584   jresult = new Dali::Texture((const Dali::Texture &)result);
52585   return jresult;
52586 }
52587
52588
52589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
52590   int jresult ;
52591   int result;
52592
52593   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
52594   jresult = (int)result;
52595   return jresult;
52596 }
52597
52598
52599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
52600   int jresult ;
52601   int result;
52602
52603   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
52604   jresult = (int)result;
52605   return jresult;
52606 }
52607
52608
52609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
52610   int jresult ;
52611   int result;
52612
52613   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
52614   jresult = (int)result;
52615   return jresult;
52616 }
52617
52618
52619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
52620   void * jresult ;
52621   Dali::Toolkit::PageTurnView::Property *result = 0 ;
52622
52623   {
52624     try {
52625       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
52626     } CALL_CATCH_EXCEPTION(0);
52627   }
52628
52629   jresult = (void *)result;
52630   return jresult;
52631 }
52632
52633
52634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
52635   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
52636
52637   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
52638   {
52639     try {
52640       delete arg1;
52641     } CALL_CATCH_EXCEPTION();
52642   }
52643
52644 }
52645
52646
52647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
52648   void * jresult ;
52649   Dali::Toolkit::PageTurnView *result = 0 ;
52650
52651   {
52652     try {
52653       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
52654     } CALL_CATCH_EXCEPTION(0);
52655   }
52656
52657   jresult = (void *)result;
52658   return jresult;
52659 }
52660
52661
52662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
52663   void * jresult ;
52664   Dali::Toolkit::PageTurnView *arg1 = 0 ;
52665   Dali::Toolkit::PageTurnView *result = 0 ;
52666
52667   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
52668   if (!arg1) {
52669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
52670     return 0;
52671   }
52672   {
52673     try {
52674       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
52675     } CALL_CATCH_EXCEPTION(0);
52676   }
52677
52678   jresult = (void *)result;
52679   return jresult;
52680 }
52681
52682
52683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
52684   void * jresult ;
52685   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
52686   Dali::Toolkit::PageTurnView *arg2 = 0 ;
52687   Dali::Toolkit::PageTurnView *result = 0 ;
52688
52689   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
52690   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
52691   if (!arg2) {
52692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
52693     return 0;
52694   }
52695   {
52696     try {
52697       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
52698     } CALL_CATCH_EXCEPTION(0);
52699   }
52700
52701   jresult = (void *)result;
52702   return jresult;
52703 }
52704
52705
52706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
52707   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
52708
52709   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
52710   {
52711     try {
52712       delete arg1;
52713     } CALL_CATCH_EXCEPTION();
52714   }
52715
52716 }
52717
52718
52719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
52720   void * jresult ;
52721   Dali::BaseHandle arg1 ;
52722   Dali::BaseHandle *argp1 ;
52723   Dali::Toolkit::PageTurnView result;
52724
52725   argp1 = (Dali::BaseHandle *)jarg1;
52726   if (!argp1) {
52727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52728     return 0;
52729   }
52730   arg1 = *argp1;
52731   {
52732     try {
52733       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
52734     } CALL_CATCH_EXCEPTION(0);
52735   }
52736
52737   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
52738   return jresult;
52739 }
52740
52741
52742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
52743   void * jresult ;
52744   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
52745   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
52746
52747   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
52748   {
52749     try {
52750       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
52751     } CALL_CATCH_EXCEPTION(0);
52752   }
52753
52754   jresult = (void *)result;
52755   return jresult;
52756 }
52757
52758
52759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
52760   void * jresult ;
52761   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
52762   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
52763
52764   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
52765   {
52766     try {
52767       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
52768     } CALL_CATCH_EXCEPTION(0);
52769   }
52770
52771   jresult = (void *)result;
52772   return jresult;
52773 }
52774
52775
52776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
52777   void * jresult ;
52778   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
52779   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
52780
52781   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
52782   {
52783     try {
52784       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
52785     } CALL_CATCH_EXCEPTION(0);
52786   }
52787
52788   jresult = (void *)result;
52789   return jresult;
52790 }
52791
52792
52793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
52794   void * jresult ;
52795   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
52796   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
52797
52798   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
52799   {
52800     try {
52801       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
52802     } CALL_CATCH_EXCEPTION(0);
52803   }
52804
52805   jresult = (void *)result;
52806   return jresult;
52807 }
52808
52809
52810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
52811   void * jresult ;
52812   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
52813
52814   {
52815     try {
52816       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
52817     } CALL_CATCH_EXCEPTION(0);
52818   }
52819
52820   jresult = (void *)result;
52821   return jresult;
52822 }
52823
52824
52825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
52826   void * jresult ;
52827   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
52828   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
52829
52830   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
52831   if (!arg1) {
52832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
52833     return 0;
52834   }
52835   {
52836     try {
52837       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
52838     } CALL_CATCH_EXCEPTION(0);
52839   }
52840
52841   jresult = (void *)result;
52842   return jresult;
52843 }
52844
52845
52846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
52847   void * jresult ;
52848   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
52849   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
52850   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
52851
52852   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
52853   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
52854   if (!arg2) {
52855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
52856     return 0;
52857   }
52858   {
52859     try {
52860       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
52861     } CALL_CATCH_EXCEPTION(0);
52862   }
52863
52864   jresult = (void *)result;
52865   return jresult;
52866 }
52867
52868
52869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
52870   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
52871
52872   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
52873   {
52874     try {
52875       delete arg1;
52876     } CALL_CATCH_EXCEPTION();
52877   }
52878
52879 }
52880
52881
52882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
52883   void * jresult ;
52884   Dali::Toolkit::PageFactory *arg1 = 0 ;
52885   Dali::Vector2 *arg2 = 0 ;
52886   Dali::Toolkit::PageTurnLandscapeView result;
52887
52888   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
52889   if (!arg1) {
52890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
52891     return 0;
52892   }
52893   arg2 = (Dali::Vector2 *)jarg2;
52894   if (!arg2) {
52895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
52896     return 0;
52897   }
52898   {
52899     try {
52900       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
52901     } CALL_CATCH_EXCEPTION(0);
52902   }
52903
52904   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
52905   return jresult;
52906 }
52907
52908
52909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
52910   void * jresult ;
52911   Dali::BaseHandle arg1 ;
52912   Dali::BaseHandle *argp1 ;
52913   Dali::Toolkit::PageTurnLandscapeView result;
52914
52915   argp1 = (Dali::BaseHandle *)jarg1;
52916   if (!argp1) {
52917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52918     return 0;
52919   }
52920   arg1 = *argp1;
52921   {
52922     try {
52923       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
52924     } CALL_CATCH_EXCEPTION(0);
52925   }
52926
52927   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
52928   return jresult;
52929 }
52930
52931
52932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
52933   void * jresult ;
52934   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
52935
52936   {
52937     try {
52938       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
52939     } CALL_CATCH_EXCEPTION(0);
52940   }
52941
52942   jresult = (void *)result;
52943   return jresult;
52944 }
52945
52946
52947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
52948   void * jresult ;
52949   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
52950   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
52951
52952   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
52953   if (!arg1) {
52954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
52955     return 0;
52956   }
52957   {
52958     try {
52959       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
52960     } CALL_CATCH_EXCEPTION(0);
52961   }
52962
52963   jresult = (void *)result;
52964   return jresult;
52965 }
52966
52967
52968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
52969   void * jresult ;
52970   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
52971   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
52972   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
52973
52974   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
52975   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
52976   if (!arg2) {
52977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
52978     return 0;
52979   }
52980   {
52981     try {
52982       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
52983     } CALL_CATCH_EXCEPTION(0);
52984   }
52985
52986   jresult = (void *)result;
52987   return jresult;
52988 }
52989
52990
52991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
52992   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
52993
52994   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
52995   {
52996     try {
52997       delete arg1;
52998     } CALL_CATCH_EXCEPTION();
52999   }
53000
53001 }
53002
53003
53004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
53005   void * jresult ;
53006   Dali::Toolkit::PageFactory *arg1 = 0 ;
53007   Dali::Vector2 *arg2 = 0 ;
53008   Dali::Toolkit::PageTurnPortraitView result;
53009
53010   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
53011   if (!arg1) {
53012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
53013     return 0;
53014   }
53015   arg2 = (Dali::Vector2 *)jarg2;
53016   if (!arg2) {
53017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
53018     return 0;
53019   }
53020   {
53021     try {
53022       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
53023     } CALL_CATCH_EXCEPTION(0);
53024   }
53025
53026   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
53027   return jresult;
53028 }
53029
53030
53031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
53032   void * jresult ;
53033   Dali::BaseHandle arg1 ;
53034   Dali::BaseHandle *argp1 ;
53035   Dali::Toolkit::PageTurnPortraitView result;
53036
53037   argp1 = (Dali::BaseHandle *)jarg1;
53038   if (!argp1) {
53039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
53040     return 0;
53041   }
53042   arg1 = *argp1;
53043   {
53044     try {
53045       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
53046     } CALL_CATCH_EXCEPTION(0);
53047   }
53048
53049   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
53050   return jresult;
53051 }
53052
53053
53054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
53055   int jresult ;
53056   int result;
53057
53058   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
53059   jresult = (int)result;
53060   return jresult;
53061 }
53062
53063
53064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
53065   int jresult ;
53066   int result;
53067
53068   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
53069   jresult = (int)result;
53070   return jresult;
53071 }
53072
53073
53074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
53075   int jresult ;
53076   int result;
53077
53078   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
53079   jresult = (int)result;
53080   return jresult;
53081 }
53082
53083
53084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
53085   void * jresult ;
53086   Dali::Toolkit::ToggleButton::Property *result = 0 ;
53087
53088   {
53089     try {
53090       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
53091     } CALL_CATCH_EXCEPTION(0);
53092   }
53093
53094   jresult = (void *)result;
53095   return jresult;
53096 }
53097
53098
53099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
53100   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
53101
53102   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
53103   {
53104     try {
53105       delete arg1;
53106     } CALL_CATCH_EXCEPTION();
53107   }
53108
53109 }
53110
53111
53112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
53113   void * jresult ;
53114   Dali::Toolkit::ToggleButton *result = 0 ;
53115
53116   {
53117     try {
53118       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
53119     } CALL_CATCH_EXCEPTION(0);
53120   }
53121
53122   jresult = (void *)result;
53123   return jresult;
53124 }
53125
53126
53127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
53128   void * jresult ;
53129   Dali::Toolkit::ToggleButton *arg1 = 0 ;
53130   Dali::Toolkit::ToggleButton *result = 0 ;
53131
53132   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
53133   if (!arg1) {
53134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
53135     return 0;
53136   }
53137   {
53138     try {
53139       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
53140     } CALL_CATCH_EXCEPTION(0);
53141   }
53142
53143   jresult = (void *)result;
53144   return jresult;
53145 }
53146
53147
53148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
53149   void * jresult ;
53150   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
53151   Dali::Toolkit::ToggleButton *arg2 = 0 ;
53152   Dali::Toolkit::ToggleButton *result = 0 ;
53153
53154   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
53155   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
53156   if (!arg2) {
53157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
53158     return 0;
53159   }
53160   {
53161     try {
53162       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
53163     } CALL_CATCH_EXCEPTION(0);
53164   }
53165
53166   jresult = (void *)result;
53167   return jresult;
53168 }
53169
53170
53171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
53172   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
53173
53174   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
53175   {
53176     try {
53177       delete arg1;
53178     } CALL_CATCH_EXCEPTION();
53179   }
53180
53181 }
53182
53183
53184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
53185   void * jresult ;
53186   Dali::Toolkit::ToggleButton result;
53187
53188   {
53189     try {
53190       result = Dali::Toolkit::ToggleButton::New();
53191     } CALL_CATCH_EXCEPTION(0);
53192   }
53193
53194   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
53195   return jresult;
53196 }
53197
53198
53199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
53200   void * jresult ;
53201   Dali::BaseHandle arg1 ;
53202   Dali::BaseHandle *argp1 ;
53203   Dali::Toolkit::ToggleButton result;
53204
53205   argp1 = (Dali::BaseHandle *)jarg1;
53206   if (!argp1) {
53207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
53208     return 0;
53209   }
53210   arg1 = *argp1;
53211   {
53212     try {
53213       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
53214     } CALL_CATCH_EXCEPTION(0);
53215   }
53216
53217   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
53218   return jresult;
53219 }
53220
53221
53222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
53223   void * jresult ;
53224   Dali::Toolkit::Visual::Base *result = 0 ;
53225
53226   {
53227     try {
53228       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
53229     } CALL_CATCH_EXCEPTION(0);
53230   }
53231
53232   jresult = (void *)result;
53233   return jresult;
53234 }
53235
53236
53237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
53238   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
53239
53240   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
53241   {
53242     try {
53243       delete arg1;
53244     } CALL_CATCH_EXCEPTION();
53245   }
53246
53247 }
53248
53249
53250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
53251   void * jresult ;
53252   Dali::Toolkit::Visual::Base *arg1 = 0 ;
53253   Dali::Toolkit::Visual::Base *result = 0 ;
53254
53255   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
53256   if (!arg1) {
53257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
53258     return 0;
53259   }
53260   {
53261     try {
53262       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
53263     } CALL_CATCH_EXCEPTION(0);
53264   }
53265
53266   jresult = (void *)result;
53267   return jresult;
53268 }
53269
53270
53271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
53272   void * jresult ;
53273   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
53274   Dali::Toolkit::Visual::Base *arg2 = 0 ;
53275   Dali::Toolkit::Visual::Base *result = 0 ;
53276
53277   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
53278   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
53279   if (!arg2) {
53280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
53281     return 0;
53282   }
53283   {
53284     try {
53285       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
53286     } CALL_CATCH_EXCEPTION(0);
53287   }
53288
53289   jresult = (void *)result;
53290   return jresult;
53291 }
53292
53293
53294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
53295   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
53296   std::string *arg2 = 0 ;
53297
53298   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
53299   if (!jarg2) {
53300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53301     return ;
53302   }
53303   std::string arg2_str(jarg2);
53304   arg2 = &arg2_str;
53305   {
53306     try {
53307       (arg1)->SetName((std::string const &)*arg2);
53308     } CALL_CATCH_EXCEPTION();
53309   }
53310
53311
53312   //argout typemap for const std::string&
53313
53314 }
53315
53316
53317 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
53318   char * jresult ;
53319   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
53320   std::string *result = 0 ;
53321
53322   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
53323   {
53324     try {
53325       result = (std::string *) &(arg1)->GetName();
53326     } CALL_CATCH_EXCEPTION(0);
53327   }
53328
53329   jresult = SWIG_csharp_string_callback(result->c_str());
53330   return jresult;
53331 }
53332
53333
53334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
53335   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
53336   Dali::Property::Map *arg2 = 0 ;
53337   Dali::Size arg3 ;
53338   Dali::Size *argp3 ;
53339
53340   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
53341   arg2 = (Dali::Property::Map *)jarg2;
53342   if (!arg2) {
53343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53344     return ;
53345   }
53346   argp3 = (Dali::Size *)jarg3;
53347   if (!argp3) {
53348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
53349     return ;
53350   }
53351   arg3 = *argp3;
53352   {
53353     try {
53354       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
53355     } CALL_CATCH_EXCEPTION();
53356   }
53357
53358 }
53359
53360
53361 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
53362   float jresult ;
53363   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
53364   float arg2 ;
53365   float result;
53366
53367   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
53368   arg2 = (float)jarg2;
53369   {
53370     try {
53371       result = (float)(arg1)->GetHeightForWidth(arg2);
53372     } CALL_CATCH_EXCEPTION(0);
53373   }
53374
53375   jresult = result;
53376   return jresult;
53377 }
53378
53379
53380 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
53381   float jresult ;
53382   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
53383   float arg2 ;
53384   float result;
53385
53386   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
53387   arg2 = (float)jarg2;
53388   {
53389     try {
53390       result = (float)(arg1)->GetWidthForHeight(arg2);
53391     } CALL_CATCH_EXCEPTION(0);
53392   }
53393
53394   jresult = result;
53395   return jresult;
53396 }
53397
53398
53399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
53400   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
53401   Dali::Vector2 *arg2 = 0 ;
53402
53403   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
53404   arg2 = (Dali::Vector2 *)jarg2;
53405   if (!arg2) {
53406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
53407     return ;
53408   }
53409   {
53410     try {
53411       (arg1)->GetNaturalSize(*arg2);
53412     } CALL_CATCH_EXCEPTION();
53413   }
53414
53415 }
53416
53417
53418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
53419   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
53420   float arg2 ;
53421
53422   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
53423   arg2 = (int)jarg2;
53424   {
53425     try {
53426       (arg1)->SetDepthIndex(arg2);
53427     } CALL_CATCH_EXCEPTION();
53428   }
53429
53430 }
53431
53432
53433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
53434   int jresult ;
53435   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
53436   int result;
53437
53438   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
53439   {
53440     try {
53441       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
53442     } CALL_CATCH_EXCEPTION(0);
53443   }
53444
53445   jresult = result;
53446   return jresult;
53447 }
53448
53449
53450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
53451   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
53452   Dali::Property::Map *arg2 = 0 ;
53453
53454   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
53455   arg2 = (Dali::Property::Map *)jarg2;
53456   if (!arg2) {
53457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
53458     return ;
53459   }
53460   {
53461     try {
53462       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
53463     } CALL_CATCH_EXCEPTION();
53464   }
53465
53466 }
53467
53468
53469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
53470   void * jresult ;
53471   Dali::Toolkit::VisualFactory result;
53472
53473   {
53474     try {
53475       result = Dali::Toolkit::VisualFactory::Get();
53476     } CALL_CATCH_EXCEPTION(0);
53477   }
53478
53479   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
53480   return jresult;
53481 }
53482
53483
53484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
53485   void * jresult ;
53486   Dali::Toolkit::VisualFactory *result = 0 ;
53487
53488   {
53489     try {
53490       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
53491     } CALL_CATCH_EXCEPTION(0);
53492   }
53493
53494   jresult = (void *)result;
53495   return jresult;
53496 }
53497
53498
53499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
53500   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
53501
53502   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
53503   {
53504     try {
53505       delete arg1;
53506     } CALL_CATCH_EXCEPTION();
53507   }
53508
53509 }
53510
53511
53512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
53513   void * jresult ;
53514   Dali::Toolkit::VisualFactory *arg1 = 0 ;
53515   Dali::Toolkit::VisualFactory *result = 0 ;
53516
53517   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
53518   if (!arg1) {
53519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
53520     return 0;
53521   }
53522   {
53523     try {
53524       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
53525     } CALL_CATCH_EXCEPTION(0);
53526   }
53527
53528   jresult = (void *)result;
53529   return jresult;
53530 }
53531
53532
53533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
53534   void * jresult ;
53535   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
53536   Dali::Toolkit::VisualFactory *arg2 = 0 ;
53537   Dali::Toolkit::VisualFactory *result = 0 ;
53538
53539   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
53540   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
53541   if (!arg2) {
53542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
53543     return 0;
53544   }
53545   {
53546     try {
53547       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
53548     } CALL_CATCH_EXCEPTION(0);
53549   }
53550
53551   jresult = (void *)result;
53552   return jresult;
53553 }
53554
53555
53556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
53557   void * jresult ;
53558   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
53559   Dali::Property::Map *arg2 = 0 ;
53560   Dali::Toolkit::Visual::Base result;
53561
53562   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
53563   arg2 = (Dali::Property::Map *)jarg2;
53564   if (!arg2) {
53565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53566     return 0;
53567   }
53568   {
53569     try {
53570       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
53571     } CALL_CATCH_EXCEPTION(0);
53572   }
53573
53574   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
53575   return jresult;
53576 }
53577
53578
53579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
53580   void * jresult ;
53581   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
53582   std::string *arg2 = 0 ;
53583   Dali::ImageDimensions arg3 ;
53584   Dali::ImageDimensions *argp3 ;
53585   Dali::Toolkit::Visual::Base result;
53586
53587   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
53588   if (!jarg2) {
53589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53590     return 0;
53591   }
53592   std::string arg2_str(jarg2);
53593   arg2 = &arg2_str;
53594   argp3 = (Dali::ImageDimensions *)jarg3;
53595   if (!argp3) {
53596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
53597     return 0;
53598   }
53599   arg3 = *argp3;
53600   {
53601     try {
53602       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
53603     } CALL_CATCH_EXCEPTION(0);
53604   }
53605
53606   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
53607
53608   //argout typemap for const std::string&
53609
53610   return jresult;
53611 }
53612
53613
53614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
53615   void * jresult ;
53616   Dali::Toolkit::AsyncImageLoader *result = 0 ;
53617
53618   {
53619     try {
53620       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
53621     } CALL_CATCH_EXCEPTION(0);
53622   }
53623
53624   jresult = (void *)result;
53625   return jresult;
53626 }
53627
53628
53629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
53630   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
53631
53632   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
53633   {
53634     try {
53635       delete arg1;
53636     } CALL_CATCH_EXCEPTION();
53637   }
53638
53639 }
53640
53641
53642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
53643   void * jresult ;
53644   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
53645   Dali::Toolkit::AsyncImageLoader *result = 0 ;
53646
53647   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
53648   if (!arg1) {
53649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
53650     return 0;
53651   }
53652   {
53653     try {
53654       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
53655     } CALL_CATCH_EXCEPTION(0);
53656   }
53657
53658   jresult = (void *)result;
53659   return jresult;
53660 }
53661
53662
53663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
53664   void * jresult ;
53665   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
53666   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
53667   Dali::Toolkit::AsyncImageLoader *result = 0 ;
53668
53669   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
53670   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
53671   if (!arg2) {
53672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
53673     return 0;
53674   }
53675   {
53676     try {
53677       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
53678     } CALL_CATCH_EXCEPTION(0);
53679   }
53680
53681   jresult = (void *)result;
53682   return jresult;
53683 }
53684
53685
53686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
53687   void * jresult ;
53688   Dali::Toolkit::AsyncImageLoader result;
53689
53690   {
53691     try {
53692       result = Dali::Toolkit::AsyncImageLoader::New();
53693     } CALL_CATCH_EXCEPTION(0);
53694   }
53695
53696   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
53697   return jresult;
53698 }
53699
53700
53701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
53702   void * jresult ;
53703   Dali::BaseHandle arg1 ;
53704   Dali::BaseHandle *argp1 ;
53705   Dali::Toolkit::AsyncImageLoader result;
53706
53707   argp1 = (Dali::BaseHandle *)jarg1;
53708   if (!argp1) {
53709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
53710     return 0;
53711   }
53712   arg1 = *argp1;
53713   {
53714     try {
53715       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
53716     } CALL_CATCH_EXCEPTION(0);
53717   }
53718
53719   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
53720   return jresult;
53721 }
53722
53723
53724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
53725   unsigned int jresult ;
53726   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
53727   std::string *arg2 = 0 ;
53728   uint32_t result;
53729
53730   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
53731   if (!jarg2) {
53732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53733     return 0;
53734   }
53735   std::string arg2_str(jarg2);
53736   arg2 = &arg2_str;
53737   {
53738     try {
53739       result = (arg1)->Load((std::string const &)*arg2);
53740     } CALL_CATCH_EXCEPTION(0);
53741   }
53742
53743   jresult = result;
53744
53745   //argout typemap for const std::string&
53746
53747   return jresult;
53748 }
53749
53750
53751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
53752   unsigned int jresult ;
53753   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
53754   std::string *arg2 = 0 ;
53755   Dali::ImageDimensions arg3 ;
53756   Dali::ImageDimensions *argp3 ;
53757   uint32_t result;
53758
53759   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
53760   if (!jarg2) {
53761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53762     return 0;
53763   }
53764   std::string arg2_str(jarg2);
53765   arg2 = &arg2_str;
53766   argp3 = (Dali::ImageDimensions *)jarg3;
53767   if (!argp3) {
53768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
53769     return 0;
53770   }
53771   arg3 = *argp3;
53772   {
53773     try {
53774       result = (arg1)->Load((std::string const &)*arg2,arg3);
53775     } CALL_CATCH_EXCEPTION(0);
53776   }
53777
53778   jresult = result;
53779
53780   //argout typemap for const std::string&
53781
53782   return jresult;
53783 }
53784
53785
53786 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, bool jarg6) {
53787   unsigned int jresult ;
53788   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
53789   std::string *arg2 = 0 ;
53790   Dali::ImageDimensions arg3 ;
53791   Dali::FittingMode::Type arg4 ;
53792   Dali::SamplingMode::Type arg5 ;
53793   bool arg6 ;
53794   Dali::ImageDimensions *argp3 ;
53795   uint32_t result;
53796
53797   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
53798   if (!jarg2) {
53799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53800     return 0;
53801   }
53802   std::string arg2_str(jarg2);
53803   arg2 = &arg2_str;
53804   argp3 = (Dali::ImageDimensions *)jarg3;
53805   if (!argp3) {
53806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
53807     return 0;
53808   }
53809   arg3 = *argp3;
53810   arg4 = (Dali::FittingMode::Type)jarg4;
53811   arg5 = (Dali::SamplingMode::Type)jarg5;
53812   arg6 = jarg6 ? true : false;
53813   {
53814     try {
53815       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
53816     } CALL_CATCH_EXCEPTION(0);
53817   }
53818
53819   jresult = result;
53820
53821   //argout typemap for const std::string&
53822
53823   return jresult;
53824 }
53825
53826
53827 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
53828   bool jresult ;
53829   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
53830   uint32_t arg2 ;
53831   bool result;
53832
53833   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
53834   arg2 = (uint32_t)jarg2;
53835   {
53836     try {
53837       result = (bool)(arg1)->Cancel(arg2);
53838     } CALL_CATCH_EXCEPTION(0);
53839   }
53840
53841   jresult = result;
53842   return jresult;
53843 }
53844
53845
53846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
53847   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
53848
53849   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
53850   {
53851     try {
53852       (arg1)->CancelAll();
53853     } CALL_CATCH_EXCEPTION();
53854   }
53855
53856 }
53857
53858
53859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
53860   void * jresult ;
53861   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
53862   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
53863
53864   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
53865   {
53866     try {
53867       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
53868     } CALL_CATCH_EXCEPTION(0);
53869   }
53870
53871   jresult = (void *)result;
53872   return jresult;
53873 }
53874
53875
53876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
53877   void * jresult ;
53878   std::string *arg1 = 0 ;
53879   Dali::PixelData result;
53880
53881   if (!jarg1) {
53882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53883     return 0;
53884   }
53885   std::string arg1_str(jarg1);
53886   arg1 = &arg1_str;
53887   {
53888     try {
53889       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
53890     } CALL_CATCH_EXCEPTION(0);
53891   }
53892
53893   jresult = new Dali::PixelData((const Dali::PixelData &)result);
53894
53895   //argout typemap for const std::string&
53896
53897   return jresult;
53898 }
53899
53900
53901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
53902   void * jresult ;
53903   std::string *arg1 = 0 ;
53904   Dali::ImageDimensions arg2 ;
53905   Dali::ImageDimensions *argp2 ;
53906   Dali::PixelData result;
53907
53908   if (!jarg1) {
53909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53910     return 0;
53911   }
53912   std::string arg1_str(jarg1);
53913   arg1 = &arg1_str;
53914   argp2 = (Dali::ImageDimensions *)jarg2;
53915   if (!argp2) {
53916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
53917     return 0;
53918   }
53919   arg2 = *argp2;
53920   {
53921     try {
53922       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
53923     } CALL_CATCH_EXCEPTION(0);
53924   }
53925
53926   jresult = new Dali::PixelData((const Dali::PixelData &)result);
53927
53928   //argout typemap for const std::string&
53929
53930   return jresult;
53931 }
53932
53933
53934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
53935   void * jresult ;
53936   std::string *arg1 = 0 ;
53937   Dali::ImageDimensions arg2 ;
53938   Dali::FittingMode::Type arg3 ;
53939   Dali::SamplingMode::Type arg4 ;
53940   bool arg5 ;
53941   Dali::ImageDimensions *argp2 ;
53942   Dali::PixelData result;
53943
53944   if (!jarg1) {
53945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53946     return 0;
53947   }
53948   std::string arg1_str(jarg1);
53949   arg1 = &arg1_str;
53950   argp2 = (Dali::ImageDimensions *)jarg2;
53951   if (!argp2) {
53952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
53953     return 0;
53954   }
53955   arg2 = *argp2;
53956   arg3 = (Dali::FittingMode::Type)jarg3;
53957   arg4 = (Dali::SamplingMode::Type)jarg4;
53958   arg5 = jarg5 ? true : false;
53959   {
53960     try {
53961       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
53962     } CALL_CATCH_EXCEPTION(0);
53963   }
53964
53965   jresult = new Dali::PixelData((const Dali::PixelData &)result);
53966
53967   //argout typemap for const std::string&
53968
53969   return jresult;
53970 }
53971
53972
53973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
53974   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
53975
53976   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
53977   {
53978     try {
53979       delete arg1;
53980     } CALL_CATCH_EXCEPTION();
53981   }
53982
53983 }
53984
53985
53986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * customAlgorithmInterface, void * currentFocusedActor, void * proposedActorToFocus, int direction, char * deviceName) {
53987   void * jresult ;
53988   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
53989   Dali::Actor arg2 ;
53990   Dali::Actor arg3 ;
53991   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
53992   std::string *arg5 = 0 ;
53993   Dali::Actor *argp2 ;
53994   Dali::Actor *argp3 ;
53995   Dali::Actor result;
53996
53997   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)customAlgorithmInterface;
53998   argp2 = (Dali::Actor *)currentFocusedActor;
53999   if (!argp2) {
54000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54001     return 0;
54002   }
54003   arg2 = *argp2;
54004   argp3 = (Dali::Actor *)proposedActorToFocus;
54005   if (!argp3) {
54006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54007     return 0;
54008   }
54009   arg3 = *argp3;
54010   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)direction;
54011
54012   std::string arg5_str(deviceName);
54013   arg5 = &arg5_str;
54014
54015   {
54016     try {
54017       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4,(std::string const &)*arg5);
54018     } CALL_CATCH_EXCEPTION(0);
54019   }
54020
54021   jresult = new Dali::Actor((const Dali::Actor &)result);
54022   return jresult;
54023 }
54024
54025
54026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
54027   void * jresult ;
54028   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
54029
54030   {
54031     try {
54032       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
54033     } CALL_CATCH_EXCEPTION(0);
54034   }
54035
54036   jresult = (void *)result;
54037   return jresult;
54038 }
54039
54040
54041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback0_t callback0) {
54042   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg;
54043   SwigDirector_FrameCallbackInterface *director = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
54044   if (director) {
54045     director->swig_connect_director(callback0);
54046   }
54047 }
54048
54049
54050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameCallbackInterface() {
54051   void * jresult ;
54052   Dali::FrameCallbackInterface *result = 0 ;
54053
54054   {
54055     try {
54056       result =(Dali::FrameCallbackInterface *) new SwigDirector_FrameCallbackInterface();
54057     } CALL_CATCH_EXCEPTION(0);
54058   }
54059
54060   jresult = (void *)result;
54061   return jresult;
54062 }
54063
54064 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPosition(void * updateProxy, unsigned int id,  void* position) {
54065   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
54066   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
54067   return proxy->GetPosition(id, *vector3);
54068 }
54069
54070 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetPosition(void * updateProxy, unsigned int id, void* position) {
54071   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
54072   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
54073   return proxy->SetPosition(id, *vector3);
54074 }
54075
54076 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakePosition(void * updateProxy, unsigned int id, void* position) {
54077   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
54078   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
54079   return proxy->BakePosition(id, *vector3);
54080 }
54081
54082 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetSize(void * updateProxy, unsigned int id, void* size) {
54083   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
54084   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
54085   return proxy->GetSize(id, *vector3);
54086 }
54087
54088 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetSize(void * updateProxy, unsigned int id, void* size) {
54089   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
54090   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
54091   return proxy->SetSize(id, *vector3);
54092 }
54093 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeSize(void * updateProxy, unsigned int id, void* size) {
54094   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
54095   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
54096   return proxy->BakeSize(id, *vector3);
54097 }
54098
54099 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPositionAndSize(void * updateProxy, unsigned int id, void* position, void* size) {
54100   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
54101   Dali::Vector3* vector3_pos = (Dali::Vector3 *)position;
54102   Dali::Vector3* vector3_size = (Dali::Vector3 *)size;
54103   return proxy->GetPositionAndSize(id, *vector3_pos, *vector3_size);
54104 }
54105
54106 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetScale(void * updateProxy, unsigned int id, void* scale) {
54107   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
54108   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
54109   return proxy->GetScale(id,* vector3);
54110 }
54111
54112 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetScale(void * updateProxy, unsigned int id, void* scale) {
54113   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
54114   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
54115   return proxy->SetScale(id, *vector3);
54116 }
54117
54118 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeScale(void * updateProxy, unsigned int id, void* scale) {
54119   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
54120   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
54121   return proxy->BakeScale(id, *vector3);
54122 }
54123
54124 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetColor(void * updateProxy, unsigned int id, void* color) {
54125   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
54126   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
54127   return proxy->GetColor(id, *vector4);
54128 }
54129
54130 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetColor(void * updateProxy, unsigned int id, void* color) {
54131   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
54132   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
54133   return proxy->SetColor(id, *vector4);
54134 }
54135
54136 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeColor(void * updateProxy, unsigned int id, void* color) {
54137   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
54138   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
54139   return proxy->BakeColor(id, *vector4);
54140 }
54141
54142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_AddFrameCallback(void * jarg1, void* jarg2, void* jarg3) {
54143   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
54144   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
54145
54146   Dali::Stage *arg1 = (Dali::Stage *) 0;
54147   Dali::Actor *arg3 = 0;
54148
54149   arg1 = (Dali::Stage *)jarg1;
54150   arg3 = (Dali::Actor *)jarg3;
54151
54152   DevelStage::AddFrameCallback( *arg1, *arg2, *arg3 );
54153   return;
54154 }
54155
54156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_RemoveFrameCallback(void * jarg1, void* jarg2) {
54157
54158   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
54159   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
54160
54161   Dali::Stage *arg1 = (Dali::Stage *) 0;
54162
54163   arg1 = (Dali::Stage *)jarg1;
54164
54165   DevelStage::RemoveFrameCallback( *arg1, *arg2 );
54166   return;
54167 }
54168
54169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
54170   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
54171   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
54172   if (director) {
54173     director->swig_connect_director(callback0);
54174   }
54175 }
54176
54177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
54178   KeyboardFocusManager arg1 ;
54179   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
54180   KeyboardFocusManager *argp1 ;
54181
54182   argp1 = (KeyboardFocusManager *)jarg1;
54183   if (!argp1) {
54184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
54185     return ;
54186   }
54187   arg1 = *argp1;
54188   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
54189   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
54190   {
54191     try {
54192       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
54193     } CALL_CATCH_EXCEPTION();
54194   }
54195
54196 }
54197
54198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_EnableDefaultAlgorithm(void * jarg1, bool jarg2) {
54199   KeyboardFocusManager arg1 ;
54200   bool arg2 ;
54201   KeyboardFocusManager *argp1 ;
54202
54203   argp1 = (KeyboardFocusManager *)jarg1;
54204   if (!argp1) {
54205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
54206     return ;
54207   }
54208   arg1 = *argp1;
54209   arg2 = jarg2;
54210   {
54211     try {
54212       Dali::Toolkit::DevelKeyboardFocusManager::EnableDefaultAlgorithm(arg1, arg2);
54213     } CALL_CATCH_EXCEPTION();
54214   }
54215 }
54216
54217 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_IsDefaultAlgorithmEnabled(void * jarg1) {
54218   bool jresult ;
54219   KeyboardFocusManager arg1 ;
54220   KeyboardFocusManager *argp1 ;
54221   bool result;
54222
54223   argp1 = (KeyboardFocusManager *)jarg1;
54224   if (!argp1) {
54225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
54226     return false;
54227   }
54228   arg1 = *argp1;
54229   {
54230     try {
54231       result = Dali::Toolkit::DevelKeyboardFocusManager::IsDefaultAlgorithmEnabled(arg1);
54232     } CALL_CATCH_EXCEPTION(0);
54233   }
54234   jresult = result;
54235   return jresult;
54236 }
54237
54238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_SetFocusFinderRootActor(void * manager, void * actor) {
54239   if (!manager) {
54240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
54241     return ;
54242   }
54243   if (!actor) {
54244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
54245     return ;
54246   }
54247   {
54248     try {
54249       Dali::Toolkit::DevelKeyboardFocusManager::SetFocusFinderRootActor(*(KeyboardFocusManager *)manager, *(Dali::Actor *)actor);
54250     } CALL_CATCH_EXCEPTION();
54251   }
54252 }
54253
54254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_ResetFocusFinderRootActor(void * manager) {
54255   if (!manager) {
54256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
54257     return ;
54258   }
54259   {
54260     try {
54261       Dali::Toolkit::DevelKeyboardFocusManager::ResetFocusFinderRootActor(*(KeyboardFocusManager *)manager);
54262     } CALL_CATCH_EXCEPTION();
54263   }
54264 }
54265
54266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
54267   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54268
54269   arg1 = (std::vector< unsigned int > *)jarg1;
54270   {
54271     try {
54272       (arg1)->clear();
54273     } CALL_CATCH_EXCEPTION();
54274   }
54275
54276 }
54277
54278
54279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
54280   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54281   unsigned int *arg2 = 0 ;
54282   unsigned int temp2 ;
54283
54284   arg1 = (std::vector< unsigned int > *)jarg1;
54285   temp2 = (unsigned int)jarg2;
54286   arg2 = &temp2;
54287   {
54288     try {
54289       (arg1)->push_back((unsigned int const &)*arg2);
54290     } CALL_CATCH_EXCEPTION();
54291   }
54292
54293 }
54294
54295
54296 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
54297   unsigned long jresult ;
54298   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54299   std::vector< unsigned int >::size_type result;
54300
54301   arg1 = (std::vector< unsigned int > *)jarg1;
54302   {
54303     try {
54304       result = ((std::vector< unsigned int > const *)arg1)->size();
54305     } CALL_CATCH_EXCEPTION(0);
54306   }
54307
54308   jresult = (unsigned long)result;
54309   return jresult;
54310 }
54311
54312
54313 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
54314   unsigned long jresult ;
54315   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54316   std::vector< unsigned int >::size_type result;
54317
54318   arg1 = (std::vector< unsigned int > *)jarg1;
54319   {
54320     try {
54321       result = ((std::vector< unsigned int > const *)arg1)->capacity();
54322     } CALL_CATCH_EXCEPTION(0);
54323   }
54324
54325   jresult = (unsigned long)result;
54326   return jresult;
54327 }
54328
54329
54330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
54331   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54332   std::vector< unsigned int >::size_type arg2 ;
54333
54334   arg1 = (std::vector< unsigned int > *)jarg1;
54335   arg2 = (std::vector< unsigned int >::size_type)jarg2;
54336   {
54337     try {
54338       (arg1)->reserve(arg2);
54339     } CALL_CATCH_EXCEPTION();
54340   }
54341
54342 }
54343
54344
54345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
54346   void * jresult ;
54347   std::vector< unsigned int > *result = 0 ;
54348
54349   {
54350     try {
54351       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
54352     } CALL_CATCH_EXCEPTION(0);
54353   }
54354
54355   jresult = (void *)result;
54356   return jresult;
54357 }
54358
54359
54360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
54361   void * jresult ;
54362   std::vector< unsigned int > *arg1 = 0 ;
54363   std::vector< unsigned int > *result = 0 ;
54364
54365   arg1 = (std::vector< unsigned int > *)jarg1;
54366   if (!arg1) {
54367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
54368     return 0;
54369   }
54370   {
54371     try {
54372       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
54373     } CALL_CATCH_EXCEPTION(0);
54374   }
54375
54376   jresult = (void *)result;
54377   return jresult;
54378 }
54379
54380
54381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
54382   void * jresult ;
54383   int arg1 ;
54384   std::vector< unsigned int > *result = 0 ;
54385
54386   arg1 = (int)jarg1;
54387   {
54388     try {
54389       try {
54390         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
54391       }
54392       catch(std::out_of_range &_e) {
54393         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54394         return 0;
54395       }
54396
54397     } CALL_CATCH_EXCEPTION(0);
54398   }
54399
54400   jresult = (void *)result;
54401   return jresult;
54402 }
54403
54404
54405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
54406   unsigned int jresult ;
54407   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54408   int arg2 ;
54409   unsigned int result;
54410
54411   arg1 = (std::vector< unsigned int > *)jarg1;
54412   arg2 = (int)jarg2;
54413   {
54414     try {
54415       try {
54416         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
54417       }
54418       catch(std::out_of_range &_e) {
54419         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54420         return 0;
54421       }
54422
54423     } CALL_CATCH_EXCEPTION(0);
54424   }
54425
54426   jresult = result;
54427   return jresult;
54428 }
54429
54430
54431 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
54432   unsigned int jresult ;
54433   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54434   int arg2 ;
54435   unsigned int *result = 0 ;
54436
54437   arg1 = (std::vector< unsigned int > *)jarg1;
54438   arg2 = (int)jarg2;
54439   {
54440     try {
54441       try {
54442         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
54443       }
54444       catch(std::out_of_range &_e) {
54445         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54446         return 0;
54447       }
54448
54449     } CALL_CATCH_EXCEPTION(0);
54450   }
54451
54452   jresult = *result;
54453   return jresult;
54454 }
54455
54456
54457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
54458   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54459   int arg2 ;
54460   unsigned int *arg3 = 0 ;
54461   unsigned int temp3 ;
54462
54463   arg1 = (std::vector< unsigned int > *)jarg1;
54464   arg2 = (int)jarg2;
54465   temp3 = (unsigned int)jarg3;
54466   arg3 = &temp3;
54467   {
54468     try {
54469       try {
54470         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
54471       }
54472       catch(std::out_of_range &_e) {
54473         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54474         return ;
54475       }
54476
54477     } CALL_CATCH_EXCEPTION();
54478   }
54479
54480 }
54481
54482
54483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
54484   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54485   std::vector< unsigned int > *arg2 = 0 ;
54486
54487   arg1 = (std::vector< unsigned int > *)jarg1;
54488   arg2 = (std::vector< unsigned int > *)jarg2;
54489   if (!arg2) {
54490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
54491     return ;
54492   }
54493   {
54494     try {
54495       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
54496     } CALL_CATCH_EXCEPTION();
54497   }
54498
54499 }
54500
54501
54502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
54503   void * jresult ;
54504   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54505   int arg2 ;
54506   int arg3 ;
54507   std::vector< unsigned int > *result = 0 ;
54508
54509   arg1 = (std::vector< unsigned int > *)jarg1;
54510   arg2 = (int)jarg2;
54511   arg3 = (int)jarg3;
54512   {
54513     try {
54514       try {
54515         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
54516       }
54517       catch(std::out_of_range &_e) {
54518         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54519         return 0;
54520       }
54521       catch(std::invalid_argument &_e) {
54522         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
54523         return 0;
54524       }
54525
54526     } CALL_CATCH_EXCEPTION(0);
54527   }
54528
54529   jresult = (void *)result;
54530   return jresult;
54531 }
54532
54533
54534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
54535   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54536   int arg2 ;
54537   unsigned int *arg3 = 0 ;
54538   unsigned int temp3 ;
54539
54540   arg1 = (std::vector< unsigned int > *)jarg1;
54541   arg2 = (int)jarg2;
54542   temp3 = (unsigned int)jarg3;
54543   arg3 = &temp3;
54544   {
54545     try {
54546       try {
54547         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
54548       }
54549       catch(std::out_of_range &_e) {
54550         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54551         return ;
54552       }
54553
54554     } CALL_CATCH_EXCEPTION();
54555   }
54556
54557 }
54558
54559
54560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
54561   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54562   int arg2 ;
54563   std::vector< unsigned int > *arg3 = 0 ;
54564
54565   arg1 = (std::vector< unsigned int > *)jarg1;
54566   arg2 = (int)jarg2;
54567   arg3 = (std::vector< unsigned int > *)jarg3;
54568   if (!arg3) {
54569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
54570     return ;
54571   }
54572   {
54573     try {
54574       try {
54575         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
54576       }
54577       catch(std::out_of_range &_e) {
54578         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54579         return ;
54580       }
54581
54582     } CALL_CATCH_EXCEPTION();
54583   }
54584
54585 }
54586
54587
54588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
54589   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54590   int arg2 ;
54591
54592   arg1 = (std::vector< unsigned int > *)jarg1;
54593   arg2 = (int)jarg2;
54594   {
54595     try {
54596       try {
54597         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
54598       }
54599       catch(std::out_of_range &_e) {
54600         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54601         return ;
54602       }
54603
54604     } CALL_CATCH_EXCEPTION();
54605   }
54606
54607 }
54608
54609
54610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
54611   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54612   int arg2 ;
54613   int arg3 ;
54614
54615   arg1 = (std::vector< unsigned int > *)jarg1;
54616   arg2 = (int)jarg2;
54617   arg3 = (int)jarg3;
54618   {
54619     try {
54620       try {
54621         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
54622       }
54623       catch(std::out_of_range &_e) {
54624         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54625         return ;
54626       }
54627       catch(std::invalid_argument &_e) {
54628         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
54629         return ;
54630       }
54631
54632     } CALL_CATCH_EXCEPTION();
54633   }
54634
54635 }
54636
54637
54638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
54639   void * jresult ;
54640   unsigned int *arg1 = 0 ;
54641   int arg2 ;
54642   unsigned int temp1 ;
54643   std::vector< unsigned int > *result = 0 ;
54644
54645   temp1 = (unsigned int)jarg1;
54646   arg1 = &temp1;
54647   arg2 = (int)jarg2;
54648   {
54649     try {
54650       try {
54651         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
54652       }
54653       catch(std::out_of_range &_e) {
54654         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54655         return 0;
54656       }
54657
54658     } CALL_CATCH_EXCEPTION(0);
54659   }
54660
54661   jresult = (void *)result;
54662   return jresult;
54663 }
54664
54665
54666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
54667   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54668
54669   arg1 = (std::vector< unsigned int > *)jarg1;
54670   {
54671     try {
54672       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
54673     } CALL_CATCH_EXCEPTION();
54674   }
54675
54676 }
54677
54678
54679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
54680   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54681   int arg2 ;
54682   int arg3 ;
54683
54684   arg1 = (std::vector< unsigned int > *)jarg1;
54685   arg2 = (int)jarg2;
54686   arg3 = (int)jarg3;
54687   {
54688     try {
54689       try {
54690         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
54691       }
54692       catch(std::out_of_range &_e) {
54693         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54694         return ;
54695       }
54696       catch(std::invalid_argument &_e) {
54697         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
54698         return ;
54699       }
54700
54701     } CALL_CATCH_EXCEPTION();
54702   }
54703
54704 }
54705
54706
54707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
54708   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54709   int arg2 ;
54710   std::vector< unsigned int > *arg3 = 0 ;
54711
54712   arg1 = (std::vector< unsigned int > *)jarg1;
54713   arg2 = (int)jarg2;
54714   arg3 = (std::vector< unsigned int > *)jarg3;
54715   if (!arg3) {
54716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
54717     return ;
54718   }
54719   {
54720     try {
54721       try {
54722         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
54723       }
54724       catch(std::out_of_range &_e) {
54725         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54726         return ;
54727       }
54728
54729     } CALL_CATCH_EXCEPTION();
54730   }
54731
54732 }
54733
54734
54735 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
54736   bool jresult ;
54737   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54738   unsigned int *arg2 = 0 ;
54739   unsigned int temp2 ;
54740   bool result;
54741
54742   arg1 = (std::vector< unsigned int > *)jarg1;
54743   temp2 = (unsigned int)jarg2;
54744   arg2 = &temp2;
54745   {
54746     try {
54747       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
54748     } CALL_CATCH_EXCEPTION(0);
54749   }
54750
54751   jresult = result;
54752   return jresult;
54753 }
54754
54755
54756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
54757   int jresult ;
54758   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54759   unsigned int *arg2 = 0 ;
54760   unsigned int temp2 ;
54761   int result;
54762
54763   arg1 = (std::vector< unsigned int > *)jarg1;
54764   temp2 = (unsigned int)jarg2;
54765   arg2 = &temp2;
54766   {
54767     try {
54768       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
54769     } CALL_CATCH_EXCEPTION(0);
54770   }
54771
54772   jresult = result;
54773   return jresult;
54774 }
54775
54776
54777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
54778   int jresult ;
54779   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54780   unsigned int *arg2 = 0 ;
54781   unsigned int temp2 ;
54782   int result;
54783
54784   arg1 = (std::vector< unsigned int > *)jarg1;
54785   temp2 = (unsigned int)jarg2;
54786   arg2 = &temp2;
54787   {
54788     try {
54789       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
54790     } CALL_CATCH_EXCEPTION(0);
54791   }
54792
54793   jresult = result;
54794   return jresult;
54795 }
54796
54797
54798 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
54799   bool jresult ;
54800   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54801   unsigned int *arg2 = 0 ;
54802   unsigned int temp2 ;
54803   bool result;
54804
54805   arg1 = (std::vector< unsigned int > *)jarg1;
54806   temp2 = (unsigned int)jarg2;
54807   arg2 = &temp2;
54808   {
54809     try {
54810       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
54811     } CALL_CATCH_EXCEPTION(0);
54812   }
54813
54814   jresult = result;
54815   return jresult;
54816 }
54817
54818
54819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
54820   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
54821
54822   arg1 = (std::vector< unsigned int > *)jarg1;
54823   {
54824     try {
54825       delete arg1;
54826     } CALL_CATCH_EXCEPTION();
54827   }
54828
54829 }
54830
54831
54832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
54833   void * jresult ;
54834   std::pair< unsigned int,Dali::Actor > *result = 0 ;
54835
54836   {
54837     try {
54838       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
54839     } CALL_CATCH_EXCEPTION(0);
54840   }
54841
54842   jresult = (void *)result;
54843   return jresult;
54844 }
54845
54846
54847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
54848   void * jresult ;
54849   unsigned int arg1 ;
54850   Dali::Actor arg2 ;
54851   Dali::Actor *argp2 ;
54852   std::pair< unsigned int,Dali::Actor > *result = 0 ;
54853
54854   arg1 = (unsigned int)jarg1;
54855   argp2 = (Dali::Actor *)jarg2;
54856   if (!argp2) {
54857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54858     return 0;
54859   }
54860   arg2 = *argp2;
54861   {
54862     try {
54863       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
54864     } CALL_CATCH_EXCEPTION(0);
54865   }
54866
54867   jresult = (void *)result;
54868   return jresult;
54869 }
54870
54871
54872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
54873   void * jresult ;
54874   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
54875   std::pair< unsigned int,Dali::Actor > *result = 0 ;
54876
54877   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
54878   if (!arg1) {
54879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
54880     return 0;
54881   }
54882   {
54883     try {
54884       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
54885     } CALL_CATCH_EXCEPTION(0);
54886   }
54887
54888   jresult = (void *)result;
54889   return jresult;
54890 }
54891
54892
54893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
54894   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
54895   unsigned int arg2 ;
54896
54897   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
54898   arg2 = (unsigned int)jarg2;
54899   if (arg1) (arg1)->first = arg2;
54900 }
54901
54902
54903 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
54904   unsigned int jresult ;
54905   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
54906   unsigned int result;
54907
54908   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
54909   result = (unsigned int) ((arg1)->first);
54910   jresult = result;
54911   return jresult;
54912 }
54913
54914
54915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
54916   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
54917   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
54918
54919   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
54920   arg2 = (Dali::Actor *)jarg2;
54921   if (arg1) (arg1)->second = *arg2;
54922 }
54923
54924
54925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
54926   void * jresult ;
54927   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
54928   Dali::Actor *result = 0 ;
54929
54930   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
54931   result = (Dali::Actor *)& ((arg1)->second);
54932   jresult = (void *)result;
54933   return jresult;
54934 }
54935
54936
54937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
54938   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
54939
54940   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
54941   {
54942     try {
54943       delete arg1;
54944     } CALL_CATCH_EXCEPTION();
54945   }
54946
54947 }
54948
54949
54950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
54951   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54952
54953   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54954   {
54955     try {
54956       (arg1)->clear();
54957     } CALL_CATCH_EXCEPTION();
54958   }
54959
54960 }
54961
54962
54963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
54964   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54965   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
54966
54967   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54968   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
54969   if (!arg2) {
54970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
54971     return ;
54972   }
54973   {
54974     try {
54975       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
54976     } CALL_CATCH_EXCEPTION();
54977   }
54978
54979 }
54980
54981
54982 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
54983   unsigned long jresult ;
54984   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
54985   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
54986
54987   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
54988   {
54989     try {
54990       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
54991     } CALL_CATCH_EXCEPTION(0);
54992   }
54993
54994   jresult = (unsigned long)result;
54995   return jresult;
54996 }
54997
54998
54999 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
55000   unsigned long jresult ;
55001   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
55002   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
55003
55004   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55005   {
55006     try {
55007       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
55008     } CALL_CATCH_EXCEPTION(0);
55009   }
55010
55011   jresult = (unsigned long)result;
55012   return jresult;
55013 }
55014
55015
55016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
55017   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
55018   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
55019
55020   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55021   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
55022   {
55023     try {
55024       (arg1)->reserve(arg2);
55025     } CALL_CATCH_EXCEPTION();
55026   }
55027
55028 }
55029
55030
55031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
55032   void * jresult ;
55033   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
55034
55035   {
55036     try {
55037       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
55038     } CALL_CATCH_EXCEPTION(0);
55039   }
55040
55041   jresult = (void *)result;
55042   return jresult;
55043 }
55044
55045
55046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
55047   void * jresult ;
55048   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
55049   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
55050
55051   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55052   if (!arg1) {
55053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
55054     return 0;
55055   }
55056   {
55057     try {
55058       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);
55059     } CALL_CATCH_EXCEPTION(0);
55060   }
55061
55062   jresult = (void *)result;
55063   return jresult;
55064 }
55065
55066
55067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
55068   void * jresult ;
55069   int arg1 ;
55070   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
55071
55072   arg1 = (int)jarg1;
55073   {
55074     try {
55075       try {
55076         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);
55077       }
55078       catch(std::out_of_range &_e) {
55079         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55080         return 0;
55081       }
55082
55083     } CALL_CATCH_EXCEPTION(0);
55084   }
55085
55086   jresult = (void *)result;
55087   return jresult;
55088 }
55089
55090
55091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
55092   void * jresult ;
55093   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
55094   int arg2 ;
55095   std::pair< unsigned int,Dali::Actor > result;
55096
55097   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55098   arg2 = (int)jarg2;
55099   {
55100     try {
55101       try {
55102         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
55103       }
55104       catch(std::out_of_range &_e) {
55105         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55106         return 0;
55107       }
55108
55109     } CALL_CATCH_EXCEPTION(0);
55110   }
55111
55112   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
55113   return jresult;
55114 }
55115
55116
55117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
55118   void * jresult ;
55119   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
55120   int arg2 ;
55121   std::pair< unsigned int,Dali::Actor > *result = 0 ;
55122
55123   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55124   arg2 = (int)jarg2;
55125   {
55126     try {
55127       try {
55128         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
55129       }
55130       catch(std::out_of_range &_e) {
55131         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55132         return 0;
55133       }
55134
55135     } CALL_CATCH_EXCEPTION(0);
55136   }
55137
55138   jresult = (void *)result;
55139   return jresult;
55140 }
55141
55142
55143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
55144   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
55145   int arg2 ;
55146   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
55147
55148   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55149   arg2 = (int)jarg2;
55150   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
55151   if (!arg3) {
55152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
55153     return ;
55154   }
55155   {
55156     try {
55157       try {
55158         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);
55159       }
55160       catch(std::out_of_range &_e) {
55161         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55162         return ;
55163       }
55164
55165     } CALL_CATCH_EXCEPTION();
55166   }
55167
55168 }
55169
55170
55171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
55172   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
55173   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
55174
55175   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55176   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
55177   if (!arg2) {
55178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
55179     return ;
55180   }
55181   {
55182     try {
55183       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);
55184     } CALL_CATCH_EXCEPTION();
55185   }
55186
55187 }
55188
55189
55190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
55191   void * jresult ;
55192   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
55193   int arg2 ;
55194   int arg3 ;
55195   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
55196
55197   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55198   arg2 = (int)jarg2;
55199   arg3 = (int)jarg3;
55200   {
55201     try {
55202       try {
55203         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);
55204       }
55205       catch(std::out_of_range &_e) {
55206         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55207         return 0;
55208       }
55209       catch(std::invalid_argument &_e) {
55210         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
55211         return 0;
55212       }
55213
55214     } CALL_CATCH_EXCEPTION(0);
55215   }
55216
55217   jresult = (void *)result;
55218   return jresult;
55219 }
55220
55221
55222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
55223   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
55224   int arg2 ;
55225   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
55226
55227   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55228   arg2 = (int)jarg2;
55229   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
55230   if (!arg3) {
55231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
55232     return ;
55233   }
55234   {
55235     try {
55236       try {
55237         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);
55238       }
55239       catch(std::out_of_range &_e) {
55240         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55241         return ;
55242       }
55243
55244     } CALL_CATCH_EXCEPTION();
55245   }
55246
55247 }
55248
55249
55250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
55251   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
55252   int arg2 ;
55253   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
55254
55255   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55256   arg2 = (int)jarg2;
55257   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
55258   if (!arg3) {
55259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
55260     return ;
55261   }
55262   {
55263     try {
55264       try {
55265         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);
55266       }
55267       catch(std::out_of_range &_e) {
55268         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55269         return ;
55270       }
55271
55272     } CALL_CATCH_EXCEPTION();
55273   }
55274
55275 }
55276
55277
55278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
55279   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
55280   int arg2 ;
55281
55282   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55283   arg2 = (int)jarg2;
55284   {
55285     try {
55286       try {
55287         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
55288       }
55289       catch(std::out_of_range &_e) {
55290         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55291         return ;
55292       }
55293
55294     } CALL_CATCH_EXCEPTION();
55295   }
55296
55297 }
55298
55299
55300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
55301   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
55302   int arg2 ;
55303   int arg3 ;
55304
55305   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55306   arg2 = (int)jarg2;
55307   arg3 = (int)jarg3;
55308   {
55309     try {
55310       try {
55311         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
55312       }
55313       catch(std::out_of_range &_e) {
55314         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55315         return ;
55316       }
55317       catch(std::invalid_argument &_e) {
55318         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
55319         return ;
55320       }
55321
55322     } CALL_CATCH_EXCEPTION();
55323   }
55324
55325 }
55326
55327
55328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
55329   void * jresult ;
55330   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
55331   int arg2 ;
55332   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
55333
55334   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
55335   if (!arg1) {
55336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
55337     return 0;
55338   }
55339   arg2 = (int)jarg2;
55340   {
55341     try {
55342       try {
55343         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);
55344       }
55345       catch(std::out_of_range &_e) {
55346         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55347         return 0;
55348       }
55349
55350     } CALL_CATCH_EXCEPTION(0);
55351   }
55352
55353   jresult = (void *)result;
55354   return jresult;
55355 }
55356
55357
55358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
55359   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
55360
55361   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55362   {
55363     try {
55364       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
55365     } CALL_CATCH_EXCEPTION();
55366   }
55367
55368 }
55369
55370
55371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
55372   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
55373   int arg2 ;
55374   int arg3 ;
55375
55376   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55377   arg2 = (int)jarg2;
55378   arg3 = (int)jarg3;
55379   {
55380     try {
55381       try {
55382         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
55383       }
55384       catch(std::out_of_range &_e) {
55385         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55386         return ;
55387       }
55388       catch(std::invalid_argument &_e) {
55389         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
55390         return ;
55391       }
55392
55393     } CALL_CATCH_EXCEPTION();
55394   }
55395
55396 }
55397
55398
55399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
55400   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
55401   int arg2 ;
55402   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
55403
55404   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55405   arg2 = (int)jarg2;
55406   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
55407   if (!arg3) {
55408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
55409     return ;
55410   }
55411   {
55412     try {
55413       try {
55414         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);
55415       }
55416       catch(std::out_of_range &_e) {
55417         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55418         return ;
55419       }
55420
55421     } CALL_CATCH_EXCEPTION();
55422   }
55423
55424 }
55425
55426
55427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
55428   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
55429
55430   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
55431   {
55432     try {
55433       delete arg1;
55434     } CALL_CATCH_EXCEPTION();
55435   }
55436
55437 }
55438
55439
55440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
55441   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55442
55443   arg1 = (std::vector< Dali::Actor > *)jarg1;
55444   {
55445     try {
55446       (arg1)->clear();
55447     } CALL_CATCH_EXCEPTION();
55448   }
55449
55450 }
55451
55452
55453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
55454   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55455   Dali::Actor *arg2 = 0 ;
55456
55457   arg1 = (std::vector< Dali::Actor > *)jarg1;
55458   arg2 = (Dali::Actor *)jarg2;
55459   if (!arg2) {
55460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
55461     return ;
55462   }
55463   {
55464     try {
55465       (arg1)->push_back((Dali::Actor const &)*arg2);
55466     } CALL_CATCH_EXCEPTION();
55467   }
55468
55469 }
55470
55471
55472 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
55473   unsigned long jresult ;
55474   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55475   std::vector< Dali::Actor >::size_type result;
55476
55477   arg1 = (std::vector< Dali::Actor > *)jarg1;
55478   {
55479     try {
55480       result = ((std::vector< Dali::Actor > const *)arg1)->size();
55481     } CALL_CATCH_EXCEPTION(0);
55482   }
55483
55484   jresult = (unsigned long)result;
55485   return jresult;
55486 }
55487
55488
55489 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
55490   unsigned long jresult ;
55491   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55492   std::vector< Dali::Actor >::size_type result;
55493
55494   arg1 = (std::vector< Dali::Actor > *)jarg1;
55495   {
55496     try {
55497       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
55498     } CALL_CATCH_EXCEPTION(0);
55499   }
55500
55501   jresult = (unsigned long)result;
55502   return jresult;
55503 }
55504
55505
55506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
55507   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55508   std::vector< Dali::Actor >::size_type arg2 ;
55509
55510   arg1 = (std::vector< Dali::Actor > *)jarg1;
55511   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
55512   {
55513     try {
55514       (arg1)->reserve(arg2);
55515     } CALL_CATCH_EXCEPTION();
55516   }
55517
55518 }
55519
55520
55521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
55522   void * jresult ;
55523   std::vector< Dali::Actor > *result = 0 ;
55524
55525   {
55526     try {
55527       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
55528     } CALL_CATCH_EXCEPTION(0);
55529   }
55530
55531   jresult = (void *)result;
55532   return jresult;
55533 }
55534
55535
55536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
55537   void * jresult ;
55538   std::vector< Dali::Actor > *arg1 = 0 ;
55539   std::vector< Dali::Actor > *result = 0 ;
55540
55541   arg1 = (std::vector< Dali::Actor > *)jarg1;
55542   if (!arg1) {
55543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
55544     return 0;
55545   }
55546   {
55547     try {
55548       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
55549     } CALL_CATCH_EXCEPTION(0);
55550   }
55551
55552   jresult = (void *)result;
55553   return jresult;
55554 }
55555
55556
55557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
55558   void * jresult ;
55559   int arg1 ;
55560   std::vector< Dali::Actor > *result = 0 ;
55561
55562   arg1 = (int)jarg1;
55563   {
55564     try {
55565       try {
55566         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
55567       }
55568       catch(std::out_of_range &_e) {
55569         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55570         return 0;
55571       }
55572
55573     } CALL_CATCH_EXCEPTION(0);
55574   }
55575
55576   jresult = (void *)result;
55577   return jresult;
55578 }
55579
55580
55581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
55582   void * jresult ;
55583   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55584   int arg2 ;
55585   Dali::Actor result;
55586
55587   arg1 = (std::vector< Dali::Actor > *)jarg1;
55588   arg2 = (int)jarg2;
55589   {
55590     try {
55591       try {
55592         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
55593       }
55594       catch(std::out_of_range &_e) {
55595         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55596         return 0;
55597       }
55598
55599     } CALL_CATCH_EXCEPTION(0);
55600   }
55601
55602   jresult = new Dali::Actor((const Dali::Actor &)result);
55603   return jresult;
55604 }
55605
55606
55607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
55608   void * jresult ;
55609   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55610   int arg2 ;
55611   Dali::Actor *result = 0 ;
55612
55613   arg1 = (std::vector< Dali::Actor > *)jarg1;
55614   arg2 = (int)jarg2;
55615   {
55616     try {
55617       try {
55618         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
55619       }
55620       catch(std::out_of_range &_e) {
55621         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55622         return 0;
55623       }
55624
55625     } CALL_CATCH_EXCEPTION(0);
55626   }
55627
55628   jresult = (void *)result;
55629   return jresult;
55630 }
55631
55632
55633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
55634   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55635   int arg2 ;
55636   Dali::Actor *arg3 = 0 ;
55637
55638   arg1 = (std::vector< Dali::Actor > *)jarg1;
55639   arg2 = (int)jarg2;
55640   arg3 = (Dali::Actor *)jarg3;
55641   if (!arg3) {
55642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
55643     return ;
55644   }
55645   {
55646     try {
55647       try {
55648         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
55649       }
55650       catch(std::out_of_range &_e) {
55651         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55652         return ;
55653       }
55654
55655     } CALL_CATCH_EXCEPTION();
55656   }
55657
55658 }
55659
55660
55661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
55662   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55663   std::vector< Dali::Actor > *arg2 = 0 ;
55664
55665   arg1 = (std::vector< Dali::Actor > *)jarg1;
55666   arg2 = (std::vector< Dali::Actor > *)jarg2;
55667   if (!arg2) {
55668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
55669     return ;
55670   }
55671   {
55672     try {
55673       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
55674     } CALL_CATCH_EXCEPTION();
55675   }
55676
55677 }
55678
55679
55680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
55681   void * jresult ;
55682   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55683   int arg2 ;
55684   int arg3 ;
55685   std::vector< Dali::Actor > *result = 0 ;
55686
55687   arg1 = (std::vector< Dali::Actor > *)jarg1;
55688   arg2 = (int)jarg2;
55689   arg3 = (int)jarg3;
55690   {
55691     try {
55692       try {
55693         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
55694       }
55695       catch(std::out_of_range &_e) {
55696         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55697         return 0;
55698       }
55699       catch(std::invalid_argument &_e) {
55700         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
55701         return 0;
55702       }
55703
55704     } CALL_CATCH_EXCEPTION(0);
55705   }
55706
55707   jresult = (void *)result;
55708   return jresult;
55709 }
55710
55711
55712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
55713   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55714   int arg2 ;
55715   Dali::Actor *arg3 = 0 ;
55716
55717   arg1 = (std::vector< Dali::Actor > *)jarg1;
55718   arg2 = (int)jarg2;
55719   arg3 = (Dali::Actor *)jarg3;
55720   if (!arg3) {
55721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
55722     return ;
55723   }
55724   {
55725     try {
55726       try {
55727         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
55728       }
55729       catch(std::out_of_range &_e) {
55730         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55731         return ;
55732       }
55733
55734     } CALL_CATCH_EXCEPTION();
55735   }
55736
55737 }
55738
55739
55740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
55741   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55742   int arg2 ;
55743   std::vector< Dali::Actor > *arg3 = 0 ;
55744
55745   arg1 = (std::vector< Dali::Actor > *)jarg1;
55746   arg2 = (int)jarg2;
55747   arg3 = (std::vector< Dali::Actor > *)jarg3;
55748   if (!arg3) {
55749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
55750     return ;
55751   }
55752   {
55753     try {
55754       try {
55755         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
55756       }
55757       catch(std::out_of_range &_e) {
55758         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55759         return ;
55760       }
55761
55762     } CALL_CATCH_EXCEPTION();
55763   }
55764
55765 }
55766
55767
55768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
55769   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55770   int arg2 ;
55771
55772   arg1 = (std::vector< Dali::Actor > *)jarg1;
55773   arg2 = (int)jarg2;
55774   {
55775     try {
55776       try {
55777         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
55778       }
55779       catch(std::out_of_range &_e) {
55780         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55781         return ;
55782       }
55783
55784     } CALL_CATCH_EXCEPTION();
55785   }
55786
55787 }
55788
55789
55790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
55791   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55792   int arg2 ;
55793   int arg3 ;
55794
55795   arg1 = (std::vector< Dali::Actor > *)jarg1;
55796   arg2 = (int)jarg2;
55797   arg3 = (int)jarg3;
55798   {
55799     try {
55800       try {
55801         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
55802       }
55803       catch(std::out_of_range &_e) {
55804         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55805         return ;
55806       }
55807       catch(std::invalid_argument &_e) {
55808         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
55809         return ;
55810       }
55811
55812     } CALL_CATCH_EXCEPTION();
55813   }
55814
55815 }
55816
55817
55818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
55819   void * jresult ;
55820   Dali::Actor *arg1 = 0 ;
55821   int arg2 ;
55822   std::vector< Dali::Actor > *result = 0 ;
55823
55824   arg1 = (Dali::Actor *)jarg1;
55825   if (!arg1) {
55826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
55827     return 0;
55828   }
55829   arg2 = (int)jarg2;
55830   {
55831     try {
55832       try {
55833         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
55834       }
55835       catch(std::out_of_range &_e) {
55836         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55837         return 0;
55838       }
55839
55840     } CALL_CATCH_EXCEPTION(0);
55841   }
55842
55843   jresult = (void *)result;
55844   return jresult;
55845 }
55846
55847
55848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
55849   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55850
55851   arg1 = (std::vector< Dali::Actor > *)jarg1;
55852   {
55853     try {
55854       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
55855     } CALL_CATCH_EXCEPTION();
55856   }
55857
55858 }
55859
55860
55861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
55862   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55863   int arg2 ;
55864   int arg3 ;
55865
55866   arg1 = (std::vector< Dali::Actor > *)jarg1;
55867   arg2 = (int)jarg2;
55868   arg3 = (int)jarg3;
55869   {
55870     try {
55871       try {
55872         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
55873       }
55874       catch(std::out_of_range &_e) {
55875         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55876         return ;
55877       }
55878       catch(std::invalid_argument &_e) {
55879         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
55880         return ;
55881       }
55882
55883     } CALL_CATCH_EXCEPTION();
55884   }
55885
55886 }
55887
55888
55889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
55890   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55891   int arg2 ;
55892   std::vector< Dali::Actor > *arg3 = 0 ;
55893
55894   arg1 = (std::vector< Dali::Actor > *)jarg1;
55895   arg2 = (int)jarg2;
55896   arg3 = (std::vector< Dali::Actor > *)jarg3;
55897   if (!arg3) {
55898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
55899     return ;
55900   }
55901   {
55902     try {
55903       try {
55904         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
55905       }
55906       catch(std::out_of_range &_e) {
55907         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
55908         return ;
55909       }
55910
55911     } CALL_CATCH_EXCEPTION();
55912   }
55913
55914 }
55915
55916
55917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
55918   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
55919
55920   arg1 = (std::vector< Dali::Actor > *)jarg1;
55921   {
55922     try {
55923       delete arg1;
55924     } CALL_CATCH_EXCEPTION();
55925   }
55926
55927 }
55928
55929
55930 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
55931   bool jresult ;
55932   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
55933   bool result;
55934
55935   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
55936   {
55937     try {
55938       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
55939     } CALL_CATCH_EXCEPTION(0);
55940   }
55941
55942   jresult = result;
55943   return jresult;
55944 }
55945
55946
55947 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
55948   unsigned long jresult ;
55949   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
55950   std::size_t result;
55951
55952   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
55953   {
55954     try {
55955       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
55956     } CALL_CATCH_EXCEPTION(0);
55957   }
55958
55959   jresult = (unsigned long)result;
55960   return jresult;
55961 }
55962
55963
55964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
55965   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
55966   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
55967
55968   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
55969   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
55970   {
55971     try {
55972       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
55973     } CALL_CATCH_EXCEPTION();
55974   }
55975
55976 }
55977
55978
55979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
55980   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
55981   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
55982
55983   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
55984   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
55985   {
55986     try {
55987       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
55988     } CALL_CATCH_EXCEPTION();
55989   }
55990
55991 }
55992
55993
55994 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
55995   bool jresult ;
55996   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
55997   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
55998   bool result;
55999
56000   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
56001   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
56002   if (!arg2) {
56003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
56004     return 0;
56005   }
56006   {
56007     try {
56008       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
56009     } CALL_CATCH_EXCEPTION(0);
56010   }
56011
56012   jresult = result;
56013   return jresult;
56014 }
56015
56016
56017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
56018   void * jresult ;
56019   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
56020
56021   {
56022     try {
56023       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
56024     } CALL_CATCH_EXCEPTION(0);
56025   }
56026
56027   jresult = (void *)result;
56028   return jresult;
56029 }
56030
56031
56032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
56033   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
56034
56035   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
56036   {
56037     try {
56038       delete arg1;
56039     } CALL_CATCH_EXCEPTION();
56040   }
56041
56042 }
56043
56044
56045 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
56046   bool jresult ;
56047   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
56048   bool result;
56049
56050   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
56051   {
56052     try {
56053       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);
56054     } CALL_CATCH_EXCEPTION(0);
56055   }
56056
56057   jresult = result;
56058   return jresult;
56059 }
56060
56061
56062 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
56063   unsigned long jresult ;
56064   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
56065   std::size_t result;
56066
56067   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
56068   {
56069     try {
56070       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);
56071     } CALL_CATCH_EXCEPTION(0);
56072   }
56073
56074   jresult = (unsigned long)result;
56075   return jresult;
56076 }
56077
56078
56079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
56080   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
56081   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
56082
56083   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
56084   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
56085   {
56086     try {
56087       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
56088     } CALL_CATCH_EXCEPTION();
56089   }
56090
56091 }
56092
56093
56094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
56095   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
56096   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
56097
56098   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
56099   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
56100   {
56101     try {
56102       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
56103     } CALL_CATCH_EXCEPTION();
56104   }
56105
56106 }
56107
56108
56109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
56110   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
56111   Dali::Actor arg2 ;
56112   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
56113   Dali::Actor *argp2 ;
56114
56115   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
56116   argp2 = (Dali::Actor *)jarg2;
56117   if (!argp2) {
56118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56119     return ;
56120   }
56121   arg2 = *argp2;
56122   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
56123   {
56124     try {
56125       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
56126     } CALL_CATCH_EXCEPTION();
56127   }
56128
56129 }
56130
56131
56132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
56133   void * jresult ;
56134   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
56135
56136   {
56137     try {
56138       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
56139     } CALL_CATCH_EXCEPTION(0);
56140   }
56141
56142   jresult = (void *)result;
56143   return jresult;
56144 }
56145
56146
56147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
56148   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
56149
56150   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
56151   {
56152     try {
56153       delete arg1;
56154     } CALL_CATCH_EXCEPTION();
56155   }
56156
56157 }
56158
56159
56160 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
56161   bool jresult ;
56162   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
56163   bool result;
56164
56165   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
56166   {
56167     try {
56168       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
56169     } CALL_CATCH_EXCEPTION(0);
56170   }
56171
56172   jresult = result;
56173   return jresult;
56174 }
56175
56176
56177 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
56178   unsigned long jresult ;
56179   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
56180   std::size_t result;
56181
56182   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
56183   {
56184     try {
56185       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
56186     } CALL_CATCH_EXCEPTION(0);
56187   }
56188
56189   jresult = (unsigned long)result;
56190   return jresult;
56191 }
56192
56193
56194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
56195   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
56196   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
56197
56198   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
56199   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
56200   {
56201     try {
56202       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
56203     } CALL_CATCH_EXCEPTION();
56204   }
56205
56206 }
56207
56208
56209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
56210   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
56211   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
56212
56213   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
56214   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
56215   {
56216     try {
56217       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
56218     } CALL_CATCH_EXCEPTION();
56219   }
56220
56221 }
56222
56223
56224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
56225   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
56226   Dali::Actor arg2 ;
56227   Dali::Actor arg3 ;
56228   Dali::Actor *argp2 ;
56229   Dali::Actor *argp3 ;
56230
56231   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
56232   argp2 = (Dali::Actor *)jarg2;
56233   if (!argp2) {
56234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56235     return ;
56236   }
56237   arg2 = *argp2;
56238   argp3 = (Dali::Actor *)jarg3;
56239   if (!argp3) {
56240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56241     return ;
56242   }
56243   arg3 = *argp3;
56244   {
56245     try {
56246       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
56247     } CALL_CATCH_EXCEPTION();
56248   }
56249
56250 }
56251
56252
56253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
56254   void * jresult ;
56255   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
56256
56257   {
56258     try {
56259       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
56260     } CALL_CATCH_EXCEPTION(0);
56261   }
56262
56263   jresult = (void *)result;
56264   return jresult;
56265 }
56266
56267
56268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
56269   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
56270
56271   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
56272   {
56273     try {
56274       delete arg1;
56275     } CALL_CATCH_EXCEPTION();
56276   }
56277
56278 }
56279
56280
56281 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
56282   bool jresult ;
56283   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
56284   bool result;
56285
56286   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
56287   {
56288     try {
56289       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
56290     } CALL_CATCH_EXCEPTION(0);
56291   }
56292
56293   jresult = result;
56294   return jresult;
56295 }
56296
56297
56298 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
56299   unsigned long jresult ;
56300   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
56301   std::size_t result;
56302
56303   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
56304   {
56305     try {
56306       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
56307     } CALL_CATCH_EXCEPTION(0);
56308   }
56309
56310   jresult = (unsigned long)result;
56311   return jresult;
56312 }
56313
56314
56315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
56316   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
56317   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
56318
56319   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
56320   arg2 = (void (*)(Dali::Actor,bool))jarg2;
56321   {
56322     try {
56323       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
56324     } CALL_CATCH_EXCEPTION();
56325   }
56326
56327 }
56328
56329
56330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
56331   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
56332   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
56333
56334   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
56335   arg2 = (void (*)(Dali::Actor,bool))jarg2;
56336   {
56337     try {
56338       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
56339     } CALL_CATCH_EXCEPTION();
56340   }
56341
56342 }
56343
56344
56345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, bool jarg3) {
56346   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
56347   Dali::Actor arg2 ;
56348   bool arg3 ;
56349   Dali::Actor *argp2 ;
56350
56351   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
56352   argp2 = (Dali::Actor *)jarg2;
56353   if (!argp2) {
56354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56355     return ;
56356   }
56357   arg2 = *argp2;
56358   arg3 = jarg3 ? true : false;
56359   {
56360     try {
56361       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
56362     } CALL_CATCH_EXCEPTION();
56363   }
56364
56365 }
56366
56367
56368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
56369   void * jresult ;
56370   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
56371
56372   {
56373     try {
56374       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
56375     } CALL_CATCH_EXCEPTION(0);
56376   }
56377
56378   jresult = (void *)result;
56379   return jresult;
56380 }
56381
56382
56383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
56384   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
56385
56386   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
56387   {
56388     try {
56389       delete arg1;
56390     } CALL_CATCH_EXCEPTION();
56391   }
56392
56393 }
56394
56395
56396 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
56397   bool jresult ;
56398   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
56399   bool result;
56400
56401   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
56402   {
56403     try {
56404       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);
56405     } CALL_CATCH_EXCEPTION(0);
56406   }
56407
56408   jresult = result;
56409   return jresult;
56410 }
56411
56412
56413 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
56414   unsigned long jresult ;
56415   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
56416   std::size_t result;
56417
56418   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
56419   {
56420     try {
56421       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);
56422     } CALL_CATCH_EXCEPTION(0);
56423   }
56424
56425   jresult = (unsigned long)result;
56426   return jresult;
56427 }
56428
56429
56430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
56431   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
56432   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
56433
56434   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
56435   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
56436   {
56437     try {
56438       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
56439     } CALL_CATCH_EXCEPTION();
56440   }
56441
56442 }
56443
56444
56445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
56446   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
56447   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
56448
56449   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
56450   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
56451   {
56452     try {
56453       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
56454     } CALL_CATCH_EXCEPTION();
56455   }
56456
56457 }
56458
56459
56460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
56461   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
56462   Dali::Toolkit::StyleManager arg2 ;
56463   Dali::StyleChange::Type arg3 ;
56464   Dali::Toolkit::StyleManager *argp2 ;
56465
56466   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
56467   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
56468   if (!argp2) {
56469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
56470     return ;
56471   }
56472   arg2 = *argp2;
56473   arg3 = (Dali::StyleChange::Type)jarg3;
56474   {
56475     try {
56476       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
56477     } CALL_CATCH_EXCEPTION();
56478   }
56479
56480 }
56481
56482
56483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
56484   void * jresult ;
56485   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
56486
56487   {
56488     try {
56489       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
56490     } CALL_CATCH_EXCEPTION(0);
56491   }
56492
56493   jresult = (void *)result;
56494   return jresult;
56495 }
56496
56497
56498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
56499   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
56500
56501   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
56502   {
56503     try {
56504       delete arg1;
56505     } CALL_CATCH_EXCEPTION();
56506   }
56507
56508 }
56509
56510
56511 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
56512   bool jresult ;
56513   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
56514   bool result;
56515
56516   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
56517   {
56518     try {
56519       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
56520     } CALL_CATCH_EXCEPTION(0);
56521   }
56522
56523   jresult = result;
56524   return jresult;
56525 }
56526
56527
56528 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
56529   unsigned long jresult ;
56530   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
56531   std::size_t result;
56532
56533   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
56534   {
56535     try {
56536       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
56537     } CALL_CATCH_EXCEPTION(0);
56538   }
56539
56540   jresult = (unsigned long)result;
56541   return jresult;
56542 }
56543
56544
56545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
56546   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
56547   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
56548
56549   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
56550   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
56551   {
56552     try {
56553       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
56554     } CALL_CATCH_EXCEPTION();
56555   }
56556
56557 }
56558
56559
56560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
56561   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
56562   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
56563
56564   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
56565   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
56566   {
56567     try {
56568       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
56569     } CALL_CATCH_EXCEPTION();
56570   }
56571
56572 }
56573
56574
56575 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
56576   bool jresult ;
56577   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
56578   Dali::Toolkit::Button arg2 ;
56579   Dali::Toolkit::Button *argp2 ;
56580   bool result;
56581
56582   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
56583   argp2 = (Dali::Toolkit::Button *)jarg2;
56584   if (!argp2) {
56585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
56586     return 0;
56587   }
56588   arg2 = *argp2;
56589   {
56590     try {
56591       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
56592     } CALL_CATCH_EXCEPTION(0);
56593   }
56594
56595   jresult = result;
56596   return jresult;
56597 }
56598
56599
56600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
56601   void * jresult ;
56602   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
56603
56604   {
56605     try {
56606       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
56607     } CALL_CATCH_EXCEPTION(0);
56608   }
56609
56610   jresult = (void *)result;
56611   return jresult;
56612 }
56613
56614
56615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
56616   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
56617
56618   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
56619   {
56620     try {
56621       delete arg1;
56622     } CALL_CATCH_EXCEPTION();
56623   }
56624
56625 }
56626
56627
56628 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
56629   bool jresult ;
56630   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
56631   bool result;
56632
56633   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
56634   {
56635     try {
56636       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
56637     } CALL_CATCH_EXCEPTION(0);
56638   }
56639
56640   jresult = result;
56641   return jresult;
56642 }
56643
56644
56645 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
56646   unsigned long jresult ;
56647   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
56648   std::size_t result;
56649
56650   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
56651   {
56652     try {
56653       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
56654     } CALL_CATCH_EXCEPTION(0);
56655   }
56656
56657   jresult = (unsigned long)result;
56658   return jresult;
56659 }
56660
56661
56662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
56663   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
56664   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
56665
56666   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
56667   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
56668   {
56669     try {
56670       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
56671     } CALL_CATCH_EXCEPTION();
56672   }
56673
56674 }
56675
56676
56677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
56678   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
56679   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
56680
56681   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
56682   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
56683   {
56684     try {
56685       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
56686     } CALL_CATCH_EXCEPTION();
56687   }
56688
56689 }
56690
56691
56692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
56693   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
56694   Dali::Toolkit::GaussianBlurView arg2 ;
56695   Dali::Toolkit::GaussianBlurView *argp2 ;
56696
56697   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
56698   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
56699   if (!argp2) {
56700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
56701     return ;
56702   }
56703   arg2 = *argp2;
56704   {
56705     try {
56706       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
56707     } CALL_CATCH_EXCEPTION();
56708   }
56709
56710 }
56711
56712
56713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
56714   void * jresult ;
56715   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
56716
56717   {
56718     try {
56719       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
56720     } CALL_CATCH_EXCEPTION(0);
56721   }
56722
56723   jresult = (void *)result;
56724   return jresult;
56725 }
56726
56727
56728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
56729   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
56730
56731   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
56732   {
56733     try {
56734       delete arg1;
56735     } CALL_CATCH_EXCEPTION();
56736   }
56737
56738 }
56739
56740
56741 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
56742   bool jresult ;
56743   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
56744   bool result;
56745
56746   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
56747   {
56748     try {
56749       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);
56750     } CALL_CATCH_EXCEPTION(0);
56751   }
56752
56753   jresult = result;
56754   return jresult;
56755 }
56756
56757
56758 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
56759   unsigned long jresult ;
56760   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
56761   std::size_t result;
56762
56763   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
56764   {
56765     try {
56766       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);
56767     } CALL_CATCH_EXCEPTION(0);
56768   }
56769
56770   jresult = (unsigned long)result;
56771   return jresult;
56772 }
56773
56774
56775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
56776   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
56777   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
56778
56779   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
56780   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
56781   {
56782     try {
56783       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
56784     } CALL_CATCH_EXCEPTION();
56785   }
56786
56787 }
56788
56789
56790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
56791   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
56792   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
56793
56794   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
56795   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
56796   {
56797     try {
56798       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
56799     } CALL_CATCH_EXCEPTION();
56800   }
56801
56802 }
56803
56804
56805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, bool jarg4) {
56806   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
56807   Dali::Toolkit::PageTurnView arg2 ;
56808   unsigned int arg3 ;
56809   bool arg4 ;
56810   Dali::Toolkit::PageTurnView *argp2 ;
56811
56812   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
56813   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
56814   if (!argp2) {
56815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
56816     return ;
56817   }
56818   arg2 = *argp2;
56819   arg3 = (unsigned int)jarg3;
56820   arg4 = jarg4 ? true : false;
56821   {
56822     try {
56823       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
56824     } CALL_CATCH_EXCEPTION();
56825   }
56826
56827 }
56828
56829
56830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
56831   void * jresult ;
56832   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
56833
56834   {
56835     try {
56836       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
56837     } CALL_CATCH_EXCEPTION(0);
56838   }
56839
56840   jresult = (void *)result;
56841   return jresult;
56842 }
56843
56844
56845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
56846   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
56847
56848   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
56849   {
56850     try {
56851       delete arg1;
56852     } CALL_CATCH_EXCEPTION();
56853   }
56854
56855 }
56856
56857
56858 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
56859   bool jresult ;
56860   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
56861   bool result;
56862
56863   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
56864   {
56865     try {
56866       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
56867     } CALL_CATCH_EXCEPTION(0);
56868   }
56869
56870   jresult = result;
56871   return jresult;
56872 }
56873
56874
56875 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
56876   unsigned long jresult ;
56877   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
56878   std::size_t result;
56879
56880   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
56881   {
56882     try {
56883       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
56884     } CALL_CATCH_EXCEPTION(0);
56885   }
56886
56887   jresult = (unsigned long)result;
56888   return jresult;
56889 }
56890
56891
56892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
56893   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
56894   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
56895
56896   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
56897   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
56898   {
56899     try {
56900       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
56901     } CALL_CATCH_EXCEPTION();
56902   }
56903 }
56904
56905
56906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
56907   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
56908   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
56909
56910   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
56911   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
56912   {
56913     try {
56914       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
56915     } CALL_CATCH_EXCEPTION();
56916   }
56917 }
56918
56919
56920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
56921   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
56922   Dali::Toolkit::PageTurnView arg2 ;
56923   Dali::Toolkit::PageTurnView *argp2 ;
56924
56925   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
56926   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
56927   if (!argp2) {
56928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
56929     return ;
56930   }
56931   arg2 = *argp2;
56932   {
56933     try {
56934       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
56935     } CALL_CATCH_EXCEPTION();
56936   }
56937 }
56938
56939
56940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
56941   void * jresult ;
56942   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
56943
56944   {
56945     try {
56946       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
56947     } CALL_CATCH_EXCEPTION(0);
56948   }
56949
56950   jresult = (void *)result;
56951   return jresult;
56952 }
56953
56954
56955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
56956   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
56957
56958   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
56959   {
56960     try {
56961       delete arg1;
56962     } CALL_CATCH_EXCEPTION();
56963   }
56964
56965 }
56966
56967
56968 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
56969   bool jresult ;
56970   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
56971   bool result;
56972
56973   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
56974   {
56975     try {
56976       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);
56977     } CALL_CATCH_EXCEPTION(0);
56978   }
56979
56980   jresult = result;
56981   return jresult;
56982 }
56983
56984
56985 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
56986   unsigned long jresult ;
56987   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
56988   std::size_t result;
56989
56990   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
56991   {
56992     try {
56993       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);
56994     } CALL_CATCH_EXCEPTION(0);
56995   }
56996
56997   jresult = (unsigned long)result;
56998   return jresult;
56999 }
57000
57001
57002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
57003   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
57004   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
57005
57006   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
57007   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
57008   {
57009     try {
57010       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
57011     } CALL_CATCH_EXCEPTION();
57012   }
57013
57014 }
57015
57016
57017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
57018   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
57019   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
57020
57021   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
57022   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
57023   {
57024     try {
57025       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
57026     } CALL_CATCH_EXCEPTION();
57027   }
57028
57029 }
57030
57031
57032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
57033   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
57034   Dali::Toolkit::ProgressBar arg2 ;
57035   float arg3 ;
57036   float arg4 ;
57037   Dali::Toolkit::ProgressBar *argp2 ;
57038
57039   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
57040   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
57041   if (!argp2) {
57042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
57043     return ;
57044   }
57045   arg2 = *argp2;
57046   arg3 = (float)jarg3;
57047   arg4 = (float)jarg4;
57048   {
57049     try {
57050       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
57051     } CALL_CATCH_EXCEPTION();
57052   }
57053
57054 }
57055
57056
57057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
57058   void * jresult ;
57059   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
57060
57061   {
57062     try {
57063       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
57064     } CALL_CATCH_EXCEPTION(0);
57065   }
57066
57067   jresult = (void *)result;
57068   return jresult;
57069 }
57070
57071
57072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
57073   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
57074
57075   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
57076   {
57077     try {
57078       delete arg1;
57079     } CALL_CATCH_EXCEPTION();
57080   }
57081
57082 }
57083
57084
57085 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
57086   bool jresult ;
57087   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
57088   bool result;
57089
57090   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
57091   {
57092     try {
57093       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);
57094     } CALL_CATCH_EXCEPTION(0);
57095   }
57096
57097   jresult = result;
57098   return jresult;
57099 }
57100
57101
57102 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
57103   unsigned long jresult ;
57104   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
57105   std::size_t result;
57106
57107   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
57108   {
57109     try {
57110       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);
57111     } CALL_CATCH_EXCEPTION(0);
57112   }
57113
57114   jresult = (unsigned long)result;
57115   return jresult;
57116 }
57117
57118
57119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
57120   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
57121   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
57122
57123   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
57124   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
57125   {
57126     try {
57127       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57128     } CALL_CATCH_EXCEPTION();
57129   }
57130
57131 }
57132
57133
57134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
57135   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
57136   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
57137
57138   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
57139   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
57140   {
57141     try {
57142       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57143     } CALL_CATCH_EXCEPTION();
57144   }
57145
57146 }
57147
57148
57149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
57150   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
57151   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
57152
57153   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
57154   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
57155   if (!arg2) {
57156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
57157     return ;
57158   }
57159   {
57160     try {
57161       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
57162     } CALL_CATCH_EXCEPTION();
57163   }
57164
57165 }
57166
57167
57168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
57169   void * jresult ;
57170   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
57171
57172   {
57173     try {
57174       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
57175     } CALL_CATCH_EXCEPTION(0);
57176   }
57177
57178   jresult = (void *)result;
57179   return jresult;
57180 }
57181
57182
57183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
57184   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
57185
57186   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
57187   {
57188     try {
57189       delete arg1;
57190     } CALL_CATCH_EXCEPTION();
57191   }
57192
57193 }
57194
57195
57196 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
57197   bool jresult ;
57198   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
57199   bool result;
57200
57201   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
57202   {
57203     try {
57204       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
57205     } CALL_CATCH_EXCEPTION(0);
57206   }
57207
57208   jresult = result;
57209   return jresult;
57210 }
57211
57212
57213 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
57214   unsigned long jresult ;
57215   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
57216   std::size_t result;
57217
57218   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
57219   {
57220     try {
57221       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
57222     } CALL_CATCH_EXCEPTION(0);
57223   }
57224
57225   jresult = (unsigned long)result;
57226   return jresult;
57227 }
57228
57229
57230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
57231   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
57232   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
57233
57234   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
57235   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
57236   {
57237     try {
57238       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57239     } CALL_CATCH_EXCEPTION();
57240   }
57241
57242 }
57243
57244
57245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
57246   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
57247   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
57248
57249   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
57250   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
57251   {
57252     try {
57253       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57254     } CALL_CATCH_EXCEPTION();
57255   }
57256
57257 }
57258
57259
57260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
57261   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
57262   Dali::Vector2 *arg2 = 0 ;
57263
57264   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
57265   arg2 = (Dali::Vector2 *)jarg2;
57266   if (!arg2) {
57267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
57268     return ;
57269   }
57270   {
57271     try {
57272       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
57273     } CALL_CATCH_EXCEPTION();
57274   }
57275
57276 }
57277
57278
57279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
57280   void * jresult ;
57281   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
57282
57283   {
57284     try {
57285       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
57286     } CALL_CATCH_EXCEPTION(0);
57287   }
57288
57289   jresult = (void *)result;
57290   return jresult;
57291 }
57292
57293
57294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
57295   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
57296
57297   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
57298   {
57299     try {
57300       delete arg1;
57301     } CALL_CATCH_EXCEPTION();
57302   }
57303
57304 }
57305
57306
57307
57308 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
57309   bool jresult ;
57310   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
57311   bool result;
57312
57313   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
57314   {
57315     try {
57316       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);
57317     } CALL_CATCH_EXCEPTION(0);
57318   }
57319
57320   jresult = result;
57321   return jresult;
57322 }
57323
57324
57325 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
57326   unsigned long jresult ;
57327   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
57328   std::size_t result;
57329
57330   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
57331   {
57332     try {
57333       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);
57334     } CALL_CATCH_EXCEPTION(0);
57335   }
57336
57337   jresult = (unsigned long)result;
57338   return jresult;
57339 }
57340
57341
57342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
57343   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
57344   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
57345
57346   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
57347   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
57348   {
57349     try {
57350       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57351     } CALL_CATCH_EXCEPTION();
57352   }
57353
57354 }
57355
57356
57357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
57358   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
57359   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
57360
57361   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
57362   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
57363   {
57364     try {
57365       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57366     } CALL_CATCH_EXCEPTION();
57367   }
57368
57369 }
57370
57371
57372 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57373   bool jresult ;
57374   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
57375   Dali::Toolkit::Control arg2 ;
57376   Dali::KeyEvent *arg3 = 0 ;
57377   Dali::Toolkit::Control *argp2 ;
57378   bool result;
57379
57380   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
57381   argp2 = (Dali::Toolkit::Control *)jarg2;
57382   if (!argp2) {
57383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
57384     return 0;
57385   }
57386   arg2 = *argp2;
57387   arg3 = (Dali::KeyEvent *)jarg3;
57388   if (!arg3) {
57389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
57390     return 0;
57391   }
57392   {
57393     try {
57394       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);
57395     } CALL_CATCH_EXCEPTION(0);
57396   }
57397
57398   jresult = result;
57399   return jresult;
57400 }
57401
57402
57403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
57404   void * jresult ;
57405   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
57406
57407   {
57408     try {
57409       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
57410     } CALL_CATCH_EXCEPTION(0);
57411   }
57412
57413   jresult = (void *)result;
57414   return jresult;
57415 }
57416
57417
57418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
57419   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
57420
57421   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
57422   {
57423     try {
57424       delete arg1;
57425     } CALL_CATCH_EXCEPTION();
57426   }
57427
57428 }
57429
57430
57431 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
57432   bool jresult ;
57433   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
57434   bool result;
57435
57436   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
57437   {
57438     try {
57439       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
57440     } CALL_CATCH_EXCEPTION(0);
57441   }
57442
57443   jresult = result;
57444   return jresult;
57445 }
57446
57447
57448 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
57449   unsigned long jresult ;
57450   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
57451   std::size_t result;
57452
57453   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
57454   {
57455     try {
57456       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
57457     } CALL_CATCH_EXCEPTION(0);
57458   }
57459
57460   jresult = (unsigned long)result;
57461   return jresult;
57462 }
57463
57464
57465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
57466   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
57467   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
57468
57469   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
57470   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
57471   {
57472     try {
57473       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
57474     } CALL_CATCH_EXCEPTION();
57475   }
57476
57477 }
57478
57479
57480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
57481   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
57482   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
57483
57484   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
57485   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
57486   {
57487     try {
57488       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
57489     } CALL_CATCH_EXCEPTION();
57490   }
57491
57492 }
57493
57494
57495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
57496   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
57497   Dali::Toolkit::Control arg2 ;
57498   Dali::Toolkit::Control *argp2 ;
57499
57500   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
57501   argp2 = (Dali::Toolkit::Control *)jarg2;
57502   if (!argp2) {
57503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
57504     return ;
57505   }
57506   arg2 = *argp2;
57507   {
57508     try {
57509       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
57510     } CALL_CATCH_EXCEPTION();
57511   }
57512
57513 }
57514
57515
57516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
57517   void * jresult ;
57518   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
57519
57520   {
57521     try {
57522       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
57523     } CALL_CATCH_EXCEPTION(0);
57524   }
57525
57526   jresult = (void *)result;
57527   return jresult;
57528 }
57529
57530
57531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
57532   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
57533
57534   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
57535   {
57536     try {
57537       delete arg1;
57538     } CALL_CATCH_EXCEPTION();
57539   }
57540
57541 }
57542
57543
57544 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
57545   bool jresult ;
57546   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
57547   bool result;
57548
57549   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
57550   {
57551     try {
57552       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
57553     } CALL_CATCH_EXCEPTION(0);
57554   }
57555
57556   jresult = result;
57557   return jresult;
57558 }
57559
57560
57561 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
57562   unsigned long jresult ;
57563   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
57564   std::size_t result;
57565
57566   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
57567   {
57568     try {
57569       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
57570     } CALL_CATCH_EXCEPTION(0);
57571   }
57572
57573   jresult = (unsigned long)result;
57574   return jresult;
57575 }
57576
57577
57578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
57579   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
57580   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
57581
57582   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
57583   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
57584   {
57585     try {
57586       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
57587     } CALL_CATCH_EXCEPTION();
57588   }
57589
57590 }
57591
57592
57593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
57594   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
57595   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
57596
57597   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
57598   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
57599   {
57600     try {
57601       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
57602     } CALL_CATCH_EXCEPTION();
57603   }
57604
57605 }
57606
57607
57608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
57609   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
57610   Dali::Toolkit::VideoView *arg2 = 0 ;
57611
57612   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
57613   arg2 = (Dali::Toolkit::VideoView *)jarg2;
57614   if (!arg2) {
57615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
57616     return ;
57617   }
57618   {
57619     try {
57620       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
57621     } CALL_CATCH_EXCEPTION();
57622   }
57623
57624 }
57625
57626
57627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
57628   void * jresult ;
57629   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
57630
57631   {
57632     try {
57633       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
57634     } CALL_CATCH_EXCEPTION(0);
57635   }
57636
57637   jresult = (void *)result;
57638   return jresult;
57639 }
57640
57641
57642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
57643   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
57644
57645   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
57646   {
57647     try {
57648       delete arg1;
57649     } CALL_CATCH_EXCEPTION();
57650   }
57651
57652 }
57653
57654
57655 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
57656   bool jresult ;
57657   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
57658   bool result;
57659
57660   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
57661   {
57662     try {
57663       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
57664     } CALL_CATCH_EXCEPTION(0);
57665   }
57666
57667   jresult = result;
57668   return jresult;
57669 }
57670
57671
57672 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
57673   unsigned long jresult ;
57674   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
57675   std::size_t result;
57676
57677   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
57678   {
57679     try {
57680       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
57681     } CALL_CATCH_EXCEPTION(0);
57682   }
57683
57684   jresult = (unsigned long)result;
57685   return jresult;
57686 }
57687
57688
57689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
57690   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
57691   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
57692
57693   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
57694   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
57695   {
57696     try {
57697       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
57698     } CALL_CATCH_EXCEPTION();
57699   }
57700
57701 }
57702
57703
57704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
57705   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
57706   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
57707
57708   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
57709   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
57710   {
57711     try {
57712       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
57713     } CALL_CATCH_EXCEPTION();
57714   }
57715
57716 }
57717
57718
57719 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
57720   bool jresult ;
57721   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
57722   Dali::Toolkit::Slider arg2 ;
57723   float arg3 ;
57724   Dali::Toolkit::Slider *argp2 ;
57725   bool result;
57726
57727   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
57728   argp2 = (Dali::Toolkit::Slider *)jarg2;
57729   if (!argp2) {
57730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
57731     return 0;
57732   }
57733   arg2 = *argp2;
57734   arg3 = (float)jarg3;
57735   {
57736     try {
57737       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
57738     } CALL_CATCH_EXCEPTION(0);
57739   }
57740
57741   jresult = result;
57742   return jresult;
57743 }
57744
57745
57746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
57747   void * jresult ;
57748   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
57749
57750   {
57751     try {
57752       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
57753     } CALL_CATCH_EXCEPTION(0);
57754   }
57755
57756   jresult = (void *)result;
57757   return jresult;
57758 }
57759
57760
57761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
57762   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
57763
57764   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
57765   {
57766     try {
57767       delete arg1;
57768     } CALL_CATCH_EXCEPTION();
57769   }
57770
57771 }
57772
57773
57774 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
57775   bool jresult ;
57776   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
57777   bool result;
57778
57779   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
57780   {
57781     try {
57782       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
57783     } CALL_CATCH_EXCEPTION(0);
57784   }
57785
57786   jresult = result;
57787   return jresult;
57788 }
57789
57790
57791 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
57792   unsigned long jresult ;
57793   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
57794   std::size_t result;
57795
57796   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
57797   {
57798     try {
57799       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
57800     } CALL_CATCH_EXCEPTION(0);
57801   }
57802
57803   jresult = (unsigned long)result;
57804   return jresult;
57805 }
57806
57807
57808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
57809   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
57810   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
57811
57812   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
57813   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
57814   {
57815     try {
57816       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
57817     } CALL_CATCH_EXCEPTION();
57818   }
57819
57820 }
57821
57822
57823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
57824   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
57825   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
57826
57827   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
57828   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
57829   {
57830     try {
57831       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
57832     } CALL_CATCH_EXCEPTION();
57833   }
57834
57835 }
57836
57837
57838 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
57839   bool jresult ;
57840   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
57841   Dali::Toolkit::Slider arg2 ;
57842   int arg3 ;
57843   Dali::Toolkit::Slider *argp2 ;
57844   bool result;
57845
57846   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
57847   argp2 = (Dali::Toolkit::Slider *)jarg2;
57848   if (!argp2) {
57849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
57850     return 0;
57851   }
57852   arg2 = *argp2;
57853   arg3 = (int)jarg3;
57854   {
57855     try {
57856       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
57857     } CALL_CATCH_EXCEPTION(0);
57858   }
57859
57860   jresult = result;
57861   return jresult;
57862 }
57863
57864
57865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
57866   void * jresult ;
57867   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
57868
57869   {
57870     try {
57871       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
57872     } CALL_CATCH_EXCEPTION(0);
57873   }
57874
57875   jresult = (void *)result;
57876   return jresult;
57877 }
57878
57879
57880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
57881   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
57882
57883   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
57884   {
57885     try {
57886       delete arg1;
57887     } CALL_CATCH_EXCEPTION();
57888   }
57889
57890 }
57891
57892
57893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
57894   void * jresult ;
57895   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
57896
57897   {
57898     try {
57899       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
57900     } CALL_CATCH_EXCEPTION(0);
57901   }
57902
57903   jresult = (void *)result;
57904   return jresult;
57905 }
57906
57907
57908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
57909   void * jresult ;
57910   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
57911   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
57912
57913   arg1 = (Dali::Toolkit::Ruler *)jarg1;
57914   {
57915     try {
57916       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
57917     } CALL_CATCH_EXCEPTION(0);
57918   }
57919
57920   jresult = (void *)result;
57921   return jresult;
57922 }
57923
57924
57925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
57926   void * jresult ;
57927   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
57928   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
57929
57930   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57931   if (!arg1) {
57932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
57933     return 0;
57934   }
57935   {
57936     try {
57937       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
57938     } CALL_CATCH_EXCEPTION(0);
57939   }
57940
57941   jresult = (void *)result;
57942   return jresult;
57943 }
57944
57945
57946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
57947   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57948
57949   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57950   {
57951     try {
57952       delete arg1;
57953     } CALL_CATCH_EXCEPTION();
57954   }
57955
57956 }
57957
57958
57959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
57960   void * jresult ;
57961   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57962   Dali::Toolkit::Ruler *result = 0 ;
57963
57964   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57965   {
57966     try {
57967       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
57968     } CALL_CATCH_EXCEPTION(0);
57969   }
57970
57971   jresult = (void *)result;
57972   return jresult;
57973 }
57974
57975
57976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
57977   void * jresult ;
57978   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57979   Dali::Toolkit::Ruler *result = 0 ;
57980
57981   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57982   {
57983     try {
57984       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
57985     } CALL_CATCH_EXCEPTION(0);
57986   }
57987
57988   jresult = (void *)result;
57989   return jresult;
57990 }
57991
57992
57993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
57994   void * jresult ;
57995   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57996   Dali::Toolkit::Ruler *result = 0 ;
57997
57998   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57999   {
58000     try {
58001       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
58002     } CALL_CATCH_EXCEPTION(0);
58003   }
58004
58005   jresult = (void *)result;
58006   return jresult;
58007 }
58008
58009
58010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
58011   void * jresult ;
58012   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58013   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
58014   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
58015
58016   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58017   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
58018   if (!arg2) {
58019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
58020     return 0;
58021   }
58022   {
58023     try {
58024       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
58025     } CALL_CATCH_EXCEPTION(0);
58026   }
58027
58028   jresult = (void *)result;
58029   return jresult;
58030 }
58031
58032
58033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
58034   void * jresult ;
58035   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58036   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
58037   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
58038
58039   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58040   arg2 = (Dali::Toolkit::Ruler *)jarg2;
58041   {
58042     try {
58043       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
58044     } CALL_CATCH_EXCEPTION(0);
58045   }
58046
58047   jresult = (void *)result;
58048   return jresult;
58049 }
58050
58051
58052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
58053   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58054
58055   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58056   {
58057     try {
58058       (arg1)->Reset();
58059     } CALL_CATCH_EXCEPTION();
58060   }
58061
58062 }
58063
58064
58065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
58066   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58067   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
58068
58069   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58070   arg2 = (Dali::Toolkit::Ruler *)jarg2;
58071   {
58072     try {
58073       (arg1)->Reset(arg2);
58074     } CALL_CATCH_EXCEPTION();
58075   }
58076
58077 }
58078
58079
58080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
58081   void * jresult ;
58082   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58083   Dali::Toolkit::Ruler *result = 0 ;
58084
58085   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58086   {
58087     try {
58088       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
58089     } CALL_CATCH_EXCEPTION(0);
58090   }
58091
58092   jresult = (void *)result;
58093   return jresult;
58094 }
58095
58096
58097 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
58098   float jresult ;
58099   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58100   float arg2 ;
58101   float arg3 ;
58102   float result;
58103
58104   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58105   arg2 = (float)jarg2;
58106   arg3 = (float)jarg3;
58107   {
58108     try {
58109       result = (float)(*arg1)->Snap(arg2,arg3);
58110     } CALL_CATCH_EXCEPTION(0);
58111   }
58112
58113   jresult = result;
58114   return jresult;
58115 }
58116
58117
58118 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
58119   float jresult ;
58120   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58121   float arg2 ;
58122   float result;
58123
58124   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58125   arg2 = (float)jarg2;
58126   {
58127     try {
58128       result = (float)(*arg1)->Snap(arg2);
58129     } CALL_CATCH_EXCEPTION(0);
58130   }
58131
58132   jresult = result;
58133   return jresult;
58134 }
58135
58136
58137 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) {
58138   float jresult ;
58139   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58140   unsigned int arg2 ;
58141   unsigned int *arg3 = 0 ;
58142   bool arg4 ;
58143   float result;
58144
58145   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58146   arg2 = (unsigned int)jarg2;
58147   arg3 = (unsigned int *)jarg3;
58148   arg4 = jarg4 ? true : false;
58149   {
58150     try {
58151       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
58152     } CALL_CATCH_EXCEPTION(0);
58153   }
58154
58155   jresult = result;
58156   return jresult;
58157 }
58158
58159
58160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) {
58161   unsigned int jresult ;
58162   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58163   float arg2 ;
58164   bool arg3 ;
58165   unsigned int result;
58166
58167   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58168   arg2 = (float)jarg2;
58169   arg3 = jarg3 ? true : false;
58170   {
58171     try {
58172       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
58173     } CALL_CATCH_EXCEPTION(0);
58174   }
58175
58176   jresult = result;
58177   return jresult;
58178 }
58179
58180
58181 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
58182   unsigned int jresult ;
58183   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58184   unsigned int result;
58185
58186   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58187   {
58188     try {
58189       result = (unsigned int)(*arg1)->GetTotalPages();
58190     } CALL_CATCH_EXCEPTION(0);
58191   }
58192
58193   jresult = result;
58194   return jresult;
58195 }
58196
58197
58198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
58199   int jresult ;
58200   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58201   Dali::Toolkit::Ruler::RulerType result;
58202
58203   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58204   {
58205     try {
58206       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
58207     } CALL_CATCH_EXCEPTION(0);
58208   }
58209
58210   jresult = (int)result;
58211   return jresult;
58212 }
58213
58214
58215 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
58216   bool jresult ;
58217   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58218   bool result;
58219
58220   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58221   {
58222     try {
58223       result = (bool)(*arg1)->IsEnabled();
58224     } CALL_CATCH_EXCEPTION(0);
58225   }
58226
58227   jresult = result;
58228   return jresult;
58229 }
58230
58231
58232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
58233   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58234
58235   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58236   {
58237     try {
58238       (*arg1)->Enable();
58239     } CALL_CATCH_EXCEPTION();
58240   }
58241
58242 }
58243
58244
58245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
58246   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58247
58248   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58249   {
58250     try {
58251       (*arg1)->Disable();
58252     } CALL_CATCH_EXCEPTION();
58253   }
58254
58255 }
58256
58257
58258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
58259   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58260   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
58261   Dali::Toolkit::RulerDomain *argp2 ;
58262
58263   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58264   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
58265   if (!argp2) {
58266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
58267     return ;
58268   }
58269   arg2 = *argp2;
58270   {
58271     try {
58272       (*arg1)->SetDomain(arg2);
58273     } CALL_CATCH_EXCEPTION();
58274   }
58275
58276 }
58277
58278
58279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
58280   void * jresult ;
58281   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58282   Dali::Toolkit::RulerDomain *result = 0 ;
58283
58284   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58285   {
58286     try {
58287       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
58288     } CALL_CATCH_EXCEPTION(0);
58289   }
58290
58291   jresult = (void *)result;
58292   return jresult;
58293 }
58294
58295
58296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
58297   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58298
58299   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58300   {
58301     try {
58302       (*arg1)->DisableDomain();
58303     } CALL_CATCH_EXCEPTION();
58304   }
58305
58306 }
58307
58308
58309 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
58310   float jresult ;
58311   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58312   float arg2 ;
58313   float arg3 ;
58314   float arg4 ;
58315   float result;
58316
58317   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58318   arg2 = (float)jarg2;
58319   arg3 = (float)jarg3;
58320   arg4 = (float)jarg4;
58321   {
58322     try {
58323       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
58324     } CALL_CATCH_EXCEPTION(0);
58325   }
58326
58327   jresult = result;
58328   return jresult;
58329 }
58330
58331
58332 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
58333   float jresult ;
58334   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58335   float arg2 ;
58336   float arg3 ;
58337   float result;
58338
58339   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58340   arg2 = (float)jarg2;
58341   arg3 = (float)jarg3;
58342   {
58343     try {
58344       result = (float)(*arg1)->Clamp(arg2,arg3);
58345     } CALL_CATCH_EXCEPTION(0);
58346   }
58347
58348   jresult = result;
58349   return jresult;
58350 }
58351
58352
58353 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
58354   float jresult ;
58355   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58356   float arg2 ;
58357   float result;
58358
58359   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58360   arg2 = (float)jarg2;
58361   {
58362     try {
58363       result = (float)(*arg1)->Clamp(arg2);
58364     } CALL_CATCH_EXCEPTION(0);
58365   }
58366
58367   jresult = result;
58368   return jresult;
58369 }
58370
58371
58372 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
58373   float jresult ;
58374   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58375   float arg2 ;
58376   float arg3 ;
58377   float arg4 ;
58378   Dali::Toolkit::ClampState *arg5 = 0 ;
58379   float result;
58380
58381   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58382   arg2 = (float)jarg2;
58383   arg3 = (float)jarg3;
58384   arg4 = (float)jarg4;
58385   arg5 = (Dali::Toolkit::ClampState *)jarg5;
58386   if (!arg5) {
58387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
58388     return 0;
58389   }
58390   {
58391     try {
58392       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
58393     } CALL_CATCH_EXCEPTION(0);
58394   }
58395
58396   jresult = result;
58397   return jresult;
58398 }
58399
58400
58401 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
58402   float jresult ;
58403   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58404   float arg2 ;
58405   float arg3 ;
58406   float arg4 ;
58407   float arg5 ;
58408   float result;
58409
58410   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58411   arg2 = (float)jarg2;
58412   arg3 = (float)jarg3;
58413   arg4 = (float)jarg4;
58414   arg5 = (float)jarg5;
58415   {
58416     try {
58417       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
58418     } CALL_CATCH_EXCEPTION(0);
58419   }
58420
58421   jresult = result;
58422   return jresult;
58423 }
58424
58425
58426 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
58427   float jresult ;
58428   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58429   float arg2 ;
58430   float arg3 ;
58431   float arg4 ;
58432   float result;
58433
58434   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58435   arg2 = (float)jarg2;
58436   arg3 = (float)jarg3;
58437   arg4 = (float)jarg4;
58438   {
58439     try {
58440       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
58441     } CALL_CATCH_EXCEPTION(0);
58442   }
58443
58444   jresult = result;
58445   return jresult;
58446 }
58447
58448
58449 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
58450   float jresult ;
58451   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58452   float arg2 ;
58453   float arg3 ;
58454   float result;
58455
58456   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58457   arg2 = (float)jarg2;
58458   arg3 = (float)jarg3;
58459   {
58460     try {
58461       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
58462     } CALL_CATCH_EXCEPTION(0);
58463   }
58464
58465   jresult = result;
58466   return jresult;
58467 }
58468
58469
58470 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
58471   float jresult ;
58472   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58473   float arg2 ;
58474   float result;
58475
58476   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58477   arg2 = (float)jarg2;
58478   {
58479     try {
58480       result = (float)(*arg1)->SnapAndClamp(arg2);
58481     } CALL_CATCH_EXCEPTION(0);
58482   }
58483
58484   jresult = result;
58485   return jresult;
58486 }
58487
58488
58489 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
58490   float jresult ;
58491   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58492   float arg2 ;
58493   float arg3 ;
58494   float arg4 ;
58495   float arg5 ;
58496   Dali::Toolkit::ClampState *arg6 = 0 ;
58497   float result;
58498
58499   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58500   arg2 = (float)jarg2;
58501   arg3 = (float)jarg3;
58502   arg4 = (float)jarg4;
58503   arg5 = (float)jarg5;
58504   arg6 = (Dali::Toolkit::ClampState *)jarg6;
58505   if (!arg6) {
58506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
58507     return 0;
58508   }
58509   {
58510     try {
58511       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
58512     } CALL_CATCH_EXCEPTION(0);
58513   }
58514
58515   jresult = result;
58516   return jresult;
58517 }
58518
58519
58520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
58521   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58522
58523   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58524   {
58525     try {
58526       (*arg1)->Reference();
58527     } CALL_CATCH_EXCEPTION();
58528   }
58529
58530 }
58531
58532
58533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
58534   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58535
58536   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58537   {
58538     try {
58539       (*arg1)->Unreference();
58540     } CALL_CATCH_EXCEPTION();
58541   }
58542
58543 }
58544
58545
58546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
58547   int jresult ;
58548   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
58549   int result;
58550
58551   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
58552   {
58553     try {
58554       result = (int)(*arg1)->ReferenceCount();
58555     } CALL_CATCH_EXCEPTION(0);
58556   }
58557
58558   jresult = result;
58559   return jresult;
58560 }
58561
58562
58563 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
58564   bool jresult ;
58565   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
58566   bool result;
58567
58568   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
58569   {
58570     try {
58571       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
58572     } CALL_CATCH_EXCEPTION(0);
58573   }
58574
58575   jresult = result;
58576   return jresult;
58577 }
58578
58579
58580 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
58581   unsigned long jresult ;
58582   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
58583   std::size_t result;
58584
58585   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
58586   {
58587     try {
58588       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
58589     } CALL_CATCH_EXCEPTION(0);
58590   }
58591
58592   jresult = (unsigned long)result;
58593   return jresult;
58594 }
58595
58596
58597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
58598   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
58599   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
58600
58601   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
58602   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
58603   {
58604     try {
58605       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
58606     } CALL_CATCH_EXCEPTION();
58607   }
58608
58609 }
58610
58611
58612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
58613   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
58614   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
58615
58616   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
58617   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
58618   {
58619     try {
58620       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
58621     } CALL_CATCH_EXCEPTION();
58622   }
58623
58624 }
58625
58626
58627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
58628   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
58629   Dali::Toolkit::Control arg2 ;
58630   Dali::Toolkit::Control *argp2 ;
58631
58632   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
58633   argp2 = (Dali::Toolkit::Control *)jarg2;
58634   if (!argp2) {
58635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
58636     return ;
58637   }
58638   arg2 = *argp2;
58639   {
58640     try {
58641       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
58642     } CALL_CATCH_EXCEPTION();
58643   }
58644
58645 }
58646
58647
58648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
58649   void * jresult ;
58650   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
58651
58652   {
58653     try {
58654       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
58655     } CALL_CATCH_EXCEPTION(0);
58656   }
58657
58658   jresult = (void *)result;
58659   return jresult;
58660 }
58661
58662
58663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
58664   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
58665
58666   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
58667   {
58668     try {
58669       delete arg1;
58670     } CALL_CATCH_EXCEPTION();
58671   }
58672
58673 }
58674
58675 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
58676   Dali::RefObject *result = NULL;
58677
58678   if (arg1)
58679   {
58680     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
58681   }
58682   return result;
58683 }
58684
58685 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
58686     return (Dali::RefObject *)jarg1;
58687 }
58688
58689 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
58690     return (Dali::SignalObserver *)jarg1;
58691 }
58692
58693 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
58694     return (Dali::ConnectionTrackerInterface *)jarg1;
58695 }
58696
58697 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
58698     return (Dali::BaseHandle *)jarg1;
58699 }
58700
58701 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
58702     return (Dali::BaseHandle *)jarg1;
58703 }
58704
58705 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
58706     return (Dali::BaseHandle *)jarg1;
58707 }
58708
58709 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
58710     return (Dali::BaseHandle *)jarg1;
58711 }
58712
58713 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
58714     return (Dali::BaseHandle *)jarg1;
58715 }
58716
58717 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
58718     return (Dali::BaseHandle *)jarg1;
58719 }
58720
58721 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
58722     return (Dali::BaseHandle *)jarg1;
58723 }
58724
58725 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
58726     return (Dali::BaseHandle *)jarg1;
58727 }
58728
58729 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
58730     return (Dali::BaseHandle *)jarg1;
58731 }
58732
58733 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
58734     return (Dali::BaseHandle *)jarg1;
58735 }
58736
58737 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VertexBuffer_SWIGUpcast(Dali::VertexBuffer *jarg1) {
58738     return (Dali::BaseHandle *)jarg1;
58739 }
58740
58741 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
58742     return (Dali::BaseHandle *)jarg1;
58743 }
58744
58745 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
58746     return (Dali::Handle *)jarg1;
58747 }
58748
58749 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
58750     return (Dali::Handle *)jarg1;
58751 }
58752
58753 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
58754     return (Dali::BaseHandle *)jarg1;
58755 }
58756
58757 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
58758     return (Dali::BaseHandle *)jarg1;
58759 }
58760
58761 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
58762     return (Dali::Handle *)jarg1;
58763 }
58764
58765 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchEvent *jarg1) {
58766     return (Dali::BaseHandle *)jarg1;
58767 }
58768
58769 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Hover_SWIGUpcast(Dali::HoverEvent *jarg1) {
58770     return (Dali::BaseHandle *)jarg1;
58771 }
58772
58773 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Wheel_SWIGUpcast(Dali::WheelEvent *jarg1) {
58774     return (Dali::BaseHandle *)jarg1;
58775 }
58776
58777 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Key_SWIGUpcast(Dali::KeyEvent *jarg1) {
58778     return (Dali::BaseHandle *)jarg1;
58779 }
58780
58781 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Gesture_SWIGUpcast(Dali::Gesture *jarg1) {
58782     return (Dali::BaseHandle *)jarg1;
58783 }
58784
58785 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
58786     return (Dali::Handle *)jarg1;
58787 }
58788
58789 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
58790     return (Dali::GestureDetector *)jarg1;
58791 }
58792
58793 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
58794     return (Dali::Gesture *)jarg1;
58795 }
58796
58797 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
58798     return (Dali::Handle *)jarg1;
58799 }
58800
58801 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
58802     return (Dali::Actor *)jarg1;
58803 }
58804
58805 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
58806     return (Dali::RefObject *)jarg1;
58807 }
58808
58809 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
58810     return (Dali::Actor *)jarg1;
58811 }
58812
58813 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
58814     return (Dali::GestureDetector *)jarg1;
58815 }
58816
58817 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
58818     return (Dali::Gesture *)jarg1;
58819 }
58820
58821 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
58822     return (Dali::GestureDetector *)jarg1;
58823 }
58824
58825 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
58826     return (Dali::Gesture *)jarg1;
58827 }
58828
58829 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
58830     return (Dali::GestureDetector *)jarg1;
58831 }
58832
58833 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
58834     return (Dali::Gesture *)jarg1;
58835 }
58836
58837 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
58838     return (Dali::BaseHandle *)jarg1;
58839 }
58840
58841 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
58842     return (Dali::Handle *)jarg1;
58843 }
58844
58845 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
58846     return (Dali::Handle *)jarg1;
58847 }
58848
58849 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
58850     return (Dali::Handle *)jarg1;
58851 }
58852
58853 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
58854     return (Dali::RefObject *)jarg1;
58855 }
58856
58857 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
58858     return (Dali::Actor *)jarg1;
58859 }
58860
58861 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
58862     return (Dali::BaseHandle *)jarg1;
58863 }
58864
58865 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
58866     return (Dali::BaseHandle *)jarg1;
58867 }
58868
58869 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
58870     return (Dali::BaseHandle *)jarg1;
58871 }
58872
58873 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
58874     return (Dali::CustomActorImpl *)jarg1;
58875 }
58876
58877 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
58878     return (Dali::CustomActor *)jarg1;
58879 }
58880
58881 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
58882     return (Dali::BaseHandle *)jarg1;
58883 }
58884
58885 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
58886     return (Dali::Toolkit::Control *)jarg1;
58887 }
58888
58889 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
58890     return (Dali::Toolkit::Control *)jarg1;
58891 }
58892
58893 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
58894     return (Dali::Toolkit::Button *)jarg1;
58895 }
58896
58897 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
58898     return (Dali::Toolkit::Button *)jarg1;
58899 }
58900
58901 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
58902     return (Dali::Toolkit::Button *)jarg1;
58903 }
58904
58905 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
58906     return (Dali::Toolkit::Control *)jarg1;
58907 }
58908
58909 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
58910     return (Dali::Toolkit::Control *)jarg1;
58911 }
58912
58913 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
58914     return (Dali::Toolkit::Control *)jarg1;
58915 }
58916
58917 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
58918     return (Dali::Toolkit::Control *)jarg1;
58919 }
58920
58921 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
58922     return (Dali::Toolkit::Control *)jarg1;
58923 }
58924
58925 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
58926     return (Dali::RefObject *)jarg1;
58927 }
58928
58929 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
58930     return (Dali::Toolkit::Scrollable *)jarg1;
58931 }
58932
58933 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
58934     return (Dali::BaseHandle *)jarg1;
58935 }
58936
58937 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
58938     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
58939 }
58940
58941 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
58942     return (Dali::RefObject *)jarg1;
58943 }
58944
58945 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
58946     return (Dali::Toolkit::Ruler *)jarg1;
58947 }
58948
58949 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
58950     return (Dali::Toolkit::Ruler *)jarg1;
58951 }
58952
58953 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
58954     return (Dali::Toolkit::Scrollable *)jarg1;
58955 }
58956
58957 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
58958     return (Dali::Toolkit::Control *)jarg1;
58959 }
58960
58961
58962 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
58963     return (Dali::Toolkit::Control *)jarg1;
58964 }
58965
58966 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
58967     return (Dali::BaseHandle *)jarg1;
58968 }
58969
58970 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
58971     return (Dali::BaseHandle *)jarg1;
58972 }
58973
58974 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
58975     return (Dali::Toolkit::Control *)jarg1;
58976 }
58977
58978 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
58979     return (Dali::Toolkit::Control *)jarg1;
58980 }
58981
58982 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_CameraView_SWIGUpcast(Dali::Toolkit::CameraView *jarg1) {
58983     return (Dali::Toolkit::Control *)jarg1;
58984 }
58985
58986 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
58987     return (Dali::Toolkit::Control *)jarg1;
58988 }
58989
58990 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
58991     return (Dali::Toolkit::Control *)jarg1;
58992 }
58993
58994 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
58995     return (Dali::Toolkit::Control *)jarg1;
58996 }
58997
58998 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
58999     return (Dali::Toolkit::Control *)jarg1;
59000 }
59001
59002 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
59003     return (Dali::Toolkit::PageTurnView *)jarg1;
59004 }
59005
59006 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
59007     return (Dali::Toolkit::PageTurnView *)jarg1;
59008 }
59009
59010 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
59011     return (Dali::Toolkit::Button *)jarg1;
59012 }
59013
59014 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
59015     return (Dali::BaseHandle *)jarg1;
59016 }
59017
59018 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
59019     return (Dali::BaseHandle *)jarg1;
59020 }
59021
59022 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
59023     return (Dali::BaseHandle *)jarg1;
59024 }
59025
59026 /*
59027  * Widget binding
59028  */
59029 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
59030     return (Dali::BaseHandle *)jarg1;
59031 }
59032
59033 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
59034     return (Dali::BaseObject *)jarg1;
59035 }
59036
59037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
59038   void * jresult ;
59039   Dali::Widget result;
59040
59041   {
59042     try {
59043       result = Dali::Widget::New();
59044     } CALL_CATCH_EXCEPTION(0);
59045   }
59046
59047   jresult = new Dali::Widget((const Dali::Widget &)result);
59048   return jresult;
59049 }
59050
59051
59052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
59053   void * jresult ;
59054   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
59055   Dali::Widget result;
59056
59057   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59058
59059   if (!arg1) {
59060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
59061     return 0;
59062   }
59063   {
59064     try {
59065       jresult = new Dali::Widget(arg1);
59066     } CALL_CATCH_EXCEPTION(0);
59067   }
59068   return jresult;
59069 }
59070
59071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
59072   void * jresult ;
59073   Dali::Widget *result = 0 ;
59074
59075   {
59076     try {
59077       result = (Dali::Widget *)new Dali::Widget();
59078     } CALL_CATCH_EXCEPTION(0);
59079   }
59080   jresult = (void *)result;
59081   return jresult;
59082 }
59083
59084
59085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
59086   void * jresult ;
59087   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
59088   Dali::Widget *arg2 = 0 ;
59089   Dali::Widget *result = 0 ;
59090
59091   arg1 = (Dali::Widget *)jarg1;
59092   arg2 = (Dali::Widget *)jarg2;
59093   if (!arg2) {
59094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
59095     return 0;
59096   }
59097   {
59098     try {
59099       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
59100     } CALL_CATCH_EXCEPTION(0);
59101   }
59102   jresult = (void *)result;
59103   return jresult;
59104 }
59105
59106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
59107   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
59108
59109   arg1 = (Dali::Widget *)jarg1;
59110   {
59111     try {
59112       delete arg1;
59113     } CALL_CATCH_EXCEPTION();
59114   }
59115 }
59116
59117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
59118   void * jresult ;
59119   SwigDirector_WidgetImpl* result;
59120   {
59121     try {
59122       result = new SwigDirector_WidgetImpl();
59123     } CALL_CATCH_EXCEPTION(0);
59124   }
59125   jresult = result;
59126   return jresult;
59127 }
59128
59129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
59130   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59131   std::string *arg2 = 0 ;
59132   Dali::Window arg3 ;
59133   Dali::Window *argp3 ;
59134
59135   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59136   if (!jarg2) {
59137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59138     return ;
59139   }
59140   std::string arg2_str(jarg2);
59141   arg2 = &arg2_str;
59142   argp3 = (Dali::Window *)jarg3;
59143   if (!argp3) {
59144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
59145     return ;
59146   }
59147   arg3 = *argp3;
59148   {
59149     try {
59150       (arg1)->OnCreate((std::string const &)*arg2,arg3);
59151     } CALL_CATCH_EXCEPTION();
59152   }
59153 }
59154
59155
59156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
59157   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59158   std::string *arg2 = 0 ;
59159   Dali::Window arg3 ;
59160   Dali::Window *argp3 ;
59161
59162   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59163   if (!jarg2) {
59164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59165     return ;
59166   }
59167   std::string arg2_str(jarg2);
59168   arg2 = &arg2_str;
59169   argp3 = (Dali::Window *)jarg3;
59170   if (!argp3) {
59171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
59172     return ;
59173   }
59174   arg3 = *argp3;
59175   {
59176     try {
59177       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
59178     } CALL_CATCH_EXCEPTION();
59179   }
59180 }
59181
59182
59183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
59184   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59185   std::string *arg2 = 0 ;
59186   Dali::Widget::Termination arg3 ;
59187
59188   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59189   if (!jarg2) {
59190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59191     return ;
59192   }
59193   std::string arg2_str(jarg2);
59194   arg2 = &arg2_str;
59195   arg3 = (Dali::Widget::Termination)jarg3;
59196   {
59197     try {
59198       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
59199     } CALL_CATCH_EXCEPTION();
59200   }
59201 }
59202
59203
59204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
59205   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59206   std::string *arg2 = 0 ;
59207   Dali::Widget::Termination arg3 ;
59208
59209   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59210   if (!jarg2) {
59211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59212     return ;
59213   }
59214   std::string arg2_str(jarg2);
59215   arg2 = &arg2_str;
59216   arg3 = (Dali::Widget::Termination)jarg3;
59217   {
59218     try {
59219       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
59220     } CALL_CATCH_EXCEPTION();
59221   }
59222 }
59223
59224
59225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
59226   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59227
59228   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59229   {
59230     try {
59231       (arg1)->OnPause();
59232     } CALL_CATCH_EXCEPTION();
59233   }
59234 }
59235
59236
59237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
59238   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59239
59240   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59241   {
59242     try {
59243       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
59244     } CALL_CATCH_EXCEPTION();
59245   }
59246 }
59247
59248
59249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
59250   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59251
59252   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59253   {
59254     try {
59255       (arg1)->OnResume();
59256     } CALL_CATCH_EXCEPTION();
59257   }
59258 }
59259
59260
59261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
59262   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59263
59264   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59265   {
59266     try {
59267       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
59268     } CALL_CATCH_EXCEPTION();
59269   }
59270 }
59271
59272
59273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
59274   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59275   Dali::Window arg2 ;
59276   Dali::Window *argp2 ;
59277
59278   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59279   argp2 = (Dali::Window *)jarg2;
59280   if (!argp2) {
59281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
59282     return ;
59283   }
59284   arg2 = *argp2;
59285   {
59286     try {
59287       (arg1)->OnResize(arg2);
59288     } CALL_CATCH_EXCEPTION();
59289   }
59290 }
59291
59292
59293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
59294   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59295   Dali::Window arg2 ;
59296   Dali::Window *argp2 ;
59297
59298   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59299   argp2 = (Dali::Window *)jarg2;
59300   if (!argp2) {
59301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
59302     return ;
59303   }
59304   arg2 = *argp2;
59305   {
59306     try {
59307       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
59308     } CALL_CATCH_EXCEPTION();
59309   }
59310 }
59311
59312
59313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
59314   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59315   std::string *arg2 = 0 ;
59316   int arg3 ;
59317
59318   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59319   if (!jarg2) {
59320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59321     return ;
59322   }
59323   std::string arg2_str(jarg2);
59324   arg2 = &arg2_str;
59325   arg3 = (int)jarg3;
59326   {
59327     try {
59328       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
59329     } CALL_CATCH_EXCEPTION();
59330   }
59331 }
59332
59333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
59334   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59335   std::string *arg2 = 0 ;
59336   int arg3 ;
59337
59338   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59339   if (!jarg2) {
59340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59341     return ;
59342   }
59343   std::string arg2_str(jarg2);
59344   arg2 = &arg2_str;
59345   arg3 = (int)jarg3;
59346   {
59347     try {
59348       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
59349     } CALL_CATCH_EXCEPTION();
59350   }
59351 }
59352
59353
59354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
59355   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59356   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
59357   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
59358
59359   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59360   arg2 = (Dali::SlotObserver *)jarg2;
59361   arg3 = (Dali::CallbackBase *)jarg3;
59362   {
59363     try {
59364       (arg1)->SignalConnected(arg2,arg3);
59365     } CALL_CATCH_EXCEPTION();
59366   }
59367 }
59368
59369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
59370   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59371   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
59372   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
59373
59374   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59375   arg2 = (Dali::SlotObserver *)jarg2;
59376   arg3 = (Dali::CallbackBase *)jarg3;
59377   {
59378     try {
59379       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
59380     } CALL_CATCH_EXCEPTION();
59381   }
59382 }
59383
59384
59385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
59386   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59387   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
59388   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
59389
59390   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59391   arg2 = (Dali::SlotObserver *)jarg2;
59392   arg3 = (Dali::CallbackBase *)jarg3;
59393   {
59394     try {
59395       (arg1)->SignalDisconnected(arg2,arg3);
59396     } CALL_CATCH_EXCEPTION();
59397   }
59398 }
59399
59400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
59401   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59402   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
59403   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
59404
59405   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59406   arg2 = (Dali::SlotObserver *)jarg2;
59407   arg3 = (Dali::CallbackBase *)jarg3;
59408   {
59409     try {
59410       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
59411     } CALL_CATCH_EXCEPTION();
59412   }
59413 }
59414
59415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
59416   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59417   std::string *arg2 = 0 ;
59418
59419   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59420   if (!jarg2) {
59421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59422     return ;
59423   }
59424   std::string arg2_str(jarg2);
59425   arg2 = &arg2_str;
59426   {
59427     try {
59428       (arg1)->SetContentInfo((std::string const &)*arg2);
59429     } CALL_CATCH_EXCEPTION();
59430   }
59431 }
59432
59433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetUsingKeyEvent(void * jwidget, bool jflag) {
59434   Dali::Internal::Adaptor::Widget *widget = (Dali::Internal::Adaptor::Widget *) 0 ;
59435   bool flag;
59436
59437   widget = (Dali::Internal::Adaptor::Widget *)jwidget;
59438   flag = jflag ? true : false;
59439   {
59440     try {
59441       (widget)->SetUsingKeyEvent(flag);
59442     } CALL_CATCH_EXCEPTION();
59443   }
59444 }
59445
59446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
59447   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
59448   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
59449
59450   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
59451   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
59452   {
59453     try {
59454       (arg1)->SetImpl(arg2);
59455     } CALL_CATCH_EXCEPTION();
59456   }
59457 }
59458
59459
59460 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) {
59461   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
59462   if (director) {
59463     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
59464   }
59465 }
59466
59467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
59468   void * jresult ;
59469   Dali::Widget *arg1 = 0 ;
59470   SwigDirector_WidgetImpl *result = 0 ;
59471
59472   arg1 = (Dali::Widget *)jarg1;
59473   if (!arg1) {
59474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
59475     return 0;
59476   }
59477   {
59478     try {
59479       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
59480     } CALL_CATCH_EXCEPTION(0);
59481   }
59482   jresult = (void*) result;
59483   return jresult;
59484 }
59485
59486
59487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
59488   void * jresult ;
59489   int *arg1 = (int *) 0 ;
59490   char ***arg2 ;
59491   std::string *arg3 = 0 ;
59492   Dali::WidgetApplication result;
59493   {
59494     int index = 0;
59495     int length = 0;
59496     char *retPtr;
59497     char *nextPtr;
59498     argWidgetC = jarg1;
59499     argWidgetV = new char*[jarg1 + 1];
59500
59501     retPtr = strtok_r( jarg2, " ", &nextPtr);
59502     if( retPtr )
59503     {
59504       length = strlen(retPtr);
59505     }
59506     argWidgetV[index] = new char[length + 1];
59507     if( retPtr )
59508     {
59509       strncpy(argWidgetV[index], retPtr, length);
59510     }
59511     argWidgetV[index][length] = '\0';
59512     index++;
59513
59514     while (index < jarg1)
59515     {
59516       length = 0;
59517       retPtr = strtok_r(NULL, " ", &nextPtr);
59518       if( retPtr )
59519       {
59520         length = strlen(retPtr);
59521       }
59522       argWidgetV[index] = new char[length + 1];
59523       if( retPtr )
59524       {
59525         strncpy(argWidgetV[index], retPtr, length);
59526       }
59527       argWidgetV[index][length] = '\0';
59528       index++;
59529     }
59530
59531     argWidgetV[jarg1] = NULL;
59532     argWidgetC = jarg1;
59533
59534     arg1 = &argWidgetC;
59535     arg2 = &argWidgetV;
59536   }
59537
59538   if (!jarg3) {
59539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59540     return 0;
59541   }
59542   std::string arg3_str(jarg3);
59543   arg3 = &arg3_str;
59544   {
59545     try {
59546       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
59547     } CALL_CATCH_EXCEPTION(0);
59548   }
59549   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
59550   return jresult;
59551 }
59552
59553
59554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
59555   void * jresult ;
59556   Dali::WidgetApplication *result = 0 ;
59557
59558   {
59559     try {
59560       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
59561     } CALL_CATCH_EXCEPTION(0);
59562   }
59563   jresult = (void *)result;
59564   return jresult;
59565 }
59566
59567
59568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
59569   void * jresult ;
59570   Dali::WidgetApplication *arg1 = 0 ;
59571   Dali::WidgetApplication *result = 0 ;
59572
59573   arg1 = (Dali::WidgetApplication *)jarg1;
59574   if (!arg1) {
59575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
59576     return 0;
59577   }
59578   {
59579     try {
59580       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
59581     } CALL_CATCH_EXCEPTION(0);
59582   }
59583   jresult = (void *)result;
59584   return jresult;
59585 }
59586
59587
59588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
59589   void * jresult ;
59590   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
59591   Dali::WidgetApplication *arg2 = 0 ;
59592   Dali::WidgetApplication *result = 0 ;
59593
59594   arg1 = (Dali::WidgetApplication *)jarg1;
59595   arg2 = (Dali::WidgetApplication *)jarg2;
59596   if (!arg2) {
59597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
59598     return 0;
59599   }
59600   {
59601     try {
59602       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
59603     } CALL_CATCH_EXCEPTION(0);
59604   }
59605   jresult = (void *)result;
59606   return jresult;
59607 }
59608
59609
59610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
59611   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
59612
59613   arg1 = (Dali::WidgetApplication *)jarg1;
59614   {
59615     try {
59616       delete arg1;
59617       if( argWidgetV )
59618       {
59619         // free string data
59620         for( int i=0; i < argWidgetC+1; i++)
59621         {
59622           delete [] argWidgetV[i];
59623         }
59624         delete [] argWidgetV;
59625       }
59626     } CALL_CATCH_EXCEPTION();
59627   }
59628 }
59629
59630
59631 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
59632 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
59633
59634 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
59635 {
59636   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
59637   return *widget;
59638 }
59639
59640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
59641   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
59642   std::string *arg2 = 0 ;
59643
59644   arg1 = (Dali::WidgetApplication *)jarg1;
59645   if (!jarg2) {
59646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59647     return ;
59648   }
59649   std::string arg2_str(*jarg2);
59650   arg2 = &arg2_str;
59651
59652   if(!_CSharpCreateWidgetFunction)
59653   {
59654     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
59655   }
59656
59657   {
59658     try {
59659       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
59660     } CALL_CATCH_EXCEPTION();
59661   }
59662   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
59663 }
59664
59665
59666 //for PixelBuffer and ImageLoading
59667
59668 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
59669     return (Dali::BaseHandle *)jarg1;
59670 }
59671
59672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
59673   void * jresult ;
59674   unsigned int arg1 ;
59675   unsigned int arg2 ;
59676   Dali::Pixel::Format arg3 ;
59677   Dali::Devel::PixelBuffer result;
59678
59679   arg1 = (unsigned int)jarg1;
59680   arg2 = (unsigned int)jarg2;
59681   arg3 = (Dali::Pixel::Format)jarg3;
59682   {
59683     try {
59684       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
59685     } CALL_CATCH_EXCEPTION(0);
59686   }
59687   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59688   return jresult;
59689 }
59690
59691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
59692   void * jresult ;
59693   Dali::Devel::PixelBuffer *result = 0 ;
59694
59695   {
59696     try {
59697       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
59698     } CALL_CATCH_EXCEPTION(0);
59699   }
59700   jresult = (void *)result;
59701   return jresult;
59702 }
59703
59704
59705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
59706   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59707
59708   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59709   {
59710     try {
59711       delete arg1;
59712     } CALL_CATCH_EXCEPTION();
59713   }
59714 }
59715
59716
59717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
59718   void * jresult ;
59719   Dali::Devel::PixelBuffer *arg1 = 0 ;
59720   Dali::Devel::PixelBuffer *result = 0 ;
59721
59722   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59723   if (!arg1) {
59724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
59725     return 0;
59726   }
59727   {
59728     try {
59729       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
59730     } CALL_CATCH_EXCEPTION(0);
59731   }
59732   jresult = (void *)result;
59733   return jresult;
59734 }
59735
59736
59737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
59738   void * jresult ;
59739   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59740   Dali::Devel::PixelBuffer *arg2 = 0 ;
59741   Dali::Devel::PixelBuffer *result = 0 ;
59742
59743   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59744   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
59745   if (!arg2) {
59746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
59747     return 0;
59748   }
59749   {
59750     try {
59751       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
59752     } CALL_CATCH_EXCEPTION(0);
59753   }
59754   jresult = (void *)result;
59755   return jresult;
59756 }
59757
59758
59759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
59760   void * jresult ;
59761   Dali::Devel::PixelBuffer *arg1 = 0 ;
59762   Dali::PixelData result;
59763
59764   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59765   if (!arg1) {
59766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
59767     return 0;
59768   }
59769   {
59770     try {
59771       result = Dali::Devel::PixelBuffer::Convert(*arg1);
59772     } CALL_CATCH_EXCEPTION(0);
59773   }
59774   jresult = new Dali::PixelData((const Dali::PixelData &)result);
59775   return jresult;
59776 }
59777
59778
59779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
59780   void * jresult ;
59781   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59782   Dali::PixelData result;
59783
59784   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59785   {
59786     try {
59787       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
59788     } CALL_CATCH_EXCEPTION(0);
59789   }
59790   jresult = new Dali::PixelData((const Dali::PixelData &)result);
59791   return jresult;
59792 }
59793
59794
59795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
59796   void * jresult ;
59797   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59798   unsigned char *result = 0 ;
59799
59800   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59801   {
59802     try {
59803       result = (unsigned char *)(arg1)->GetBuffer();
59804     } CALL_CATCH_EXCEPTION(0);
59805   }
59806    jresult = (void *)result;
59807    return jresult;
59808 }
59809
59810 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
59811   unsigned int jresult ;
59812   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59813   unsigned int result;
59814
59815   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59816   {
59817     try {
59818       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
59819     } CALL_CATCH_EXCEPTION(0);
59820   }
59821   jresult = result;
59822   return jresult;
59823 }
59824
59825
59826 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
59827   unsigned int jresult ;
59828   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59829   unsigned int result;
59830
59831   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59832   {
59833     try {
59834       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
59835     } CALL_CATCH_EXCEPTION(0);
59836   }
59837   jresult = result;
59838   return jresult;
59839 }
59840
59841
59842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
59843   int jresult ;
59844   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59845   Dali::Pixel::Format result;
59846
59847   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59848   {
59849     try {
59850       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
59851     } CALL_CATCH_EXCEPTION(0);
59852   }
59853   jresult = (int)result;
59854   return jresult;
59855 }
59856
59857
59858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, bool jarg4) {
59859   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59860   Dali::Devel::PixelBuffer arg2 ;
59861   float arg3 ;
59862   bool arg4 ;
59863   Dali::Devel::PixelBuffer *argp2 ;
59864
59865   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59866   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
59867   if (!argp2) {
59868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
59869     return ;
59870   }
59871   arg2 = *argp2;
59872   arg3 = (float)jarg3;
59873   arg4 = jarg4 ? true : false;
59874   {
59875     try {
59876       (arg1)->ApplyMask(arg2,arg3,arg4);
59877     } CALL_CATCH_EXCEPTION();
59878   }
59879 }
59880
59881
59882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
59883   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59884   Dali::Devel::PixelBuffer arg2 ;
59885   float arg3 ;
59886   Dali::Devel::PixelBuffer *argp2 ;
59887
59888   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59889   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
59890   if (!argp2) {
59891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
59892     return ;
59893   }
59894   arg2 = *argp2;
59895   arg3 = (float)jarg3;
59896   {
59897     try {
59898       (arg1)->ApplyMask(arg2,arg3);
59899     } CALL_CATCH_EXCEPTION();
59900   }
59901 }
59902
59903
59904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
59905   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59906   Dali::Devel::PixelBuffer arg2 ;
59907   Dali::Devel::PixelBuffer *argp2 ;
59908
59909   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59910   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
59911   if (!argp2) {
59912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
59913     return ;
59914   }
59915   arg2 = *argp2;
59916   {
59917     try {
59918       (arg1)->ApplyMask(arg2);
59919     } CALL_CATCH_EXCEPTION();
59920   }
59921 }
59922
59923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
59924   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59925   float arg2 ;
59926
59927   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59928   arg2 = (float)jarg2;
59929   {
59930     try {
59931       (arg1)->ApplyGaussianBlur(arg2);
59932     } CALL_CATCH_EXCEPTION();
59933   }
59934 }
59935
59936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
59937   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59938   uint16_t arg2 ;
59939   uint16_t arg3 ;
59940   uint16_t arg4 ;
59941   uint16_t arg5 ;
59942
59943   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59944   arg2 = (uint16_t)jarg2;
59945   arg3 = (uint16_t)jarg3;
59946   arg4 = (uint16_t)jarg4;
59947   arg5 = (uint16_t)jarg5;
59948   {
59949     try {
59950       (arg1)->Crop(arg2,arg3,arg4,arg5);
59951     } CALL_CATCH_EXCEPTION();
59952   }
59953 }
59954
59955
59956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
59957   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59958   uint16_t arg2 ;
59959   uint16_t arg3 ;
59960
59961   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59962   arg2 = (uint16_t)jarg2;
59963   arg3 = (uint16_t)jarg3;
59964   {
59965     try {
59966       (arg1)->Resize(arg2,arg3);
59967     } CALL_CATCH_EXCEPTION();
59968   }
59969 }
59970
59971 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void* jarg2) {
59972   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59973   Dali::Degree * arg2 ;
59974
59975   bool result = false;
59976
59977   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59978   arg2 = (Dali::Degree *)jarg2;
59979   {
59980     try {
59981       result = (arg1)->Rotate(*arg2);
59982     } CALL_CATCH_EXCEPTION(false);
59983   }
59984   return result;
59985 }
59986
59987 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBrightness(void * jarg1) {
59988   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
59989   uint32_t result = 0;
59990
59991   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
59992   {
59993     try {
59994       result = (arg1)->GetBrightness();
59995     } CALL_CATCH_EXCEPTION(0);
59996   }
59997   return result;
59998 }
59999
60000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
60001   void * jresult ;
60002   std::string *arg1 = 0 ;
60003   Dali::ImageDimensions arg2 ;
60004   Dali::FittingMode::Type arg3 ;
60005   Dali::SamplingMode::Type arg4 ;
60006   bool arg5 ;
60007   Dali::ImageDimensions *argp2 ;
60008   Dali::Devel::PixelBuffer result;
60009
60010   if (!jarg1) {
60011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60012     return 0;
60013   }
60014   std::string arg1_str(jarg1);
60015   arg1 = &arg1_str;
60016   argp2 = (Dali::ImageDimensions *)jarg2;
60017   if (!argp2) {
60018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60019     return 0;
60020   }
60021   arg2 = *argp2;
60022   arg3 = (Dali::FittingMode::Type)jarg3;
60023   arg4 = (Dali::SamplingMode::Type)jarg4;
60024   arg5 = jarg5 ? true : false;
60025   {
60026     try {
60027       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
60028     } CALL_CATCH_EXCEPTION(0);
60029   }
60030   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60031   return jresult;
60032 }
60033
60034
60035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
60036   void * jresult ;
60037   std::string *arg1 = 0 ;
60038   Dali::ImageDimensions arg2 ;
60039   Dali::FittingMode::Type arg3 ;
60040   Dali::SamplingMode::Type arg4 ;
60041   Dali::ImageDimensions *argp2 ;
60042   Dali::Devel::PixelBuffer result;
60043
60044   if (!jarg1) {
60045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60046     return 0;
60047   }
60048   std::string arg1_str(jarg1);
60049   arg1 = &arg1_str;
60050   argp2 = (Dali::ImageDimensions *)jarg2;
60051   if (!argp2) {
60052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60053     return 0;
60054   }
60055   arg2 = *argp2;
60056   arg3 = (Dali::FittingMode::Type)jarg3;
60057   arg4 = (Dali::SamplingMode::Type)jarg4;
60058   {
60059     try {
60060       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
60061     } CALL_CATCH_EXCEPTION(0);
60062   }
60063   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60064   return jresult;
60065 }
60066
60067
60068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
60069   void * jresult ;
60070   std::string *arg1 = 0 ;
60071   Dali::ImageDimensions arg2 ;
60072   Dali::FittingMode::Type arg3 ;
60073   Dali::ImageDimensions *argp2 ;
60074   Dali::Devel::PixelBuffer result;
60075
60076   if (!jarg1) {
60077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60078     return 0;
60079   }
60080   std::string arg1_str(jarg1);
60081   arg1 = &arg1_str;
60082   argp2 = (Dali::ImageDimensions *)jarg2;
60083   if (!argp2) {
60084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60085     return 0;
60086   }
60087   arg2 = *argp2;
60088   arg3 = (Dali::FittingMode::Type)jarg3;
60089   {
60090     try {
60091       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
60092     } CALL_CATCH_EXCEPTION(0);
60093   }
60094   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60095   return jresult;
60096 }
60097
60098
60099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
60100   void * jresult ;
60101   std::string *arg1 = 0 ;
60102   Dali::ImageDimensions arg2 ;
60103   Dali::ImageDimensions *argp2 ;
60104   Dali::Devel::PixelBuffer result;
60105
60106   if (!jarg1) {
60107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60108     return 0;
60109   }
60110   std::string arg1_str(jarg1);
60111   arg1 = &arg1_str;
60112   argp2 = (Dali::ImageDimensions *)jarg2;
60113   if (!argp2) {
60114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60115     return 0;
60116   }
60117   arg2 = *argp2;
60118   {
60119     try {
60120       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
60121     } CALL_CATCH_EXCEPTION(0);
60122   }
60123   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60124   return jresult;
60125 }
60126
60127
60128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
60129   void * jresult ;
60130   std::string *arg1 = 0 ;
60131   Dali::Devel::PixelBuffer result;
60132
60133   if (!jarg1) {
60134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60135     return 0;
60136   }
60137   std::string arg1_str(jarg1);
60138   arg1 = &arg1_str;
60139   {
60140     try {
60141       result = Dali::LoadImageFromFile((std::string const &)*arg1);
60142     } CALL_CATCH_EXCEPTION(0);
60143   }
60144   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60145   return jresult;
60146 }
60147
60148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_0(void * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
60149   void * jresult ;
60150   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
60151   Dali::ImageDimensions arg2 ;
60152   Dali::FittingMode::Type arg3 ;
60153   Dali::SamplingMode::Type arg4 ;
60154   bool arg5 ;
60155   Dali::ImageDimensions *argp2 ;
60156   Dali::Devel::PixelBuffer result;
60157
60158   if (!jarg1) {
60159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
60160     return 0;
60161   }
60162   arg1 = (Dali::Vector<uint8_t> *)jarg1;
60163   argp2 = (Dali::ImageDimensions *)jarg2;
60164   if (!argp2) {
60165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60166     return 0;
60167   }
60168   arg2 = *argp2;
60169   arg3 = (Dali::FittingMode::Type)jarg3;
60170   arg4 = (Dali::SamplingMode::Type)jarg4;
60171   arg5 = jarg5 ? true : false;
60172   {
60173     try {
60174       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1, arg2, arg3, arg4, arg5);
60175     } CALL_CATCH_EXCEPTION(0);
60176   }
60177   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60178   return jresult;
60179 }
60180
60181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_1(void * jarg1, void * jarg2, int jarg3, int jarg4) {
60182   void * jresult ;
60183   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
60184   Dali::ImageDimensions arg2 ;
60185   Dali::FittingMode::Type arg3 ;
60186   Dali::SamplingMode::Type arg4 ;
60187   Dali::ImageDimensions *argp2 ;
60188   Dali::Devel::PixelBuffer result;
60189
60190   if (!jarg1) {
60191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
60192     return 0;
60193   }
60194   arg1 = (Dali::Vector<uint8_t> *)jarg1;
60195   argp2 = (Dali::ImageDimensions *)jarg2;
60196   if (!argp2) {
60197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60198     return 0;
60199   }
60200   arg2 = *argp2;
60201   arg3 = (Dali::FittingMode::Type)jarg3;
60202   arg4 = (Dali::SamplingMode::Type)jarg4;
60203   {
60204     try {
60205       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1, arg2, arg3, arg4);
60206     } CALL_CATCH_EXCEPTION(0);
60207   }
60208   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60209   return jresult;
60210 }
60211
60212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_2(void * jarg1, void * jarg2, int jarg3) {
60213   void * jresult ;
60214   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
60215   Dali::ImageDimensions arg2 ;
60216   Dali::FittingMode::Type arg3 ;
60217   Dali::ImageDimensions *argp2 ;
60218   Dali::Devel::PixelBuffer result;
60219
60220   if (!jarg1) {
60221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
60222     return 0;
60223   }
60224   arg1 = (Dali::Vector<uint8_t> *)jarg1;
60225   argp2 = (Dali::ImageDimensions *)jarg2;
60226   if (!argp2) {
60227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60228     return 0;
60229   }
60230   arg2 = *argp2;
60231   arg3 = (Dali::FittingMode::Type)jarg3;
60232   {
60233     try {
60234       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1, arg2, arg3);
60235     } CALL_CATCH_EXCEPTION(0);
60236   }
60237   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60238   return jresult;
60239 }
60240
60241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_3(void * jarg1, void * jarg2) {
60242   void * jresult ;
60243   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
60244   Dali::ImageDimensions arg2 ;
60245   Dali::ImageDimensions *argp2 ;
60246   Dali::Devel::PixelBuffer result;
60247
60248   if (!jarg1) {
60249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
60250     return 0;
60251   }
60252   arg1 = (Dali::Vector<uint8_t> *)jarg1;
60253   argp2 = (Dali::ImageDimensions *)jarg2;
60254   if (!argp2) {
60255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60256     return 0;
60257   }
60258   arg2 = *argp2;
60259   {
60260     try {
60261       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1, arg2);
60262     } CALL_CATCH_EXCEPTION(0);
60263   }
60264   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60265   return jresult;
60266 }
60267
60268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_4(void * jarg1) {
60269   void * jresult ;
60270   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
60271   Dali::Devel::PixelBuffer result;
60272
60273   if (!jarg1) {
60274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
60275     return 0;
60276   }
60277   arg1 = (Dali::Vector<uint8_t> *)jarg1;
60278   {
60279     try {
60280       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1);
60281     } CALL_CATCH_EXCEPTION(0);
60282   }
60283   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60284   return jresult;
60285 }
60286
60287
60288
60289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
60290   void * jresult ;
60291   std::string *arg1 = 0 ;
60292   Dali::ImageDimensions arg2 ;
60293   Dali::FittingMode::Type arg3 ;
60294   Dali::SamplingMode::Type arg4 ;
60295   bool arg5 ;
60296   Dali::ImageDimensions *argp2 ;
60297   Dali::ImageDimensions result;
60298
60299   if (!jarg1) {
60300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60301     return 0;
60302   }
60303   std::string arg1_str(jarg1);
60304   arg1 = &arg1_str;
60305   argp2 = (Dali::ImageDimensions *)jarg2;
60306   if (!argp2) {
60307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60308     return 0;
60309   }
60310   arg2 = *argp2;
60311   arg3 = (Dali::FittingMode::Type)jarg3;
60312   arg4 = (Dali::SamplingMode::Type)jarg4;
60313   arg5 = jarg5 ? true : false;
60314   {
60315     try {
60316       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
60317     } CALL_CATCH_EXCEPTION(0);
60318   }
60319   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
60320   return jresult;
60321 }
60322
60323
60324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
60325   void * jresult ;
60326   std::string *arg1 = 0 ;
60327   Dali::ImageDimensions arg2 ;
60328   Dali::FittingMode::Type arg3 ;
60329   Dali::SamplingMode::Type arg4 ;
60330   Dali::ImageDimensions *argp2 ;
60331   Dali::ImageDimensions result;
60332
60333   if (!jarg1) {
60334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60335     return 0;
60336   }
60337   std::string arg1_str(jarg1);
60338   arg1 = &arg1_str;
60339   argp2 = (Dali::ImageDimensions *)jarg2;
60340   if (!argp2) {
60341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60342     return 0;
60343   }
60344   arg2 = *argp2;
60345   arg3 = (Dali::FittingMode::Type)jarg3;
60346   arg4 = (Dali::SamplingMode::Type)jarg4;
60347   {
60348     try {
60349       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
60350     } CALL_CATCH_EXCEPTION(0);
60351   }
60352   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
60353   return jresult;
60354 }
60355
60356
60357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
60358   void * jresult ;
60359   std::string *arg1 = 0 ;
60360   Dali::ImageDimensions arg2 ;
60361   Dali::FittingMode::Type arg3 ;
60362   Dali::ImageDimensions *argp2 ;
60363   Dali::ImageDimensions result;
60364
60365   if (!jarg1) {
60366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60367     return 0;
60368   }
60369   std::string arg1_str(jarg1);
60370   arg1 = &arg1_str;
60371   argp2 = (Dali::ImageDimensions *)jarg2;
60372   if (!argp2) {
60373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60374     return 0;
60375   }
60376   arg2 = *argp2;
60377   arg3 = (Dali::FittingMode::Type)jarg3;
60378   {
60379     try {
60380       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
60381     } CALL_CATCH_EXCEPTION(0);
60382   }
60383   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
60384   return jresult;
60385 }
60386
60387
60388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
60389   void * jresult ;
60390   std::string *arg1 = 0 ;
60391   Dali::ImageDimensions arg2 ;
60392   Dali::ImageDimensions *argp2 ;
60393   Dali::ImageDimensions result;
60394
60395   if (!jarg1) {
60396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60397     return 0;
60398   }
60399   std::string arg1_str(jarg1);
60400   arg1 = &arg1_str;
60401   argp2 = (Dali::ImageDimensions *)jarg2;
60402   if (!argp2) {
60403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60404     return 0;
60405   }
60406   arg2 = *argp2;
60407   {
60408     try {
60409       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
60410     } CALL_CATCH_EXCEPTION(0);
60411   }
60412   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
60413   return jresult;
60414 }
60415
60416
60417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
60418   void * jresult ;
60419   std::string *arg1 = 0 ;
60420   Dali::ImageDimensions result;
60421
60422   if (!jarg1) {
60423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60424     return 0;
60425   }
60426   std::string arg1_str(jarg1);
60427   arg1 = &arg1_str;
60428   {
60429     try {
60430       result = Dali::GetClosestImageSize((std::string const &)*arg1);
60431     } CALL_CATCH_EXCEPTION(0);
60432   }
60433   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
60434   return jresult;
60435 }
60436
60437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1, bool jarg2) {
60438   void * jresult ;
60439   std::string *arg1 = 0 ;
60440   bool arg2 ;
60441   Dali::ImageDimensions result;
60442
60443   if (!jarg1) {
60444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60445     return 0;
60446   }
60447   std::string arg1_str(jarg1);
60448   arg1 = &arg1_str;
60449   arg2 = jarg2 ? true : false;
60450   {
60451     try {
60452       result = Dali::GetOriginalImageSize((std::string const &)*arg1,arg2);
60453     } CALL_CATCH_EXCEPTION(0);
60454   }
60455   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
60456   return jresult;
60457 }
60458
60459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
60460   void * jresult ;
60461   std::string *arg1 = 0 ;
60462   Dali::ImageDimensions arg2 ;
60463   Dali::FittingMode::Type arg3 ;
60464   Dali::SamplingMode::Type arg4 ;
60465   bool arg5 ;
60466   Dali::ImageDimensions *argp2 ;
60467   Dali::Devel::PixelBuffer result;
60468
60469   if (!jarg1) {
60470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60471     return 0;
60472   }
60473   std::string arg1_str(jarg1);
60474   arg1 = &arg1_str;
60475   argp2 = (Dali::ImageDimensions *)jarg2;
60476   if (!argp2) {
60477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60478     return 0;
60479   }
60480   arg2 = *argp2;
60481   arg3 = (Dali::FittingMode::Type)jarg3;
60482   arg4 = (Dali::SamplingMode::Type)jarg4;
60483   arg5 = jarg5 ? true : false;
60484   {
60485     try {
60486       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
60487     } CALL_CATCH_EXCEPTION(0);
60488   }
60489   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60490   return jresult;
60491 }
60492
60493
60494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
60495   void * jresult ;
60496   std::string *arg1 = 0 ;
60497   Dali::ImageDimensions arg2 ;
60498   Dali::FittingMode::Type arg3 ;
60499   Dali::SamplingMode::Type arg4 ;
60500   Dali::ImageDimensions *argp2 ;
60501   Dali::Devel::PixelBuffer result;
60502
60503   if (!jarg1) {
60504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60505     return 0;
60506   }
60507   std::string arg1_str(jarg1);
60508   arg1 = &arg1_str;
60509   argp2 = (Dali::ImageDimensions *)jarg2;
60510   if (!argp2) {
60511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60512     return 0;
60513   }
60514   arg2 = *argp2;
60515   arg3 = (Dali::FittingMode::Type)jarg3;
60516   arg4 = (Dali::SamplingMode::Type)jarg4;
60517   {
60518     try {
60519       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
60520     } CALL_CATCH_EXCEPTION(0);
60521   }
60522   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60523   return jresult;
60524 }
60525
60526
60527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
60528   void * jresult ;
60529   std::string *arg1 = 0 ;
60530   Dali::ImageDimensions arg2 ;
60531   Dali::FittingMode::Type arg3 ;
60532   Dali::ImageDimensions *argp2 ;
60533   Dali::Devel::PixelBuffer result;
60534
60535   if (!jarg1) {
60536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60537     return 0;
60538   }
60539   std::string arg1_str(jarg1);
60540   arg1 = &arg1_str;
60541   argp2 = (Dali::ImageDimensions *)jarg2;
60542   if (!argp2) {
60543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60544     return 0;
60545   }
60546   arg2 = *argp2;
60547   arg3 = (Dali::FittingMode::Type)jarg3;
60548   {
60549     try {
60550       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
60551     } CALL_CATCH_EXCEPTION(0);
60552   }
60553   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60554   return jresult;
60555 }
60556
60557
60558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
60559   void * jresult ;
60560   std::string *arg1 = 0 ;
60561   Dali::ImageDimensions arg2 ;
60562   Dali::ImageDimensions *argp2 ;
60563   Dali::Devel::PixelBuffer result;
60564
60565   if (!jarg1) {
60566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60567     return 0;
60568   }
60569   std::string arg1_str(jarg1);
60570   arg1 = &arg1_str;
60571   argp2 = (Dali::ImageDimensions *)jarg2;
60572   if (!argp2) {
60573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
60574     return 0;
60575   }
60576   arg2 = *argp2;
60577   {
60578     try {
60579       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
60580     } CALL_CATCH_EXCEPTION(0);
60581   }
60582   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60583   return jresult;
60584 }
60585
60586
60587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
60588   void * jresult ;
60589   std::string *arg1 = 0 ;
60590   Dali::Devel::PixelBuffer result;
60591
60592   if (!jarg1) {
60593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60594     return 0;
60595   }
60596   std::string arg1_str(jarg1);
60597   arg1 = &arg1_str;
60598   {
60599     try {
60600       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
60601     } CALL_CATCH_EXCEPTION(0);
60602   }
60603   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
60604   return jresult;
60605 }
60606
60607 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
60608   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
60609   char * jresult = SWIG_csharp_string_callback((const char *)result);
60610   return jresult;
60611 }
60612
60613 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
60614   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
60615   return result;
60616 }
60617
60618 struct NativeImageSourcePtrHandle
60619 {
60620   NativeImageSourcePtr Ptr;
60621 };
60622
60623 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
60624 {
60625   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
60626   return (NativeImageInterface*)(arg1);
60627 }
60628
60629 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
60630 {
60631   void* jresult;
60632   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
60633   {
60634     try {
60635       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
60636     }
60637     catch (std::out_of_range & e) {
60638       {
60639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60640       };
60641     }
60642     catch (std::exception & e) {
60643       {
60644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60645       };
60646     }
60647     catch (Dali::DaliException e) {
60648       {
60649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60650       };
60651     }
60652     catch (...) {
60653       {
60654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60655       };
60656     }
60657   }
60658   jresult = (void *)handle;
60659   return jresult;
60660 }
60661
60662 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
60663 {
60664   void* jresult;
60665   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
60666   jresult = (void*)( handle->Ptr.Get() );
60667   return jresult;
60668 }
60669
60670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
60671   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
60672   {
60673     try {
60674       delete arg1;
60675     }
60676     catch (std::out_of_range & e) {
60677       {
60678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
60679       };
60680     }
60681     catch (std::exception & e) {
60682       {
60683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
60684       };
60685     }
60686     catch (Dali::DaliException e) {
60687       {
60688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
60689       };
60690     }
60691     catch (...) {
60692       {
60693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
60694       };
60695     }
60696   }
60697 }
60698
60699 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
60700 {
60701   void* jresult;
60702   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
60703   uint16_t* arg2 = (uint16_t*)(jarg2);
60704   uint16_t* arg3 = (uint16_t*)(jarg3);
60705   uint16_t* arg4 = (uint16_t*)(jarg4);
60706   {
60707     try {
60708       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
60709     }
60710     catch (std::out_of_range & e) {
60711       {
60712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60713       };
60714     }
60715     catch (std::exception & e) {
60716       {
60717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60718       };
60719     }
60720     catch (Dali::DaliException e) {
60721       {
60722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60723       };
60724     }
60725     catch (...) {
60726       {
60727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60728       };
60729     }
60730   }
60731   return jresult;
60732 }
60733
60734 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
60735 {
60736   bool jresult;
60737   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
60738
60739   {
60740     try {
60741       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
60742     }
60743     catch (std::out_of_range & e) {
60744       {
60745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60746       };
60747     }
60748     catch (std::exception & e) {
60749       {
60750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60751       };
60752     }
60753     catch (Dali::DaliException e) {
60754       {
60755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60756       };
60757     }
60758     catch (...) {
60759       {
60760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60761       };
60762     }
60763   }
60764   return jresult;
60765 }
60766
60767 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_GenerateUrl(void* handle)
60768 {
60769   Dali::Toolkit::ImageUrl result;
60770   NativeImageSource* nativeImageSource = (NativeImageSource*)handle;
60771   void *jresult;
60772
60773   if (!nativeImageSource)
60774   {
60775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0);
60776     return 0;
60777   }
60778   {
60779     try
60780     {
60781       result = Dali::Toolkit::Image::GenerateUrl(nativeImageSource);
60782     }
60783     catch (std::out_of_range& e)
60784     {
60785       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
60786       return 0;
60787     }
60788     catch (std::exception& e)
60789     {
60790       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
60791       return 0;
60792     }
60793     catch (Dali::DaliException e)
60794     {
60795       SWIG_CSharpException(SWIG_UnknownError, e.condition);
60796       return 0;
60797     }
60798     catch (...)
60799     {
60800       SWIG_CSharpException(SWIG_UnknownError, "unknown error");
60801       return 0;
60802     }
60803   }
60804
60805   jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl &)result);
60806   return jresult;
60807 }
60808
60809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageUrl(void* jarg1)
60810 {
60811   Dali::Toolkit::ImageUrl* imageUrl = (Dali::Toolkit::ImageUrl*) 0;
60812
60813   imageUrl = (Dali::Toolkit::ImageUrl*)jarg1;
60814   {
60815     try
60816     {
60817       delete imageUrl;
60818     }
60819     catch (std::out_of_range& e)
60820     {
60821       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
60822       return;
60823     }
60824     catch (std::exception& e)
60825     {
60826       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
60827       return;
60828     }
60829     catch (Dali::DaliException e)
60830     {
60831       SWIG_CSharpException(SWIG_UnknownError, e.condition);
60832       return;
60833     }
60834     catch (...)
60835     {
60836       SWIG_CSharpException(SWIG_UnknownError, "unknown error");
60837       return;
60838     }
60839   }
60840 }
60841
60842 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImageUrl_Get(void* jarg1)
60843 {
60844   char *jresult;
60845   Dali::Toolkit::ImageUrl* imageUrl = (Dali::Toolkit::ImageUrl*) 0;
60846   std::string result;
60847
60848   imageUrl = (Dali::Toolkit::ImageUrl*)jarg1;
60849   {
60850     try
60851     {
60852       result = imageUrl->GetUrl();
60853     }
60854     catch (std::out_of_range& e)
60855     {
60856       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
60857       return 0;
60858     }
60859     catch (std::exception& e)
60860     {
60861       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
60862       return 0;
60863     }
60864     catch (Dali::DaliException e)
60865     {
60866       SWIG_CSharpException(SWIG_UnknownError, e.condition);
60867       return 0;
60868     }
60869     catch (...)
60870     {
60871       SWIG_CSharpException(SWIG_UnknownError, "unknown error");
60872       return 0;
60873     }
60874   }
60875
60876   jresult = SWIG_csharp_string_callback((&result)->c_str());
60877   return jresult;
60878 }
60879
60880 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetSuggestedMinimumWidth(void * jarg1) {
60881   Dali::Actor *arg1 = (Dali::Actor *) 0;
60882   Dali::Vector2 maximumSize;
60883   Dali::Vector2 minimumSize;
60884   Dali::Vector3 naturalSize;
60885   bool widthForHeight;
60886   float result;
60887   {
60888     try {
60889       arg1 = (Dali::Actor *)jarg1;
60890       maximumSize = arg1->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
60891       minimumSize = arg1->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
60892       naturalSize = arg1->GetNaturalSize();
60893       widthForHeight = arg1->GetProperty< bool >( Actor::Property::WIDTH_FOR_HEIGHT );
60894
60895       float baseWidth;
60896       if (widthForHeight)
60897       {
60898         float baseHeight = maximumSize.height > 0 ? std::min(maximumSize.height, naturalSize.height) : naturalSize.height;
60899         baseWidth = arg1->GetWidthForHeight(baseHeight);
60900       }
60901       else
60902       {
60903         baseWidth = naturalSize.width;
60904       }
60905
60906       result = minimumSize.width > 0 ? std::max(baseWidth, minimumSize.width) : baseWidth;
60907       result = maximumSize.width > 0 ? std::min(result, maximumSize.width) : result;
60908     } CALL_CATCH_EXCEPTION(0);
60909   }
60910
60911   return result;
60912 }
60913
60914 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetSuggestedMinimumHeight(void * jarg1) {
60915   Dali::Actor *arg1 = (Dali::Actor *) 0;
60916   Dali::Vector2 maximumSize;
60917   Dali::Vector2 minimumSize;
60918   Dali::Vector3 naturalSize;
60919   bool heightForWidth;
60920   float result;
60921   {
60922     try {
60923       arg1 = (Dali::Actor *)jarg1;
60924       maximumSize = arg1->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
60925       minimumSize = arg1->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
60926       naturalSize = arg1->GetNaturalSize();
60927       heightForWidth = arg1->GetProperty< bool >( Actor::Property::HEIGHT_FOR_WIDTH );
60928
60929       float baseHeight;
60930       if (heightForWidth)
60931       {
60932         float baseWidth = maximumSize.width > 0 ? std::min(maximumSize.width, naturalSize.width) : naturalSize.width;
60933         baseHeight = arg1->GetHeightForWidth(baseWidth);
60934       }
60935       else
60936       {
60937         baseHeight = naturalSize.height;
60938       }
60939
60940       result = minimumSize.height > 0 ? std::max(baseHeight, minimumSize.height) : baseHeight;
60941       result = maximumSize.height > 0 ? std::min(result, maximumSize.height) : result;
60942     } CALL_CATCH_EXCEPTION(0);
60943   }
60944
60945   return result;
60946 }
60947
60948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorVector2_BaseType_get() {
60949   int jresult ;
60950   int result;
60951
60952   result = (int)Dali::Vector< Dali::Vector2 >::BaseType;
60953   jresult = (int)result;
60954   return jresult;
60955 }
60956
60957
60958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorVector2__SWIG_0() {
60959   void * jresult ;
60960   Dali::Vector< Dali::Vector2 > *result = 0 ;
60961
60962   {
60963     try {
60964       result = (Dali::Vector< Dali::Vector2 > *)new Dali::Vector< Dali::Vector2 >();
60965     } CALL_CATCH_EXCEPTION(0);
60966   }
60967
60968   jresult = (void *)result;
60969   return jresult;
60970 }
60971
60972
60973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorVector2(void * jarg1) {
60974   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
60975
60976   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60977   {
60978     try {
60979       delete arg1;
60980     } CALL_CATCH_EXCEPTION();
60981   }
60982 }
60983
60984
60985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorVector2__SWIG_1(void * jarg1) {
60986   void * jresult ;
60987   Dali::Vector< Dali::Vector2 > *arg1 = 0 ;
60988   Dali::Vector< Dali::Vector2 > *result = 0 ;
60989
60990   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
60991   if (!arg1) {
60992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 > const & type is null", 0);
60993     return 0;
60994   }
60995   {
60996     try {
60997       result = (Dali::Vector< Dali::Vector2 > *)new Dali::Vector< Dali::Vector2 >((Dali::Vector< Dali::Vector2 > const &)*arg1);
60998     } CALL_CATCH_EXCEPTION(0);
60999   }
61000
61001   jresult = (void *)result;
61002   return jresult;
61003 }
61004
61005
61006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Assign(void * jarg1, void * jarg2) {
61007   void * jresult ;
61008   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61009   Dali::Vector< Dali::Vector2 > *arg2 = 0 ;
61010   Dali::Vector< Dali::Vector2 > *result = 0 ;
61011
61012   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61013   arg2 = (Dali::Vector< Dali::Vector2 > *)jarg2;
61014   if (!arg2) {
61015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 > const & type is null", 0);
61016     return 0;
61017   }
61018   {
61019     try {
61020       result = (Dali::Vector< Dali::Vector2 > *) &(arg1)->operator =((Dali::Vector< Dali::Vector2 > const &)*arg2);
61021     } CALL_CATCH_EXCEPTION(0);
61022   }
61023
61024   jresult = (void *)result;
61025   return jresult;
61026 }
61027
61028
61029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Begin(void * jarg1) {
61030   void * jresult ;
61031   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61032   Dali::Vector< Dali::Vector2 >::Iterator result;
61033
61034   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61035   {
61036     try {
61037       result = (Dali::Vector< Dali::Vector2 >::Iterator)((Dali::Vector< Dali::Vector2 > const *)arg1)->Begin();
61038     } CALL_CATCH_EXCEPTION(0);
61039   }
61040
61041   jresult = (void *)result;
61042   return jresult;
61043 }
61044
61045
61046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_End(void * jarg1) {
61047   void * jresult ;
61048   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61049   Dali::Vector< Dali::Vector2 >::Iterator result;
61050
61051   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61052   {
61053     try {
61054       result = (Dali::Vector< Dali::Vector2 >::Iterator)((Dali::Vector< Dali::Vector2 > const *)arg1)->End();
61055     } CALL_CATCH_EXCEPTION(0);
61056   }
61057
61058   jresult = (void *)result;
61059   return jresult;
61060 }
61061
61062
61063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
61064   void * jresult ;
61065   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61066   Dali::Vector< Dali::Vector2 >::SizeType arg2 ;
61067   Dali::Vector< Dali::Vector2 >::ItemType *result = 0 ;
61068
61069   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61070   arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2;
61071   {
61072     try {
61073       result = (Dali::Vector< Dali::Vector2 >::ItemType *) &(arg1)->operator [](arg2);
61074     } CALL_CATCH_EXCEPTION(0);
61075   }
61076
61077   jresult = (void *)result;
61078   return jresult;
61079 }
61080
61081
61082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_PushBack(void * jarg1, void * jarg2) {
61083   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61084   Dali::Vector< Dali::Vector2 >::ItemType *arg2 = 0 ;
61085
61086   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61087   arg2 = (Dali::Vector< Dali::Vector2 >::ItemType *)jarg2;
61088   if (!arg2) {
61089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 >::ItemType const & type is null", 0);
61090     return ;
61091   }
61092   {
61093     try {
61094       (arg1)->PushBack((Dali::Vector< Dali::Vector2 >::ItemType const &)*arg2);
61095     } CALL_CATCH_EXCEPTION();
61096   }
61097 }
61098
61099
61100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
61101   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61102   Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
61103   Dali::Vector< Dali::Vector2 >::ItemType *arg3 = 0 ;
61104
61105   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61106   arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2;
61107   arg3 = (Dali::Vector< Dali::Vector2 >::ItemType *)jarg3;
61108   if (!arg3) {
61109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 >::ItemType const & type is null", 0);
61110     return ;
61111   }
61112   {
61113     try {
61114       (arg1)->Insert(arg2,(Dali::Vector< Dali::Vector2 >::ItemType const &)*arg3);
61115     } CALL_CATCH_EXCEPTION();
61116   }
61117 }
61118
61119
61120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
61121   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61122   Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
61123   Dali::Vector< Dali::Vector2 >::Iterator arg3 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
61124   Dali::Vector< Dali::Vector2 >::Iterator arg4 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
61125
61126   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61127   arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2;
61128   arg3 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg3;
61129   arg4 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg4;
61130   {
61131     try {
61132       (arg1)->Insert(arg2,arg3,arg4);
61133     } CALL_CATCH_EXCEPTION();
61134   }
61135 }
61136
61137
61138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Reserve(void * jarg1, unsigned long jarg2) {
61139   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61140   Dali::Vector< Dali::Vector2 >::SizeType arg2 ;
61141
61142   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61143   arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2;
61144   {
61145     try {
61146       (arg1)->Reserve(arg2);
61147     } CALL_CATCH_EXCEPTION();
61148   }
61149 }
61150
61151
61152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
61153   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61154   Dali::Vector< Dali::Vector2 >::SizeType arg2 ;
61155
61156   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61157   arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2;
61158   {
61159     try {
61160       (arg1)->Resize(arg2);
61161     } CALL_CATCH_EXCEPTION();
61162   }
61163 }
61164
61165
61166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
61167   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61168   Dali::Vector< Dali::Vector2 >::SizeType arg2 ;
61169   Dali::Vector< Dali::Vector2 >::ItemType *arg3 = 0 ;
61170
61171   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61172   arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2;
61173   arg3 = (Dali::Vector< Dali::Vector2 >::ItemType *)jarg3;
61174   if (!arg3) {
61175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
61176     return ;
61177   }
61178   {
61179     try {
61180       (arg1)->Resize(arg2,(Dali::Vector< Dali::Vector2 >::ItemType const &)*arg3);
61181     } CALL_CATCH_EXCEPTION();
61182   }
61183 }
61184
61185
61186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Erase__SWIG_0(void * jarg1, void * jarg2) {
61187   void * jresult ;
61188   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61189   Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
61190   Dali::Vector< Dali::Vector2 >::Iterator result;
61191
61192   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61193   arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2;
61194   {
61195     try {
61196       result = (Dali::Vector< Dali::Vector2 >::Iterator)(arg1)->Erase(arg2);
61197     } CALL_CATCH_EXCEPTION(0);
61198   }
61199
61200   jresult = (void *)result;
61201   return jresult;
61202 }
61203
61204
61205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
61206   void * jresult ;
61207   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61208   Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
61209   Dali::Vector< Dali::Vector2 >::Iterator arg3 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
61210   Dali::Vector< Dali::Vector2 >::Iterator result;
61211
61212   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61213   arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2;
61214   arg3 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg3;
61215   {
61216     try {
61217       result = (Dali::Vector< Dali::Vector2 >::Iterator)(arg1)->Erase(arg2,arg3);
61218     } CALL_CATCH_EXCEPTION(0);
61219   }
61220
61221   jresult = (void *)result;
61222   return jresult;
61223 }
61224
61225
61226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Remove(void * jarg1, void * jarg2) {
61227   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61228   Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
61229
61230   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61231   arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2;
61232   {
61233     try {
61234       (arg1)->Remove(arg2);
61235     } CALL_CATCH_EXCEPTION();
61236   }
61237 }
61238
61239
61240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Swap(void * jarg1, void * jarg2) {
61241   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61242   Dali::Vector< Dali::Vector2 > *arg2 = 0 ;
61243
61244   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61245   arg2 = (Dali::Vector< Dali::Vector2 > *)jarg2;
61246   if (!arg2) {
61247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 > & type is null", 0);
61248     return ;
61249   }
61250   {
61251     try {
61252       (arg1)->Swap(*arg2);
61253     } CALL_CATCH_EXCEPTION();
61254   }
61255 }
61256
61257
61258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Clear(void * jarg1) {
61259   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61260
61261   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61262   {
61263     try {
61264       (arg1)->Clear();
61265     } CALL_CATCH_EXCEPTION();
61266   }
61267 }
61268
61269
61270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Release(void * jarg1) {
61271   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61272
61273   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61274   {
61275     try {
61276       (arg1)->Release();
61277     } CALL_CATCH_EXCEPTION();
61278   }
61279 }
61280
61281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorVector2_Size(void * jarg1) {
61282   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
61283   int size;
61284
61285   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
61286   {
61287     try {
61288       size = (arg1)->Size();
61289     } CALL_CATCH_EXCEPTION(0);
61290   }
61291
61292   return size;
61293 }
61294
61295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetScreenSize() {
61296   void * jresult ;
61297   int width, height;
61298
61299   try {
61300     Dali::DevelWindowSystem::GetScreenSize(width, height);
61301   } CALL_CATCH_EXCEPTION(0);
61302
61303   jresult = new Dali::Size(width, height);
61304   return jresult;
61305 }
61306
61307 #ifdef __cplusplus
61308 }
61309 #endif