dali-csharp-binder/common/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 // EXTERNAL INCLUDES
 143 #include <algorithm>
 144 #include <exception>
 145 #include <map>
 146 #include <stdlib.h>
 147 #include <stdio.h>
 148 #include <string.h>
 149 #include <string_view>
 150 #include <string>
 151 #include <stdexcept>
 152 #include <utility>
 153 #include <vector>
 154
 155
 156 // INTERNAL INCLUDES
 157 #include "common.h"
 158
 159 #include <time.h>
 160
 161 #include <dali/dali.h>
 162 #include <dali-toolkit/dali-toolkit.h>
 163
 164 #include <dali/integration-api/debug.h>
 165
 166 #include <dali/devel-api/actors/actor-devel.h>
 167 #include <dali/devel-api/actors/camera-actor-devel.h>
 168 #include <dali/devel-api/animation/key-frames-devel.h>
 169 #include <dali/devel-api/animation/path-constrainer.h>
 170 #include <dali/devel-api/common/stage-devel.h>
 171 #include <dali/devel-api/events/key-event-devel.h>
 172 #include <dali/devel-api/events/wheel-event-devel.h>
 173 #include <dali/devel-api/events/hover-event-devel.h>
 174 #include <dali/devel-api/events/touch-point.h>
 175 #include <dali/devel-api/events/pan-gesture-devel.h>
 176 #include <dali/devel-api/events/pinch-gesture-devel.h>
 177 #include <dali/devel-api/events/long-press-gesture-devel.h>
 178 #include <dali/devel-api/events/tap-gesture-devel.h>
 179 #include <dali/devel-api/object/csharp-type-info.h>
 180 #include <dali/devel-api/object/csharp-type-registry.h>
 181 #include <dali/devel-api/update/frame-callback-interface.h>
 182 #include <dali/devel-api/update/update-proxy.h>
 183
 184 #include <dali/public-api/events/mouse-button.h>
 185 #include <dali/public-api/math/matrix.h>
 186 #include <dali/public-api/math/matrix3.h>
 187 #include <dali/public-api/math/viewport.h>
 188 #include <dali/public-api/object/property-key.h>
 189
 190 #include <dali/public-api/adaptor-framework/style-change.h>
 191 #include <dali/devel-api/adaptor-framework/environment-variable.h>
 192
 193 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 194
 195
 196 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 197   { SWIG_CSharpApplicationException, NULL },
 198   { SWIG_CSharpArithmeticException, NULL },
 199   { SWIG_CSharpDivideByZeroException, NULL },
 200   { SWIG_CSharpIndexOutOfRangeException, NULL },
 201   { SWIG_CSharpInvalidCastException, NULL },
 202   { SWIG_CSharpInvalidOperationException, NULL },
 203   { SWIG_CSharpIOException, NULL },
 204   { SWIG_CSharpNullReferenceException, NULL },
 205   { SWIG_CSharpOutOfMemoryException, NULL },
 206   { SWIG_CSharpOverflowException, NULL },
 207   { SWIG_CSharpSystemException, NULL }
 208 };
 209
 210 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 211   { SWIG_CSharpArgumentException, NULL },
 212   { SWIG_CSharpArgumentNullException, NULL },
 213   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 214 };
 215
 216 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 217   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 218   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 219     callback = SWIG_csharp_exceptions[code].callback;
 220   }
 221   callback(msg);
 222 }
 223
 224 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 225   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 226   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 227     callback = SWIG_csharp_exceptions_argument[code].callback;
 228   }
 229   callback(msg, param_name);
 230 }
 231
 232
 233 #ifdef __cplusplus
 234 extern "C"
 235 #endif
 236 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 237                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 238                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 239                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 240                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 241                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 242                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 243                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 244                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 245                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 246                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 247                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 248   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 249   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 250   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 251   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 252   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 253   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 254   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 255   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 256   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 257   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 258   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 259 }
 260
 261 #ifdef __cplusplus
 262 extern "C"
 263 #endif
 264 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 265                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 266                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 267                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 268   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 269   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 270   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 271 }
 272
 273
 274 /* Callback for returning strings to C# without leaking memory */
 275 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 276 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 277
 278
 279 #ifdef __cplusplus
 280 extern "C"
 281 #endif
 282 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 283   SWIG_csharp_string_callback = callback;
 284 }
 285
 286
 287 /* Contract support */
 288 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 289
 290
 291 /* -----------------------------------------------------------------------------
 292  * director_common.swg
 293  *
 294  * This file contains support for director classes which is common between
 295  * languages.
 296  * ----------------------------------------------------------------------------- */
 297
 298 /*
 299   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 300   'Swig' namespace. This could be useful for multi-modules projects.
 301 */
 302 #ifdef SWIG_DIRECTOR_STATIC
 303 /* Force anonymous (static) namespace */
 304 #define Swig
 305 #endif
 306 /* -----------------------------------------------------------------------------
 307  * director.swg
 308  *
 309  * This file contains support for director classes so that C# proxy
 310  * methods can be called from C++.
 311  * ----------------------------------------------------------------------------- */
 312
 313 #if defined(DEBUG_DIRECTOR_OWNED)
 314 #include <iostream>
 315 #endif
 316
 317 namespace Swig {
 318   /* Director base class - not currently used in C# directors */
 319   class Director {
 320   };
 321
 322   /* Base class for director exceptions */
 323   class DirectorException : public std::exception {
 324   protected:
 325     std::string swig_msg;
 326
 327   public:
 328     DirectorException(const char *msg) : swig_msg(msg) {
 329     }
 330
 331     DirectorException(const std::string &msg) : swig_msg(msg) {
 332     }
 333
 334     virtual ~DirectorException() throw() {
 335     }
 336
 337     const char *what() const throw() {
 338       return swig_msg.c_str();
 339     }
 340   };
 341
 342   /* Pure virtual method exception */
 343   class DirectorPureVirtualException : public DirectorException {
 344   public:
 345     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 346     }
 347   };
 348 }
 349
 350
 351 void SWIG_CSharpException(int code, const char *msg) {
 352   if (code == SWIG_ValueError) {
 353     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 354     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 355   } else {
 356     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 357     switch(code) {
 358     case SWIG_MemoryError:
 359       exception_code = SWIG_CSharpOutOfMemoryException;
 360       break;
 361     case SWIG_IndexError:
 362       exception_code = SWIG_CSharpIndexOutOfRangeException;
 363       break;
 364     case SWIG_DivisionByZero:
 365       exception_code = SWIG_CSharpDivideByZeroException;
 366       break;
 367     case SWIG_IOError:
 368       exception_code = SWIG_CSharpIOException;
 369       break;
 370     case SWIG_OverflowError:
 371       exception_code = SWIG_CSharpOverflowException;
 372       break;
 373     case SWIG_RuntimeError:
 374     case SWIG_TypeError:
 375     case SWIG_SyntaxError:
 376     case SWIG_SystemError:
 377     case SWIG_UnknownError:
 378     default:
 379       exception_code = SWIG_CSharpApplicationException;
 380       break;
 381     }
 382     SWIG_CSharpSetPendingException(exception_code, msg);
 383   }
 384 }
 385
 386
 387 #define SWIGSTDCALL
 388
 389 // add here SWIG version check
 390
 391 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 392 // disable Swig-dependent warnings
 393
 394 // 'identifier1' has C-linkage specified,
 395 // but returns UDT 'identifier2' which is incompatible with C
 396 #pragma warning(disable: 4190)
 397
 398 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 399 #pragma warning(disable: 4800)
 400
 401 // debug info too long etc etc
 402 #pragma warning(disable: 4786)
 403 #endif
 404
 405 typedef float floatp;
 406
 407 SWIGINTERN floatp *new_floatp(){
 408   return new float();
 409 }
 410 SWIGINTERN void delete_floatp(floatp *self){
 411   if (self) delete self;
 412 }
 413 SWIGINTERN void floatp_assign(floatp *self,float value){
 414   *self = value;
 415 }
 416 SWIGINTERN float floatp_value(floatp *self){
 417   return *self;
 418 }
 419 SWIGINTERN float *floatp_cast(floatp *self){
 420   return self;
 421 }
 422 SWIGINTERN floatp *floatp_frompointer(float *t){
 423   return (floatp *) t;
 424 }
 425
 426 typedef int intp;
 427
 428 SWIGINTERN intp *new_intp(){
 429   return new int();
 430 }
 431 SWIGINTERN void delete_intp(intp *self){
 432   if (self) delete self;
 433 }
 434 SWIGINTERN void intp_assign(intp *self,int value){
 435   *self = value;
 436 }
 437 SWIGINTERN int intp_value(intp *self){
 438   return *self;
 439 }
 440 SWIGINTERN int *intp_cast(intp *self){
 441   return self;
 442 }
 443 SWIGINTERN intp *intp_frompointer(int *t){
 444   return (intp *) t;
 445 }
 446
 447 typedef double doublep;
 448
 449 SWIGINTERN doublep *new_doublep(){
 450   return new double();
 451 }
 452 SWIGINTERN void delete_doublep(doublep *self){
 453   if (self) delete self;
 454 }
 455 SWIGINTERN void doublep_assign(doublep *self,double value){
 456   *self = value;
 457 }
 458 SWIGINTERN double doublep_value(doublep *self){
 459   return *self;
 460 }
 461 SWIGINTERN double *doublep_cast(doublep *self){
 462   return self;
 463 }
 464 SWIGINTERN doublep *doublep_frompointer(double *t){
 465   return (doublep *) t;
 466 }
 467
 468 typedef unsigned int uintp;
 469
 470 SWIGINTERN uintp *new_uintp(){
 471   return new unsigned int();
 472 }
 473 SWIGINTERN void delete_uintp(uintp *self){
 474   if (self) delete self;
 475 }
 476 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 477   *self = value;
 478 }
 479 SWIGINTERN unsigned int uintp_value(uintp *self){
 480   return *self;
 481 }
 482 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 483   return self;
 484 }
 485 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 486   return (uintp *) t;
 487 }
 488
 489 typedef unsigned short ushortp;
 490
 491 SWIGINTERN ushortp *new_ushortp(){
 492   return new unsigned short();
 493 }
 494 SWIGINTERN void delete_ushortp(ushortp *self){
 495   if (self) delete self;
 496 }
 497 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 498   *self = value;
 499 }
 500 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 501   return *self;
 502 }
 503 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 504   return self;
 505 }
 506 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 507   return (ushortp *) t;
 508 }
 509
 510 unsigned int int_to_uint(int x) {
 511    return (unsigned int) x;
 512 }
 513
 514
 515 using namespace Dali;
 516 using namespace Dali::Toolkit;
 517
 518 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 519 {
 520   bool result = false;
 521   try
 522   {
 523     // C++ code. DALi uses Handle <-> Body design pattern.
 524     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 525     // Handles in DALi can be converted into a boolean type
 526     // to check if the handle has a valid body attached to it.
 527     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 528     if( *self )
 529     {
 530       result = true;
 531     }
 532     else
 533     {
 534       result = false;
 535     }
 536   }
 537   CALL_CATCH_EXCEPTION(false);
 538   return result;
 539 }
 540
 541 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 542 {
 543   bool result = false;
 544   try
 545   {
 546     // C++ code. Check if two handles reference the same implemtion
 547     if( *self == rhs)
 548     {
 549       result = true;
 550     }
 551     else
 552     {
 553       result = false;
 554     }
 555   }
 556   CALL_CATCH_EXCEPTION(false);
 557   return result;
 558 }
 559
 560
 561 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 562      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 563    }
 564 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){
 565      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 566    }
 567 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 568         std::vector< Dali::TouchPoint >* pv = 0;
 569         if (capacity >= 0) {
 570           pv = new std::vector< Dali::TouchPoint >();
 571           pv->reserve(capacity);
 572        } else {
 573           throw std::out_of_range("capacity");
 574        }
 575        return pv;
 576       }
 577 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 578         if (index>=0 && index<(int)self->size())
 579           return (*self)[index];
 580         else
 581           throw std::out_of_range("index");
 582       }
 583 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 584         if (index>=0 && index<(int)self->size())
 585           return (*self)[index];
 586         else
 587           throw std::out_of_range("index");
 588       }
 589 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 590         if (index>=0 && index<(int)self->size())
 591           (*self)[index] = val;
 592         else
 593           throw std::out_of_range("index");
 594       }
 595 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 596         self->insert(self->end(), values.begin(), values.end());
 597       }
 598 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 599         if (index < 0)
 600           throw std::out_of_range("index");
 601         if (count < 0)
 602           throw std::out_of_range("count");
 603         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 604           throw std::invalid_argument("invalid range");
 605         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 606       }
 607 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 608         if (index>=0 && index<(int)self->size()+1)
 609           self->insert(self->begin()+index, x);
 610         else
 611           throw std::out_of_range("index");
 612       }
 613 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 614         if (index>=0 && index<(int)self->size()+1)
 615           self->insert(self->begin()+index, values.begin(), values.end());
 616         else
 617           throw std::out_of_range("index");
 618       }
 619 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 620         if (index>=0 && index<(int)self->size())
 621           self->erase(self->begin() + index);
 622         else
 623           throw std::out_of_range("index");
 624       }
 625 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 626         if (index < 0)
 627           throw std::out_of_range("index");
 628         if (count < 0)
 629           throw std::out_of_range("count");
 630         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 631           throw std::invalid_argument("invalid range");
 632         self->erase(self->begin()+index, self->begin()+index+count);
 633       }
 634 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 635         if (count < 0)
 636           throw std::out_of_range("count");
 637         return new std::vector< Dali::TouchPoint >(count, value);
 638       }
 639 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 640         std::reverse(self->begin(), self->end());
 641       }
 642 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 643         if (index < 0)
 644           throw std::out_of_range("index");
 645         if (count < 0)
 646           throw std::out_of_range("count");
 647         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 648           throw std::invalid_argument("invalid range");
 649         std::reverse(self->begin()+index, self->begin()+index+count);
 650       }
 651 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 652         if (index < 0)
 653           throw std::out_of_range("index");
 654         if (index+values.size() > self->size())
 655           throw std::out_of_range("index");
 656         std::copy(values.begin(), values.end(), self->begin()+index);
 657       }
 658 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 659          return self->Empty();
 660       }
 661 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 662         return self->GetConnectionCount();
 663       }
 664 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 665           self->Connect( func );
 666       }
 667 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 668           self->Disconnect( func );
 669       }
 670 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 671           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 672 /*@SWIG@*/ self->Emit( arg );
 673       }
 674 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 675          return self->Empty();
 676       }
 677 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 678         return self->GetConnectionCount();
 679       }
 680 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 681           self->Connect( func );
 682       }
 683 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 684           self->Disconnect( func );
 685       }
 686 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 687           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 688 /*@SWIG@*/ self->Emit( arg );
 689       }
 690 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 691          return self->Empty();
 692       }
 693 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 694         return self->GetConnectionCount();
 695       }
 696 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 697           self->Connect( func );
 698       }
 699 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 700           self->Disconnect( func );
 701       }
 702 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 703           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 704 /*@SWIG@*/ self->Emit( arg );
 705       }
 706 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 707          return self->Empty();
 708       }
 709 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 710         return self->GetConnectionCount();
 711       }
 712 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 713         self->Connect( func );
 714       }
 715 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 716         self->Disconnect( func );
 717       }
 718 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,Dali::Actor arg1,Dali::LongPressGesture const &arg2){
 719         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 720 /*@SWIG@*/ self->Emit( arg1, arg2 );
 721       }
 722 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 723          return self->Empty();
 724       }
 725 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){
 726         return self->GetConnectionCount();
 727       }
 728 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 &)){
 729           self->Connect( func );
 730       }
 731 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 &)){
 732           self->Disconnect( func );
 733       }
 734 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){
 735           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 736 /*@SWIG@*/ self->Emit( arg );
 737       }
 738 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchEvent const &) > const *self){
 739          return self->Empty();
 740       }
 741 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){
 742         return self->GetConnectionCount();
 743       }
 744 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 &)){
 745           self->Connect( func );
 746       }
 747 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 &)){
 748           self->Disconnect( func );
 749       }
 750 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){
 751           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 752 /*@SWIG@*/ self->Emit( arg );
 753       }
 754 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 755          return self->Empty();
 756       }
 757 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){
 758         return self->GetConnectionCount();
 759       }
 760 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 &)){
 761           self->Connect( func );
 762       }
 763 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 &)){
 764           self->Disconnect( func );
 765       }
 766 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){
 767           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 768 /*@SWIG@*/ self->Emit( arg );
 769       }
 770 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){
 771          return self->Empty();
 772       }
 773 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){
 774         return self->GetConnectionCount();
 775       }
 776 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 &)){
 777         self->Connect( func );
 778       }
 779 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 &)){
 780         self->Disconnect( func );
 781       }
 782 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){
 783         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 784 /*@SWIG@*/ self->Emit( arg1, arg2 );
 785       }
 786 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){
 787          return self->Empty();
 788       }
 789 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){
 790         return self->GetConnectionCount();
 791       }
 792 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 &)){
 793         self->Connect( func );
 794       }
 795 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 &)){
 796         self->Disconnect( func );
 797       }
 798 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){
 799         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 800 /*@SWIG@*/ self->Emit( arg1, arg2 );
 801       }
 802 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){
 803          return self->Empty();
 804       }
 805 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){
 806         return self->GetConnectionCount();
 807       }
 808 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 &)){
 809         self->Connect( func );
 810       }
 811 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 &)){
 812         self->Disconnect( func );
 813       }
 814 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){
 815         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 816 /*@SWIG@*/ self->Emit( arg1, arg2 );
 817       }
 818 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){
 819          return self->Empty();
 820       }
 821 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){
 822         return self->GetConnectionCount();
 823       }
 824 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)){
 825           return self->Connect( func );
 826       }
 827 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)){
 828           self->Disconnect( func );
 829       }
 830 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){
 831           self->Emit( arg1, arg3 );
 832       }
 833 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){
 834          return self->Empty();
 835       }
 836 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){
 837         return self->GetConnectionCount();
 838       }
 839 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)){
 840           return self->Connect( func );
 841       }
 842 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)){
 843           self->Disconnect( func );
 844       }
 845 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){
 846           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 847 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
 848       }
 849
 850 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
 851         std::vector< unsigned int >* pv = 0;
 852         if (capacity >= 0) {
 853           pv = new std::vector< unsigned int >();
 854           pv->reserve(capacity);
 855        } else {
 856           throw std::out_of_range("capacity");
 857        }
 858        return pv;
 859       }
 860 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
 861         if (index>=0 && index<(int)self->size())
 862           return (*self)[index];
 863         else
 864           throw std::out_of_range("index");
 865       }
 866 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
 867         if (index>=0 && index<(int)self->size())
 868           return (*self)[index];
 869         else
 870           throw std::out_of_range("index");
 871       }
 872 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
 873         if (index>=0 && index<(int)self->size())
 874           (*self)[index] = val;
 875         else
 876           throw std::out_of_range("index");
 877       }
 878 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
 879         self->insert(self->end(), values.begin(), values.end());
 880       }
 881 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
 882         if (index < 0)
 883           throw std::out_of_range("index");
 884         if (count < 0)
 885           throw std::out_of_range("count");
 886         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 887           throw std::invalid_argument("invalid range");
 888         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
 889       }
 890 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
 891         if (index>=0 && index<(int)self->size()+1)
 892           self->insert(self->begin()+index, x);
 893         else
 894           throw std::out_of_range("index");
 895       }
 896 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
 897         if (index>=0 && index<(int)self->size()+1)
 898           self->insert(self->begin()+index, values.begin(), values.end());
 899         else
 900           throw std::out_of_range("index");
 901       }
 902 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
 903         if (index>=0 && index<(int)self->size())
 904           self->erase(self->begin() + index);
 905         else
 906           throw std::out_of_range("index");
 907       }
 908 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
 909         if (index < 0)
 910           throw std::out_of_range("index");
 911         if (count < 0)
 912           throw std::out_of_range("count");
 913         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 914           throw std::invalid_argument("invalid range");
 915         self->erase(self->begin()+index, self->begin()+index+count);
 916       }
 917 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
 918         if (count < 0)
 919           throw std::out_of_range("count");
 920         return new std::vector< unsigned int >(count, value);
 921       }
 922 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
 923         std::reverse(self->begin(), self->end());
 924       }
 925 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
 926         if (index < 0)
 927           throw std::out_of_range("index");
 928         if (count < 0)
 929           throw std::out_of_range("count");
 930         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 931           throw std::invalid_argument("invalid range");
 932         std::reverse(self->begin()+index, self->begin()+index+count);
 933       }
 934 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
 935         if (index < 0)
 936           throw std::out_of_range("index");
 937         if (index+values.size() > self->size())
 938           throw std::out_of_range("index");
 939         std::copy(values.begin(), values.end(), self->begin()+index);
 940       }
 941 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
 942         return std::find(self->begin(), self->end(), value) != self->end();
 943       }
 944 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
 945         int index = -1;
 946         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
 947         if (it != self->end())
 948           index = (int)(it - self->begin());
 949         return index;
 950       }
 951 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
 952         int index = -1;
 953         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
 954         if (rit != self->rend())
 955           index = (int)(self->rend() - 1 - rit);
 956         return index;
 957       }
 958 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
 959         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
 960         if (it != self->end()) {
 961           self->erase(it);
 962           return true;
 963         }
 964         return false;
 965       }
 966 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){
 967         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
 968         if (capacity >= 0) {
 969           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
 970           pv->reserve(capacity);
 971        } else {
 972           throw std::out_of_range("capacity");
 973        }
 974        return pv;
 975       }
 976 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){
 977         if (index>=0 && index<(int)self->size())
 978           return (*self)[index];
 979         else
 980           throw std::out_of_range("index");
 981       }
 982 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){
 983         if (index>=0 && index<(int)self->size())
 984           return (*self)[index];
 985         else
 986           throw std::out_of_range("index");
 987       }
 988 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){
 989         if (index>=0 && index<(int)self->size())
 990           (*self)[index] = val;
 991         else
 992           throw std::out_of_range("index");
 993       }
 994 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){
 995         self->insert(self->end(), values.begin(), values.end());
 996       }
 997 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){
 998         if (index < 0)
 999           throw std::out_of_range("index");
1000         if (count < 0)
1001           throw std::out_of_range("count");
1002         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1003           throw std::invalid_argument("invalid range");
1004         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1005       }
1006 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){
1007         if (index>=0 && index<(int)self->size()+1)
1008           self->insert(self->begin()+index, x);
1009         else
1010           throw std::out_of_range("index");
1011       }
1012 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){
1013         if (index>=0 && index<(int)self->size()+1)
1014           self->insert(self->begin()+index, values.begin(), values.end());
1015         else
1016           throw std::out_of_range("index");
1017       }
1018 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){
1019         if (index>=0 && index<(int)self->size())
1020           self->erase(self->begin() + index);
1021         else
1022           throw std::out_of_range("index");
1023       }
1024 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){
1025         if (index < 0)
1026           throw std::out_of_range("index");
1027         if (count < 0)
1028           throw std::out_of_range("count");
1029         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1030           throw std::invalid_argument("invalid range");
1031         self->erase(self->begin()+index, self->begin()+index+count);
1032       }
1033 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){
1034         if (count < 0)
1035           throw std::out_of_range("count");
1036         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1037       }
1038 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){
1039         std::reverse(self->begin(), self->end());
1040       }
1041 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){
1042         if (index < 0)
1043           throw std::out_of_range("index");
1044         if (count < 0)
1045           throw std::out_of_range("count");
1046         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1047           throw std::invalid_argument("invalid range");
1048         std::reverse(self->begin()+index, self->begin()+index+count);
1049       }
1050 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){
1051         if (index < 0)
1052           throw std::out_of_range("index");
1053         if (index+values.size() > self->size())
1054           throw std::out_of_range("index");
1055         std::copy(values.begin(), values.end(), self->begin()+index);
1056       }
1057 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1058         std::vector< Dali::Actor >* pv = 0;
1059         if (capacity >= 0) {
1060           pv = new std::vector< Dali::Actor >();
1061           pv->reserve(capacity);
1062        } else {
1063           throw std::out_of_range("capacity");
1064        }
1065        return pv;
1066       }
1067 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1068         if (index>=0 && index<(int)self->size())
1069           return (*self)[index];
1070         else
1071           throw std::out_of_range("index");
1072       }
1073 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1074         if (index>=0 && index<(int)self->size())
1075           return (*self)[index];
1076         else
1077           throw std::out_of_range("index");
1078       }
1079 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1080         if (index>=0 && index<(int)self->size())
1081           (*self)[index] = val;
1082         else
1083           throw std::out_of_range("index");
1084       }
1085 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1086         self->insert(self->end(), values.begin(), values.end());
1087       }
1088 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1089         if (index < 0)
1090           throw std::out_of_range("index");
1091         if (count < 0)
1092           throw std::out_of_range("count");
1093         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1094           throw std::invalid_argument("invalid range");
1095         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1096       }
1097 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1098         if (index>=0 && index<(int)self->size()+1)
1099           self->insert(self->begin()+index, x);
1100         else
1101           throw std::out_of_range("index");
1102       }
1103 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1104         if (index>=0 && index<(int)self->size()+1)
1105           self->insert(self->begin()+index, values.begin(), values.end());
1106         else
1107           throw std::out_of_range("index");
1108       }
1109 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1110         if (index>=0 && index<(int)self->size())
1111           self->erase(self->begin() + index);
1112         else
1113           throw std::out_of_range("index");
1114       }
1115 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1116         if (index < 0)
1117           throw std::out_of_range("index");
1118         if (count < 0)
1119           throw std::out_of_range("count");
1120         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1121           throw std::invalid_argument("invalid range");
1122         self->erase(self->begin()+index, self->begin()+index+count);
1123       }
1124 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1125         if (count < 0)
1126           throw std::out_of_range("count");
1127         return new std::vector< Dali::Actor >(count, value);
1128       }
1129 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1130         std::reverse(self->begin(), self->end());
1131       }
1132 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1133         if (index < 0)
1134           throw std::out_of_range("index");
1135         if (count < 0)
1136           throw std::out_of_range("count");
1137         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1138           throw std::invalid_argument("invalid range");
1139         std::reverse(self->begin()+index, self->begin()+index+count);
1140       }
1141 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1142         if (index < 0)
1143           throw std::out_of_range("index");
1144         if (index+values.size() > self->size())
1145           throw std::out_of_range("index");
1146         std::copy(values.begin(), values.end(), self->begin()+index);
1147       }
1148 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1149          return self->Empty();
1150       }
1151 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){
1152         return self->GetConnectionCount();
1153       }
1154 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)){
1155         self->Connect( func );
1156       }
1157 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)){
1158         self->Disconnect( func );
1159       }
1160 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){
1161         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1162 /*@SWIG@*/ self->Emit( arg1, arg2 );
1163       }
1164 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1165          return self->Empty();
1166       }
1167 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1168         return self->GetConnectionCount();
1169       }
1170 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)){
1171         self->Connect( func );
1172       }
1173 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)){
1174         self->Disconnect( func );
1175       }
1176 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){
1177         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1178 /*@SWIG@*/ self->Emit( arg1, arg2 );
1179       }
1180
1181 /* ---------------------------------------------------
1182  * C++ director class methods
1183  * --------------------------------------------------- */
1184
1185 #include "dali-wrap.h"
1186
1187 /*
1188  *  Widget director
1189  */
1190 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1191   swig_init_callbacks();
1192 }
1193
1194 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1195 }
1196
1197 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1198   char * jcontentInfo = 0 ;
1199   void * jwindow  ;
1200
1201   if (!swig_callbackOnCreate) {
1202     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1203     return;
1204   } else {
1205     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1206     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1207     swig_callbackOnCreate(jcontentInfo, jwindow);
1208   }
1209 }
1210
1211 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1212   char * jcontentInfo = 0 ;
1213   int jtype  ;
1214
1215   if (!swig_callbackOnTerminate) {
1216     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1217     return;
1218   } else {
1219     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1220     jtype = (int)type;
1221     swig_callbackOnTerminate(jcontentInfo, jtype);
1222   }
1223 }
1224
1225 void SwigDirector_WidgetImpl::OnPause() {
1226   if (!swig_callbackOnPause) {
1227     Dali::Internal::Adaptor::Widget::OnPause();
1228     return;
1229   } else {
1230     swig_callbackOnPause();
1231   }
1232 }
1233
1234 void SwigDirector_WidgetImpl::OnResume() {
1235   if (!swig_callbackOnResume) {
1236     Dali::Internal::Adaptor::Widget::OnResume();
1237     return;
1238   } else {
1239     swig_callbackOnResume();
1240   }
1241 }
1242
1243 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1244   void * jwindow  ;
1245
1246   if (!swig_callbackOnResize) {
1247     Dali::Internal::Adaptor::Widget::OnResize(window);
1248     return;
1249   } else {
1250     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1251     swig_callbackOnResize(jwindow);
1252   }
1253 }
1254
1255 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1256   char * jcontentInfo = 0 ;
1257   int jforce  ;
1258
1259   if (!swig_callbackOnUpdate) {
1260     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1261     return;
1262   } else {
1263     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1264     jforce = force;
1265     swig_callbackOnUpdate(jcontentInfo, jforce);
1266   }
1267 }
1268
1269 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1270   void * jslotObserver = 0 ;
1271   void * jcallback = 0 ;
1272
1273   if (!swig_callbackSignalConnected) {
1274     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1275     return;
1276   } else {
1277     jslotObserver = (void *) slotObserver;
1278     jcallback = (void *) callback;
1279     swig_callbackSignalConnected(jslotObserver, jcallback);
1280   }
1281 }
1282
1283 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1284   void * jslotObserver = 0 ;
1285   void * jcallback = 0 ;
1286
1287   if (!swig_callbackSignalDisconnected) {
1288     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1289     return;
1290   } else {
1291     jslotObserver = (void *) slotObserver;
1292     jcallback = (void *) callback;
1293     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1294   }
1295 }
1296
1297 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) {
1298
1299   swig_callbackOnCreate = callbackOnCreate;
1300   swig_callbackOnTerminate = callbackOnTerminate;
1301   swig_callbackOnPause = callbackOnPause;
1302   swig_callbackOnResume = callbackOnResume;
1303   swig_callbackOnResize = callbackOnResize;
1304   swig_callbackOnUpdate = callbackOnUpdate;
1305   swig_callbackSignalConnected = callbackSignalConnected;
1306   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1307 }
1308
1309 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1310   swig_callbackOnCreate = 0;
1311   swig_callbackOnTerminate = 0;
1312   swig_callbackOnPause = 0;
1313   swig_callbackOnResume = 0;
1314   swig_callbackOnResize = 0;
1315   swig_callbackOnUpdate = 0;
1316   swig_callbackSignalConnected = 0;
1317   swig_callbackSignalDisconnected = 0;
1318 }
1319
1320
1321 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1322   swig_init_callbacks();
1323 }
1324
1325 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1326
1327 }
1328
1329
1330 void SwigDirector_ViewImpl::OnSceneConnection(int depth) {
1331   int jdepth  ;
1332
1333   if (!swig_callbackOnSceneConnection) {
1334     Dali::Toolkit::Internal::Control::OnSceneConnection(depth);
1335     return;
1336   } else {
1337     jdepth = depth;
1338     swig_callbackOnSceneConnection(jdepth);
1339   }
1340 }
1341
1342 void SwigDirector_ViewImpl::OnSceneDisconnection() {
1343   if (!swig_callbackOnSceneDisconnection) {
1344     Dali::Toolkit::Internal::Control::OnSceneDisconnection();
1345     return;
1346   } else {
1347     swig_callbackOnSceneDisconnection();
1348   }
1349 }
1350
1351 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1352   void * jchild = 0 ;
1353
1354   if (!swig_callbackOnChildAdd) {
1355     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1356     return;
1357   } else {
1358     jchild = (Dali::Actor *) &child;
1359     swig_callbackOnChildAdd(jchild);
1360   }
1361 }
1362
1363 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1364   void * jchild = 0 ;
1365
1366   if (!swig_callbackOnChildRemove) {
1367     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1368     return;
1369   } else {
1370     jchild = (Dali::Actor *) &child;
1371     swig_callbackOnChildRemove(jchild);
1372   }
1373 }
1374
1375 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, const Dali::Property::Value& propertyValue) {
1376   int jindex  ;
1377   void * jpropertyValue  ;
1378
1379   if (!swig_callbackOnPropertySet) {
1380     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1381     return;
1382   } else {
1383     jindex = index;
1384     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1385     swig_callbackOnPropertySet(jindex, jpropertyValue);
1386   }
1387 }
1388
1389 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1390   void * jtargetSize = 0 ;
1391
1392   if (!swig_callbackOnSizeSet) {
1393     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1394     return;
1395   } else {
1396     jtargetSize = (Dali::Vector3 *) &targetSize;
1397     swig_callbackOnSizeSet(jtargetSize);
1398   }
1399 }
1400
1401 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1402   void * janimation = 0 ;
1403   void * jtargetSize = 0 ;
1404
1405   if (!swig_callbackOnSizeAnimation) {
1406     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1407     return;
1408   } else {
1409     janimation = (Dali::Animation *) &animation;
1410     jtargetSize = (Dali::Vector3 *) &targetSize;
1411     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1412   }
1413 }
1414
1415 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1416   bool c_result = SwigValueInit< bool >() ;
1417   unsigned int jresult = 0 ;
1418   void * jarg0 = 0 ;
1419
1420   if (!swig_callbackOnKeyEvent) {
1421     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1422   } else {
1423     jarg0 = (Dali::KeyEvent *) &event;
1424     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1425     c_result = jresult ? true : false;
1426   }
1427   return c_result;
1428 }
1429
1430 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1431   void * jsize = 0 ;
1432   void * jcontainer = 0 ;
1433
1434   if (!swig_callbackOnRelayout) {
1435     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1436     return;
1437   } else {
1438     jsize = (Dali::Vector2 *) &size;
1439     jcontainer = (Dali::RelayoutContainer *) &container;
1440     swig_callbackOnRelayout(jsize, jcontainer);
1441   }
1442 }
1443
1444 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1445   int jpolicy  ;
1446   int jdimension  ;
1447
1448   if (!swig_callbackOnSetResizePolicy) {
1449     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1450     return;
1451   } else {
1452     jpolicy = (int)policy;
1453     jdimension = (int)dimension;
1454     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1455   }
1456 }
1457
1458 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1459   Dali::Vector3 c_result ;
1460   void * jresult = 0 ;
1461
1462   if (!swig_callbackGetNaturalSize) {
1463     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1464   } else {
1465     jresult = (void *) swig_callbackGetNaturalSize();
1466     if (!jresult) {
1467       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1468       return c_result;
1469     }
1470     c_result = *(Dali::Vector3 *)jresult;
1471   }
1472   return c_result;
1473 }
1474
1475 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1476   float c_result = SwigValueInit< float >() ;
1477   float jresult = 0 ;
1478   void * jchild = 0 ;
1479   int jdimension  ;
1480
1481   if (!swig_callbackCalculateChildSize) {
1482     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1483   } else {
1484     jchild = (Dali::Actor *) &child;
1485     jdimension = (int)dimension;
1486     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1487     c_result = (float)jresult;
1488   }
1489   return c_result;
1490 }
1491
1492 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1493   float c_result = SwigValueInit< float >() ;
1494   float jresult = 0 ;
1495   float jwidth  ;
1496
1497   if (!swig_callbackGetHeightForWidth) {
1498     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1499   } else {
1500     jwidth = width;
1501     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1502     c_result = (float)jresult;
1503   }
1504   return c_result;
1505 }
1506
1507 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1508   float c_result = SwigValueInit< float >() ;
1509   float jresult = 0 ;
1510   float jheight  ;
1511
1512   if (!swig_callbackGetWidthForHeight) {
1513     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1514   } else {
1515     jheight = height;
1516     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1517     c_result = (float)jresult;
1518   }
1519   return c_result;
1520 }
1521
1522 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1523   bool c_result = SwigValueInit< bool >() ;
1524   unsigned int jresult = 0 ;
1525   int jdimension  ;
1526
1527   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1528     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1529   } else {
1530     jdimension = (int)dimension;
1531     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1532     c_result = jresult ? true : false;
1533   }
1534   return c_result;
1535 }
1536
1537 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1538   int jdimension  ;
1539
1540   if (!swig_callbackOnCalculateRelayoutSize) {
1541     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1542     return;
1543   } else {
1544     jdimension = (int)dimension;
1545     swig_callbackOnCalculateRelayoutSize(jdimension);
1546   }
1547 }
1548
1549 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1550   float jsize  ;
1551   int jdimension  ;
1552
1553   if (!swig_callbackOnLayoutNegotiated) {
1554     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
1555     return;
1556   } else {
1557     jsize = size;
1558     jdimension = (int)dimension;
1559     swig_callbackOnLayoutNegotiated(jsize, jdimension);
1560   }
1561 }
1562
1563 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
1564   return Dali::CustomActorImpl::GetExtension();
1565 }
1566
1567 void SwigDirector_ViewImpl::OnInitialize() {
1568   if (!swig_callbackOnInitialize) {
1569     Dali::Toolkit::Internal::Control::OnInitialize();
1570     return;
1571   } else {
1572     swig_callbackOnInitialize();
1573   }
1574 }
1575
1576 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
1577   void * jstyleManager  ;
1578   int jchange  ;
1579
1580   if (!swig_callbackOnStyleChange) {
1581     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
1582     return;
1583   } else {
1584     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
1585     jchange = (int)change;
1586     swig_callbackOnStyleChange(jstyleManager, jchange);
1587   }
1588 }
1589
1590 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
1591   bool c_result = SwigValueInit< bool >() ;
1592   unsigned int jresult = 0 ;
1593
1594   if (!swig_callbackOnAccessibilityActivated) {
1595     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
1596   } else {
1597     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
1598     c_result = jresult ? true : false;
1599   }
1600   return c_result;
1601 }
1602
1603 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
1604   bool c_result = SwigValueInit< bool >() ;
1605   unsigned int jresult = 0 ;
1606   void * jgesture  ;
1607
1608   if (!swig_callbackOnAccessibilityPan) {
1609     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
1610   } else {
1611     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
1612     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
1613     c_result = jresult ? true : false;
1614   }
1615   return c_result;
1616 }
1617
1618 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
1619   bool c_result = SwigValueInit< bool >() ;
1620   unsigned int jresult = 0 ;
1621   unsigned int jisIncrease  ;
1622
1623   if (!swig_callbackOnAccessibilityValueChange) {
1624     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
1625   } else {
1626     jisIncrease = isIncrease;
1627     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
1628     c_result = jresult ? true : false;
1629   }
1630   return c_result;
1631 }
1632
1633 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
1634   bool c_result = SwigValueInit< bool >() ;
1635   unsigned int jresult = 0 ;
1636
1637   if (!swig_callbackOnAccessibilityZoom) {
1638     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
1639   } else {
1640     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
1641     c_result = jresult ? true : false;
1642   }
1643   return c_result;
1644 }
1645
1646 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
1647   if (!swig_callbackOnKeyInputFocusGained) {
1648     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
1649     return;
1650   } else {
1651     swig_callbackOnKeyInputFocusGained();
1652   }
1653 }
1654
1655 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
1656   if (!swig_callbackOnKeyInputFocusLost) {
1657     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
1658     return;
1659   } else {
1660     swig_callbackOnKeyInputFocusLost();
1661   }
1662 }
1663
1664
1665 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled)
1666 {
1667   Dali::Actor c_result;
1668   void* jresult = 0;
1669
1670   if(!swig_callbackGetNextKeyboardFocusableActor)
1671   {
1672     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
1673   }
1674   else
1675   {
1676     jresult = (void*)swig_callbackGetNextKeyboardFocusableActor((void*)(&currentFocusedActor), (int)direction, loopEnabled);
1677
1678     if(!jresult)
1679     {
1680       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
1681       return c_result;
1682     }
1683     c_result = *(Dali::Actor*)jresult;
1684   }
1685   return c_result;
1686 }
1687
1688 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor)
1689 {
1690   if(!swig_callbackOnKeyboardFocusChangeCommitted)
1691   {
1692     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
1693     return;
1694   }
1695   else
1696   {
1697     swig_callbackOnKeyboardFocusChangeCommitted((void*)(&commitedFocusableActor));
1698   }
1699 }
1700
1701 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
1702   bool c_result = SwigValueInit< bool >() ;
1703   unsigned int jresult = 0 ;
1704
1705   if (!swig_callbackOnKeyboardEnter) {
1706     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
1707   } else {
1708     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
1709     c_result = jresult ? true : false;
1710   }
1711   return c_result;
1712 }
1713
1714 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
1715   void * jpinch = 0 ;
1716
1717   if (!swig_callbackOnPinch) {
1718     Dali::Toolkit::Internal::Control::OnPinch(pinch);
1719     return;
1720   } else {
1721     jpinch = (Dali::PinchGesture *) &pinch;
1722     swig_callbackOnPinch(jpinch);
1723   }
1724 }
1725
1726 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
1727   void * jpan = 0 ;
1728
1729   if (!swig_callbackOnPan) {
1730     Dali::Toolkit::Internal::Control::OnPan(pan);
1731     return;
1732   } else {
1733     jpan = (Dali::PanGesture *) &pan;
1734     swig_callbackOnPan(jpan);
1735   }
1736 }
1737
1738 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
1739   void * jtap = 0 ;
1740
1741   if (!swig_callbackOnTap) {
1742     Dali::Toolkit::Internal::Control::OnTap(tap);
1743     return;
1744   } else {
1745     jtap = (Dali::TapGesture *) &tap;
1746     swig_callbackOnTap(jtap);
1747   }
1748 }
1749
1750 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
1751   void * jlongPress = 0 ;
1752
1753   if (!swig_callbackOnLongPress) {
1754     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
1755     return;
1756   } else {
1757     jlongPress = (Dali::LongPressGesture *) &longPress;
1758     swig_callbackOnLongPress(jlongPress);
1759   }
1760 }
1761
1762 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1763   void * jslotObserver = 0 ;
1764   void * jcallback = 0 ;
1765
1766   if (!swig_callbackSignalConnected) {
1767     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
1768     return;
1769   } else {
1770     jslotObserver = (void *) slotObserver;
1771     jcallback = (void *) callback;
1772     swig_callbackSignalConnected(jslotObserver, jcallback);
1773   }
1774 }
1775
1776 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1777   void * jslotObserver = 0 ;
1778   void * jcallback = 0 ;
1779
1780   if (!swig_callbackSignalDisconnected) {
1781     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
1782     return;
1783   } else {
1784     jslotObserver = (void *) slotObserver;
1785     jcallback = (void *) callback;
1786     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1787   }
1788 }
1789
1790 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
1791   return Dali::Toolkit::Internal::Control::GetControlExtension();
1792 }
1793
1794 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) {
1795   swig_callbackOnSceneConnection = callbackOnSceneConnection;
1796   swig_callbackOnSceneDisconnection = callbackOnSceneDisconnection;
1797   swig_callbackOnChildAdd = callbackOnChildAdd;
1798   swig_callbackOnChildRemove = callbackOnChildRemove;
1799   swig_callbackOnPropertySet = callbackOnPropertySet;
1800   swig_callbackOnSizeSet = callbackOnSizeSet;
1801   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
1802   swig_callbackOnKeyEvent = callbackOnKeyEvent;
1803   swig_callbackOnRelayout = callbackOnRelayout;
1804   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
1805   swig_callbackGetNaturalSize = callbackGetNaturalSize;
1806   swig_callbackCalculateChildSize = callbackCalculateChildSize;
1807   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
1808   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
1809   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
1810   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
1811   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
1812   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
1813   swig_callbackOnInitialize = callbackOnInitialize;
1814   swig_callbackOnStyleChange = callbackOnStyleChange;
1815   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
1816   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
1817   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
1818   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
1819   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
1820   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
1821   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
1822   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
1823   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
1824   swig_callbackOnPinch = callbackOnPinch;
1825   swig_callbackOnPan = callbackOnPan;
1826   swig_callbackOnTap = callbackOnTap;
1827   swig_callbackOnLongPress = callbackOnLongPress;
1828   swig_callbackSignalConnected = callbackSignalConnected;
1829   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1830 }
1831
1832 void SwigDirector_ViewImpl::swig_init_callbacks() {
1833   swig_callbackOnSceneConnection = 0;
1834   swig_callbackOnSceneDisconnection = 0;
1835   swig_callbackOnChildAdd = 0;
1836   swig_callbackOnChildRemove = 0;
1837   swig_callbackOnPropertySet = 0;
1838   swig_callbackOnSizeSet = 0;
1839   swig_callbackOnSizeAnimation = 0;
1840   swig_callbackOnKeyEvent = 0;
1841   swig_callbackOnRelayout = 0;
1842   swig_callbackOnSetResizePolicy = 0;
1843   swig_callbackGetNaturalSize = 0;
1844   swig_callbackCalculateChildSize = 0;
1845   swig_callbackGetHeightForWidth = 0;
1846   swig_callbackGetWidthForHeight = 0;
1847   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
1848   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
1849   swig_callbackOnCalculateRelayoutSize = 0;
1850   swig_callbackOnLayoutNegotiated = 0;
1851   swig_callbackOnInitialize = 0;
1852   swig_callbackOnStyleChange = 0;
1853   swig_callbackOnAccessibilityActivated = 0;
1854   swig_callbackOnAccessibilityPan = 0;
1855   swig_callbackOnAccessibilityValueChange = 0;
1856   swig_callbackOnAccessibilityZoom = 0;
1857   swig_callbackOnKeyInputFocusGained = 0;
1858   swig_callbackOnKeyInputFocusLost = 0;
1859   swig_callbackGetNextKeyboardFocusableActor = 0;
1860   swig_callbackOnKeyboardFocusChangeCommitted = 0;
1861   swig_callbackOnKeyboardEnter = 0;
1862   swig_callbackOnPinch = 0;
1863   swig_callbackOnPan = 0;
1864   swig_callbackOnTap = 0;
1865   swig_callbackOnLongPress = 0;
1866   swig_callbackSignalConnected = 0;
1867   swig_callbackSignalDisconnected = 0;
1868 }
1869
1870 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
1871   swig_init_callbacks();
1872 }
1873
1874 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
1875
1876 }
1877
1878
1879 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
1880   unsigned int c_result = SwigValueInit< unsigned int >() ;
1881   unsigned int jresult = 0 ;
1882
1883   if (!swig_callbackGetNumberOfItems) {
1884     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
1885   } else {
1886     jresult = (unsigned int) swig_callbackGetNumberOfItems();
1887     c_result = (unsigned int)jresult;
1888   }
1889   return c_result;
1890 }
1891
1892 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
1893   Dali::Actor c_result ;
1894   void * jresult = 0 ;
1895   unsigned int jitemId  ;
1896
1897   if (!swig_callbackNewItem) {
1898     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
1899   } else {
1900     jitemId = itemId;
1901     jresult = (void *) swig_callbackNewItem(jitemId);
1902     if (!jresult) {
1903       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
1904       return c_result;
1905     }
1906     c_result = *(Dali::Actor *)jresult;
1907   }
1908   return c_result;
1909 }
1910
1911 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor)
1912 {
1913   if(!swig_callbackItemReleased)
1914   {
1915     Dali::Toolkit::ItemFactory::ItemReleased(itemId, actor);
1916     return;
1917   }
1918   else
1919   {
1920     swig_callbackItemReleased(itemId, (void*)(&actor));
1921   }
1922 }
1923
1924 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
1925   return Dali::Toolkit::ItemFactory::GetExtension();
1926 }
1927
1928 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
1929   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
1930   swig_callbackNewItem = callbackNewItem;
1931   swig_callbackItemReleased = callbackItemReleased;
1932 }
1933
1934 void SwigDirector_ItemFactory::swig_init_callbacks() {
1935   swig_callbackGetNumberOfItems = 0;
1936   swig_callbackNewItem = 0;
1937   swig_callbackItemReleased = 0;
1938 }
1939
1940 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
1941   swig_init_callbacks();
1942 }
1943
1944 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
1945
1946 }
1947
1948 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction, const std::string& deviceName)
1949 {
1950   Dali::Actor c_result;
1951   void* jresult = 0;
1952
1953   if(!swig_callbackGetNextFocusableActor)
1954   {
1955     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
1956   }
1957   else
1958   {
1959     jresult = (void*)swig_callbackGetNextFocusableActor((void*)(&current), (void*)(&proposed), direction, deviceName.c_str());
1960     if(!jresult)
1961     {
1962       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__);
1963       return c_result;
1964     }
1965     c_result = *(Dali::Actor*)jresult;
1966   }
1967   return c_result;
1968 }
1969
1970 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
1971   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
1972 }
1973
1974 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
1975   swig_callbackGetNextFocusableActor = 0;
1976 }
1977
1978 SwigDirector_FrameCallbackInterface::SwigDirector_FrameCallbackInterface() : Dali::FrameCallbackInterface(), Swig::Director() {
1979   swig_callbackOnUpdate = nullptr;
1980   swig_callbackOnUpdateWithReturn = nullptr;
1981 }
1982
1983 SwigDirector_FrameCallbackInterface::~SwigDirector_FrameCallbackInterface() {
1984
1985 }
1986
1987 void SwigDirector_FrameCallbackInterface::swig_connect_director(SWIG_Callback0_t callbackUpdate) {
1988   swig_callbackOnUpdate = callbackUpdate;
1989   swig_callbackOnUpdateWithReturn = nullptr;
1990 }
1991
1992 void SwigDirector_FrameCallbackInterface::swig_connect_director_with_return(SWIG_Callback1_t callbackUpdate) {
1993   swig_callbackOnUpdateWithReturn = callbackUpdate;
1994   swig_callbackOnUpdate = nullptr;
1995 }
1996
1997 bool SwigDirector_FrameCallbackInterface::Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) {
1998   void * jcurrent  ;
1999   bool jresult = false;
2000
2001   if (!swig_callbackOnUpdate && !swig_callbackOnUpdateWithReturn) {
2002     throw Swig::DirectorPureVirtualException("Dali::FrameCallbackInterface::Update");
2003   } else {
2004     Dali::UpdateProxy* proxy = &updateProxy;
2005     jcurrent = (void *)proxy;
2006
2007     if(swig_callbackOnUpdateWithReturn)
2008     {
2009       jresult = swig_callbackOnUpdateWithReturn(jcurrent, elapsedSeconds);
2010     }
2011     else
2012     {
2013       swig_callbackOnUpdate(jcurrent, elapsedSeconds);
2014     }
2015
2016     if (!jcurrent) {
2017       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::UpdateProxy! ", __FILE__, __LINE__);
2018       return false;
2019     }
2020   }
2021   return jresult;
2022 }
2023
2024
2025
2026 /*******************************************/
2027 /*                 Binding                 */
2028 /*******************************************/
2029
2030 #ifdef __cplusplus
2031 extern "C" {
2032 #endif
2033
2034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2035   void * jresult ;
2036   floatp *result = 0 ;
2037
2038   {
2039     try {
2040       result = (floatp *)new_floatp();
2041     } CALL_CATCH_EXCEPTION(0);
2042   }
2043   jresult = (void *)result;
2044   return jresult;
2045 }
2046
2047
2048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2049   floatp *arg1 = (floatp *) 0 ;
2050
2051   arg1 = (floatp *)jarg1;
2052   {
2053     try {
2054       delete_floatp(arg1);
2055     } CALL_CATCH_EXCEPTION();
2056   }
2057
2058 }
2059
2060
2061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2062   floatp *arg1 = (floatp *) 0 ;
2063   float arg2 ;
2064
2065   arg1 = (floatp *)jarg1;
2066   arg2 = (float)jarg2;
2067   {
2068     try {
2069       floatp_assign(arg1,arg2);
2070     } CALL_CATCH_EXCEPTION();
2071   }
2072
2073 }
2074
2075
2076 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2077   float jresult ;
2078   floatp *arg1 = (floatp *) 0 ;
2079   float result;
2080
2081   arg1 = (floatp *)jarg1;
2082   {
2083     try {
2084       result = (float)floatp_value(arg1);
2085     } CALL_CATCH_EXCEPTION(0);
2086   }
2087   jresult = result;
2088   return jresult;
2089 }
2090
2091
2092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2093   void * jresult ;
2094   floatp *arg1 = (floatp *) 0 ;
2095   float *result = 0 ;
2096
2097   arg1 = (floatp *)jarg1;
2098   {
2099     try {
2100       result = (float *)floatp_cast(arg1);
2101     } CALL_CATCH_EXCEPTION(0);
2102   }
2103
2104   jresult = (void *)result;
2105   return jresult;
2106 }
2107
2108
2109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2110   void * jresult ;
2111   float *arg1 = (float *) 0 ;
2112   floatp *result = 0 ;
2113
2114   arg1 = (float *)jarg1;
2115   {
2116     try {
2117       result = (floatp *)floatp_frompointer(arg1);
2118     } CALL_CATCH_EXCEPTION(0);
2119   }
2120
2121   jresult = (void *)result;
2122   return jresult;
2123 }
2124
2125
2126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2127   void * jresult ;
2128   intp *result = 0 ;
2129
2130   {
2131     try {
2132       result = (intp *)new_intp();
2133     } CALL_CATCH_EXCEPTION(0);
2134   }
2135
2136   jresult = (void *)result;
2137   return jresult;
2138 }
2139
2140
2141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2142   intp *arg1 = (intp *) 0 ;
2143
2144   arg1 = (intp *)jarg1;
2145   {
2146     try {
2147       delete_intp(arg1);
2148     } CALL_CATCH_EXCEPTION();
2149   }
2150
2151 }
2152
2153
2154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2155   intp *arg1 = (intp *) 0 ;
2156   int arg2 ;
2157
2158   arg1 = (intp *)jarg1;
2159   arg2 = (int)jarg2;
2160   {
2161     try {
2162       intp_assign(arg1,arg2);
2163     } CALL_CATCH_EXCEPTION();
2164   }
2165
2166 }
2167
2168
2169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2170   int jresult ;
2171   intp *arg1 = (intp *) 0 ;
2172   int result;
2173
2174   arg1 = (intp *)jarg1;
2175   {
2176     try {
2177       result = (int)intp_value(arg1);
2178     } CALL_CATCH_EXCEPTION(0);
2179   }
2180
2181   jresult = result;
2182   return jresult;
2183 }
2184
2185
2186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2187   void * jresult ;
2188   intp *arg1 = (intp *) 0 ;
2189   int *result = 0 ;
2190
2191   arg1 = (intp *)jarg1;
2192   {
2193     try {
2194       result = (int *)intp_cast(arg1);
2195     } CALL_CATCH_EXCEPTION(0);
2196   }
2197
2198   jresult = (void *)result;
2199   return jresult;
2200 }
2201
2202
2203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2204   void * jresult ;
2205   int *arg1 = (int *) 0 ;
2206   intp *result = 0 ;
2207
2208   arg1 = (int *)jarg1;
2209   {
2210     try {
2211       result = (intp *)intp_frompointer(arg1);
2212     } CALL_CATCH_EXCEPTION(0);
2213   }
2214
2215   jresult = (void *)result;
2216   return jresult;
2217 }
2218
2219
2220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2221   void * jresult ;
2222   doublep *result = 0 ;
2223
2224   {
2225     try {
2226       result = (doublep *)new_doublep();
2227     } CALL_CATCH_EXCEPTION(0);
2228   }
2229
2230   jresult = (void *)result;
2231   return jresult;
2232 }
2233
2234
2235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2236   doublep *arg1 = (doublep *) 0 ;
2237
2238   arg1 = (doublep *)jarg1;
2239   {
2240     try {
2241       delete_doublep(arg1);
2242     } CALL_CATCH_EXCEPTION();
2243   }
2244
2245 }
2246
2247
2248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2249   doublep *arg1 = (doublep *) 0 ;
2250   double arg2 ;
2251
2252   arg1 = (doublep *)jarg1;
2253   arg2 = (double)jarg2;
2254   {
2255     try {
2256       doublep_assign(arg1,arg2);
2257     } CALL_CATCH_EXCEPTION();
2258   }
2259
2260 }
2261
2262
2263 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2264   double jresult ;
2265   doublep *arg1 = (doublep *) 0 ;
2266   double result;
2267
2268   arg1 = (doublep *)jarg1;
2269   {
2270     try {
2271       result = (double)doublep_value(arg1);
2272     } CALL_CATCH_EXCEPTION(0);
2273   }
2274
2275   jresult = result;
2276   return jresult;
2277 }
2278
2279
2280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2281   void * jresult ;
2282   doublep *arg1 = (doublep *) 0 ;
2283   double *result = 0 ;
2284
2285   arg1 = (doublep *)jarg1;
2286   {
2287     try {
2288       result = (double *)doublep_cast(arg1);
2289     } CALL_CATCH_EXCEPTION(0);
2290   }
2291
2292   jresult = (void *)result;
2293   return jresult;
2294 }
2295
2296
2297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2298   void * jresult ;
2299   double *arg1 = (double *) 0 ;
2300   doublep *result = 0 ;
2301
2302   arg1 = (double *)jarg1;
2303   {
2304     try {
2305       result = (doublep *)doublep_frompointer(arg1);
2306     } CALL_CATCH_EXCEPTION(0);
2307   }
2308
2309   jresult = (void *)result;
2310   return jresult;
2311 }
2312
2313
2314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2315   void * jresult ;
2316   uintp *result = 0 ;
2317
2318   {
2319     try {
2320       result = (uintp *)new_uintp();
2321     } CALL_CATCH_EXCEPTION(0);
2322   }
2323
2324   jresult = (void *)result;
2325   return jresult;
2326 }
2327
2328
2329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2330   uintp *arg1 = (uintp *) 0 ;
2331
2332   arg1 = (uintp *)jarg1;
2333   {
2334     try {
2335       delete_uintp(arg1);
2336     } CALL_CATCH_EXCEPTION();
2337   }
2338
2339 }
2340
2341
2342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2343   uintp *arg1 = (uintp *) 0 ;
2344   unsigned int arg2 ;
2345
2346   arg1 = (uintp *)jarg1;
2347   arg2 = (unsigned int)jarg2;
2348   {
2349     try {
2350       uintp_assign(arg1,arg2);
2351     } CALL_CATCH_EXCEPTION();
2352   }
2353
2354 }
2355
2356
2357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
2358   unsigned int jresult ;
2359   uintp *arg1 = (uintp *) 0 ;
2360   unsigned int result;
2361
2362   arg1 = (uintp *)jarg1;
2363   {
2364     try {
2365       result = (unsigned int)uintp_value(arg1);
2366     } CALL_CATCH_EXCEPTION(0);
2367   }
2368
2369   jresult = result;
2370   return jresult;
2371 }
2372
2373
2374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
2375   void * jresult ;
2376   uintp *arg1 = (uintp *) 0 ;
2377   unsigned int *result = 0 ;
2378
2379   arg1 = (uintp *)jarg1;
2380   {
2381     try {
2382       result = (unsigned int *)uintp_cast(arg1);
2383     } CALL_CATCH_EXCEPTION(0);
2384   }
2385
2386   jresult = (void *)result;
2387   return jresult;
2388 }
2389
2390
2391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
2392   void * jresult ;
2393   unsigned int *arg1 = (unsigned int *) 0 ;
2394   uintp *result = 0 ;
2395
2396   arg1 = (unsigned int *)jarg1;
2397   {
2398     try {
2399       result = (uintp *)uintp_frompointer(arg1);
2400     } CALL_CATCH_EXCEPTION(0);
2401   }
2402
2403   jresult = (void *)result;
2404   return jresult;
2405 }
2406
2407
2408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
2409   void * jresult ;
2410   ushortp *result = 0 ;
2411
2412   {
2413     try {
2414       result = (ushortp *)new_ushortp();
2415     } CALL_CATCH_EXCEPTION(0);
2416   }
2417
2418   jresult = (void *)result;
2419   return jresult;
2420 }
2421
2422
2423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
2424   ushortp *arg1 = (ushortp *) 0 ;
2425
2426   arg1 = (ushortp *)jarg1;
2427   {
2428     try {
2429       delete_ushortp(arg1);
2430     } CALL_CATCH_EXCEPTION();
2431   }
2432
2433 }
2434
2435
2436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
2437   ushortp *arg1 = (ushortp *) 0 ;
2438   unsigned short arg2 ;
2439
2440   arg1 = (ushortp *)jarg1;
2441   arg2 = (unsigned short)jarg2;
2442   {
2443     try {
2444       ushortp_assign(arg1,arg2);
2445     } CALL_CATCH_EXCEPTION();
2446   }
2447
2448 }
2449
2450
2451 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
2452   unsigned short jresult ;
2453   ushortp *arg1 = (ushortp *) 0 ;
2454   unsigned short result;
2455
2456   arg1 = (ushortp *)jarg1;
2457   {
2458     try {
2459       result = (unsigned short)ushortp_value(arg1);
2460     } CALL_CATCH_EXCEPTION(0);
2461   }
2462
2463   jresult = result;
2464   return jresult;
2465 }
2466
2467
2468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
2469   void * jresult ;
2470   ushortp *arg1 = (ushortp *) 0 ;
2471   unsigned short *result = 0 ;
2472
2473   arg1 = (ushortp *)jarg1;
2474   {
2475     try {
2476       result = (unsigned short *)ushortp_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_ushortp_frompointer(void * jarg1) {
2486   void * jresult ;
2487   unsigned short *arg1 = (unsigned short *) 0 ;
2488   ushortp *result = 0 ;
2489
2490   arg1 = (unsigned short *)jarg1;
2491   {
2492     try {
2493       result = (ushortp *)ushortp_frompointer(arg1);
2494     } CALL_CATCH_EXCEPTION(0);
2495   }
2496
2497   jresult = (void *)result;
2498   return jresult;
2499 }
2500
2501
2502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
2503   unsigned int jresult ;
2504   int arg1 ;
2505   unsigned int result;
2506
2507   arg1 = (int)jarg1;
2508   {
2509     try {
2510       result = (unsigned int)int_to_uint(arg1);
2511     } CALL_CATCH_EXCEPTION(0);
2512   }
2513
2514   jresult = result;
2515   return jresult;
2516 }
2517
2518
2519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
2520   char *arg1 = (char *) 0 ;
2521   char *arg2 = (char *) 0 ;
2522
2523   arg1 = (char *)jarg1;
2524   arg2 = (char *)jarg2;
2525   {
2526     try {
2527       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
2528     } CALL_CATCH_EXCEPTION();
2529   }
2530
2531 }
2532
2533
2534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
2535   void * jresult ;
2536   char *arg1 = (char *) 0 ;
2537   char *arg2 = (char *) 0 ;
2538   Dali::DaliException *result = 0 ;
2539
2540   arg1 = (char *)jarg1;
2541   arg2 = (char *)jarg2;
2542   {
2543     try {
2544       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
2545     } CALL_CATCH_EXCEPTION(0);
2546   }
2547
2548   jresult = (void *)result;
2549   return jresult;
2550 }
2551
2552
2553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
2554   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
2555   std::string arg2 = std::string(jarg2);
2556
2557   arg1 = (Dali::DaliException *)jarg1;
2558   {
2559     if (!arg2.empty()) {
2560       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
2561     } else {
2562       arg1->location = 0;
2563     }
2564   }
2565 }
2566
2567 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
2568   char * jresult ;
2569   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
2570   char *result = 0 ;
2571
2572   arg1 = (Dali::DaliException *)jarg1;
2573   result = (char *) ((arg1)->location);
2574   jresult = SWIG_csharp_string_callback((const char *)result);
2575   return jresult;
2576 }
2577
2578
2579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
2580   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
2581   std::string arg2 = std::string(jarg2);
2582
2583   arg1 = (Dali::DaliException *)jarg1;
2584   {
2585     if (!arg2.empty()) {
2586       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
2587     } else {
2588       arg1->condition = 0;
2589     }
2590   }
2591 }
2592
2593
2594 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
2595   char * jresult ;
2596   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
2597   char *result = 0 ;
2598
2599   arg1 = (Dali::DaliException *)jarg1;
2600   result = (char *) ((arg1)->condition);
2601   jresult = SWIG_csharp_string_callback((const char *)result);
2602   return jresult;
2603 }
2604
2605
2606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
2607   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
2608
2609   arg1 = (Dali::DaliException *)jarg1;
2610   {
2611     try {
2612       delete arg1;
2613     } CALL_CATCH_EXCEPTION();
2614   }
2615
2616 }
2617
2618
2619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
2620   void * jresult ;
2621   Dali::Uint16Pair *result = 0 ;
2622
2623   {
2624     try {
2625       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
2626     } CALL_CATCH_EXCEPTION(0);
2627   }
2628
2629   jresult = (void *)result;
2630   return jresult;
2631 }
2632
2633
2634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
2635   void * jresult ;
2636   uint32_t arg1 ;
2637   uint32_t arg2 ;
2638   Dali::Uint16Pair *result = 0 ;
2639
2640   arg1 = (uint32_t)jarg1;
2641   arg2 = (uint32_t)jarg2;
2642   {
2643     try {
2644       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
2645     } CALL_CATCH_EXCEPTION(0);
2646   }
2647
2648   jresult = (void *)result;
2649   return jresult;
2650 }
2651
2652
2653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
2654   void * jresult ;
2655   Dali::Uint16Pair *arg1 = 0 ;
2656   Dali::Uint16Pair *result = 0 ;
2657
2658   arg1 = (Dali::Uint16Pair *)jarg1;
2659   if (!arg1) {
2660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
2661     return 0;
2662   }
2663   {
2664     try {
2665       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
2666     } CALL_CATCH_EXCEPTION(0);
2667   }
2668
2669   jresult = (void *)result;
2670   return jresult;
2671 }
2672
2673
2674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
2675   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
2676   uint16_t arg2 ;
2677
2678   arg1 = (Dali::Uint16Pair *)jarg1;
2679   arg2 = (uint16_t)jarg2;
2680   {
2681     try {
2682       (arg1)->SetWidth(arg2);
2683     } CALL_CATCH_EXCEPTION();
2684   }
2685
2686 }
2687
2688
2689 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
2690   unsigned short jresult ;
2691   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
2692   uint16_t result;
2693
2694   arg1 = (Dali::Uint16Pair *)jarg1;
2695   {
2696     try {
2697       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
2698     } CALL_CATCH_EXCEPTION(0);
2699   }
2700
2701   jresult = result;
2702   return jresult;
2703 }
2704
2705
2706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
2707   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
2708   uint16_t arg2 ;
2709
2710   arg1 = (Dali::Uint16Pair *)jarg1;
2711   arg2 = (uint16_t)jarg2;
2712   {
2713     try {
2714       (arg1)->SetHeight(arg2);
2715     } CALL_CATCH_EXCEPTION();
2716   }
2717
2718 }
2719
2720
2721 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
2722   unsigned short jresult ;
2723   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
2724   uint16_t result;
2725
2726   arg1 = (Dali::Uint16Pair *)jarg1;
2727   {
2728     try {
2729       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
2730     } CALL_CATCH_EXCEPTION(0);
2731   }
2732
2733   jresult = result;
2734   return jresult;
2735 }
2736
2737
2738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
2739   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
2740   uint16_t arg2 ;
2741
2742   arg1 = (Dali::Uint16Pair *)jarg1;
2743   arg2 = (uint16_t)jarg2;
2744   {
2745     try {
2746       (arg1)->SetX(arg2);
2747     } CALL_CATCH_EXCEPTION();
2748   }
2749
2750 }
2751
2752
2753 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
2754   unsigned short jresult ;
2755   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
2756   uint16_t result;
2757
2758   arg1 = (Dali::Uint16Pair *)jarg1;
2759   {
2760     try {
2761       result = ((Dali::Uint16Pair const *)arg1)->GetX();
2762     } CALL_CATCH_EXCEPTION(0);
2763   }
2764
2765   jresult = result;
2766   return jresult;
2767 }
2768
2769
2770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
2771   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
2772   uint16_t arg2 ;
2773
2774   arg1 = (Dali::Uint16Pair *)jarg1;
2775   arg2 = (uint16_t)jarg2;
2776   {
2777     try {
2778       (arg1)->SetY(arg2);
2779     } CALL_CATCH_EXCEPTION();
2780   }
2781
2782 }
2783
2784
2785 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
2786   unsigned short jresult ;
2787   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
2788   uint16_t result;
2789
2790   arg1 = (Dali::Uint16Pair *)jarg1;
2791   {
2792     try {
2793       result = ((Dali::Uint16Pair const *)arg1)->GetY();
2794     } CALL_CATCH_EXCEPTION(0);
2795   }
2796
2797   jresult = result;
2798   return jresult;
2799 }
2800
2801
2802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
2803   void * jresult ;
2804   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
2805   Dali::Uint16Pair *arg2 = 0 ;
2806   Dali::Uint16Pair *result = 0 ;
2807
2808   arg1 = (Dali::Uint16Pair *)jarg1;
2809   arg2 = (Dali::Uint16Pair *)jarg2;
2810   if (!arg2) {
2811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
2812     return 0;
2813   }
2814   {
2815     try {
2816       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
2817     } CALL_CATCH_EXCEPTION(0);
2818   }
2819
2820   jresult = (void *)result;
2821   return jresult;
2822 }
2823
2824
2825 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
2826   bool jresult ;
2827   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
2828   Dali::Uint16Pair *arg2 = 0 ;
2829   bool result;
2830
2831   arg1 = (Dali::Uint16Pair *)jarg1;
2832   arg2 = (Dali::Uint16Pair *)jarg2;
2833   if (!arg2) {
2834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
2835     return 0;
2836   }
2837   {
2838     try {
2839       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
2840     } CALL_CATCH_EXCEPTION(0);
2841   }
2842
2843   jresult = result;
2844   return jresult;
2845 }
2846
2847
2848 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
2849   bool jresult ;
2850   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
2851   Dali::Uint16Pair *arg2 = 0 ;
2852   bool result;
2853
2854   arg1 = (Dali::Uint16Pair *)jarg1;
2855   arg2 = (Dali::Uint16Pair *)jarg2;
2856   if (!arg2) {
2857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
2858     return 0;
2859   }
2860   {
2861     try {
2862       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
2863     } CALL_CATCH_EXCEPTION(0);
2864   }
2865
2866   jresult = result;
2867   return jresult;
2868 }
2869
2870
2871 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
2872   bool jresult ;
2873   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
2874   Dali::Uint16Pair *arg2 = 0 ;
2875   bool result;
2876
2877   arg1 = (Dali::Uint16Pair *)jarg1;
2878   arg2 = (Dali::Uint16Pair *)jarg2;
2879   if (!arg2) {
2880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
2881     return 0;
2882   }
2883   {
2884     try {
2885       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
2886     } CALL_CATCH_EXCEPTION(0);
2887   }
2888
2889   jresult = result;
2890   return jresult;
2891 }
2892
2893
2894 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
2895   bool jresult ;
2896   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
2897   Dali::Uint16Pair *arg2 = 0 ;
2898   bool result;
2899
2900   arg1 = (Dali::Uint16Pair *)jarg1;
2901   arg2 = (Dali::Uint16Pair *)jarg2;
2902   if (!arg2) {
2903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
2904     return 0;
2905   }
2906   {
2907     try {
2908       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
2909     } CALL_CATCH_EXCEPTION(0);
2910   }
2911
2912   jresult = result;
2913   return jresult;
2914 }
2915
2916
2917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
2918   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
2919
2920   arg1 = (Dali::Uint16Pair *)jarg1;
2921   {
2922     try {
2923       delete arg1;
2924     } CALL_CATCH_EXCEPTION();
2925   }
2926
2927 }
2928
2929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Int32Pair__SWIG_0() {
2930   void * jresult ;
2931   Dali::Int32Pair *result = 0 ;
2932
2933   {
2934     try {
2935       result = (Dali::Int32Pair *)new Dali::Int32Pair();
2936     } CALL_CATCH_EXCEPTION(0);
2937   }
2938
2939   jresult = (void *)result;
2940   return jresult;
2941 }
2942
2943
2944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Int32Pair__SWIG_1(int32_t x, int32_t y) {
2945   void * jresult ;
2946   Dali::Int32Pair *result = 0 ;
2947
2948   {
2949     try {
2950       result = (Dali::Int32Pair *)new Dali::Int32Pair(x,y);
2951     } CALL_CATCH_EXCEPTION(0);
2952   }
2953
2954   jresult = (void *)result;
2955   return jresult;
2956 }
2957
2958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Int32Pair_SetX(void * int32Pair, int32_t x) {
2959   Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ;
2960
2961   {
2962     try {
2963       (pInt32Pair)->SetX(x);
2964     } CALL_CATCH_EXCEPTION();
2965   }
2966 }
2967
2968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Int32Pair_GetX(void * int32Pair) {
2969   int result ;
2970   Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair);
2971
2972   {
2973     try {
2974       result = ((Dali::Int32Pair const *)pInt32Pair)->GetX();
2975     } CALL_CATCH_EXCEPTION(0);
2976   }
2977
2978   return result;
2979 }
2980
2981
2982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Int32Pair_SetY(void * int32Pair, int32_t y) {
2983   Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ;
2984
2985   {
2986     try {
2987       (pInt32Pair)->SetY(y);
2988     } CALL_CATCH_EXCEPTION();
2989   }
2990
2991 }
2992
2993
2994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Int32Pair_GetY(void * int32Pair) {
2995   Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ;
2996   int result;
2997
2998   {
2999     try {
3000       result = ((Dali::Int32Pair const *)pInt32Pair)->GetY();
3001     } CALL_CATCH_EXCEPTION(0);
3002   }
3003
3004   return result;
3005 }
3006
3007
3008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Int32Pair(void * int32Pair) {
3009   Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ;
3010
3011   {
3012     try {
3013       delete pInt32Pair;
3014     } CALL_CATCH_EXCEPTION();
3015   }
3016
3017 }
3018
3019
3020
3021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
3022   void * jresult ;
3023   Dali::Degree *result = 0 ;
3024
3025   {
3026     try {
3027       result = (Dali::Degree *)new Dali::Degree();
3028     } CALL_CATCH_EXCEPTION(0);
3029   }
3030
3031   jresult = (void *)result;
3032   return jresult;
3033 }
3034
3035
3036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
3037   void * jresult ;
3038   float arg1 ;
3039   Dali::Degree *result = 0 ;
3040
3041   arg1 = (float)jarg1;
3042   {
3043     try {
3044       result = (Dali::Degree *)new Dali::Degree(arg1);
3045     } CALL_CATCH_EXCEPTION(0);
3046   }
3047
3048   jresult = (void *)result;
3049   return jresult;
3050 }
3051
3052
3053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
3054   void * jresult ;
3055   Dali::Radian arg1 ;
3056   Dali::Radian *argp1 ;
3057   Dali::Degree *result = 0 ;
3058
3059   argp1 = (Dali::Radian *)jarg1;
3060   if (!argp1) {
3061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3062     return 0;
3063   }
3064   arg1 = *argp1;
3065   {
3066     try {
3067       result = (Dali::Degree *)new Dali::Degree(arg1);
3068     } CALL_CATCH_EXCEPTION(0);
3069   }
3070
3071   jresult = (void *)result;
3072   return jresult;
3073 }
3074
3075
3076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
3077   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
3078   float arg2 ;
3079
3080   arg1 = (Dali::Degree *)jarg1;
3081   arg2 = (float)jarg2;
3082   if (arg1) (arg1)->degree = arg2;
3083 }
3084
3085
3086 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
3087   float jresult ;
3088   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
3089   float result;
3090
3091   arg1 = (Dali::Degree *)jarg1;
3092   result = (float) ((arg1)->degree);
3093   jresult = result;
3094   return jresult;
3095 }
3096
3097
3098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
3099   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
3100
3101   arg1 = (Dali::Degree *)jarg1;
3102   {
3103     try {
3104       delete arg1;
3105     } CALL_CATCH_EXCEPTION();
3106   }
3107
3108 }
3109
3110
3111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
3112   void * jresult ;
3113   Dali::Radian *result = 0 ;
3114
3115   result = (Dali::Radian *)&Dali::ANGLE_360;
3116   jresult = (void *)result;
3117   return jresult;
3118 }
3119
3120
3121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
3122   void * jresult ;
3123   Dali::Radian *result = 0 ;
3124
3125   result = (Dali::Radian *)&Dali::ANGLE_315;
3126   jresult = (void *)result;
3127   return jresult;
3128 }
3129
3130
3131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
3132   void * jresult ;
3133   Dali::Radian *result = 0 ;
3134
3135   result = (Dali::Radian *)&Dali::ANGLE_270;
3136   jresult = (void *)result;
3137   return jresult;
3138 }
3139
3140
3141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
3142   void * jresult ;
3143   Dali::Radian *result = 0 ;
3144
3145   result = (Dali::Radian *)&Dali::ANGLE_225;
3146   jresult = (void *)result;
3147   return jresult;
3148 }
3149
3150
3151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
3152   void * jresult ;
3153   Dali::Radian *result = 0 ;
3154
3155   result = (Dali::Radian *)&Dali::ANGLE_180;
3156   jresult = (void *)result;
3157   return jresult;
3158 }
3159
3160
3161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
3162   void * jresult ;
3163   Dali::Radian *result = 0 ;
3164
3165   result = (Dali::Radian *)&Dali::ANGLE_135;
3166   jresult = (void *)result;
3167   return jresult;
3168 }
3169
3170
3171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
3172   void * jresult ;
3173   Dali::Radian *result = 0 ;
3174
3175   result = (Dali::Radian *)&Dali::ANGLE_120;
3176   jresult = (void *)result;
3177   return jresult;
3178 }
3179
3180
3181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
3182   void * jresult ;
3183   Dali::Radian *result = 0 ;
3184
3185   result = (Dali::Radian *)&Dali::ANGLE_90;
3186   jresult = (void *)result;
3187   return jresult;
3188 }
3189
3190
3191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
3192   void * jresult ;
3193   Dali::Radian *result = 0 ;
3194
3195   result = (Dali::Radian *)&Dali::ANGLE_60;
3196   jresult = (void *)result;
3197   return jresult;
3198 }
3199
3200
3201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
3202   void * jresult ;
3203   Dali::Radian *result = 0 ;
3204
3205   result = (Dali::Radian *)&Dali::ANGLE_45;
3206   jresult = (void *)result;
3207   return jresult;
3208 }
3209
3210
3211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
3212   void * jresult ;
3213   Dali::Radian *result = 0 ;
3214
3215   result = (Dali::Radian *)&Dali::ANGLE_30;
3216   jresult = (void *)result;
3217   return jresult;
3218 }
3219
3220
3221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
3222   void * jresult ;
3223   Dali::Radian *result = 0 ;
3224
3225   result = (Dali::Radian *)&Dali::ANGLE_0;
3226   jresult = (void *)result;
3227   return jresult;
3228 }
3229
3230
3231 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
3232   bool jresult ;
3233   Dali::Degree *arg1 = 0 ;
3234   Dali::Degree *arg2 = 0 ;
3235   bool result;
3236
3237   arg1 = (Dali::Degree *)jarg1;
3238   if (!arg1) {
3239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
3240     return 0;
3241   }
3242   arg2 = (Dali::Degree *)jarg2;
3243   if (!arg2) {
3244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
3245     return 0;
3246   }
3247   {
3248     try {
3249       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
3250     } CALL_CATCH_EXCEPTION(0);
3251   }
3252
3253   jresult = result;
3254   return jresult;
3255 }
3256
3257
3258 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
3259   bool jresult ;
3260   Dali::Degree *arg1 = 0 ;
3261   Dali::Degree *arg2 = 0 ;
3262   bool result;
3263
3264   arg1 = (Dali::Degree *)jarg1;
3265   if (!arg1) {
3266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
3267     return 0;
3268   }
3269   arg2 = (Dali::Degree *)jarg2;
3270   if (!arg2) {
3271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
3272     return 0;
3273   }
3274   {
3275     try {
3276       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
3277     } CALL_CATCH_EXCEPTION(0);
3278   }
3279
3280   jresult = result;
3281   return jresult;
3282 }
3283
3284
3285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
3286   void * jresult ;
3287   Dali::Degree arg1 ;
3288   float arg2 ;
3289   float arg3 ;
3290   Dali::Degree *argp1 ;
3291   Dali::Degree result;
3292
3293   argp1 = (Dali::Degree *)jarg1;
3294   if (!argp1) {
3295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
3296     return 0;
3297   }
3298   arg1 = *argp1;
3299   arg2 = (float)jarg2;
3300   arg3 = (float)jarg3;
3301   {
3302     try {
3303       result = Dali::Clamp(arg1,arg2,arg3);
3304     } CALL_CATCH_EXCEPTION(0);
3305   }
3306
3307   jresult = new Dali::Degree((const Dali::Degree &)result);
3308   return jresult;
3309 }
3310
3311
3312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
3313   void * jresult ;
3314   Dali::Radian *result = 0 ;
3315
3316   {
3317     try {
3318       result = (Dali::Radian *)new Dali::Radian();
3319     } CALL_CATCH_EXCEPTION(0);
3320   }
3321
3322   jresult = (void *)result;
3323   return jresult;
3324 }
3325
3326
3327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
3328   void * jresult ;
3329   float arg1 ;
3330   Dali::Radian *result = 0 ;
3331
3332   arg1 = (float)jarg1;
3333   {
3334     try {
3335       result = (Dali::Radian *)new Dali::Radian(arg1);
3336     } CALL_CATCH_EXCEPTION(0);
3337   }
3338
3339   jresult = (void *)result;
3340   return jresult;
3341 }
3342
3343
3344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
3345   void * jresult ;
3346   Dali::Degree arg1 ;
3347   Dali::Degree *argp1 ;
3348   Dali::Radian *result = 0 ;
3349
3350   argp1 = (Dali::Degree *)jarg1;
3351   if (!argp1) {
3352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
3353     return 0;
3354   }
3355   arg1 = *argp1;
3356   {
3357     try {
3358       result = (Dali::Radian *)new Dali::Radian(arg1);
3359     } CALL_CATCH_EXCEPTION(0);
3360   }
3361
3362   jresult = (void *)result;
3363   return jresult;
3364 }
3365
3366
3367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
3368   void * jresult ;
3369   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
3370   float arg2 ;
3371   Dali::Radian *result = 0 ;
3372
3373   arg1 = (Dali::Radian *)jarg1;
3374   arg2 = (float)jarg2;
3375   {
3376     try {
3377       result = (Dali::Radian *) &(arg1)->operator =(arg2);
3378     } CALL_CATCH_EXCEPTION(0);
3379   }
3380
3381   jresult = (void *)result;
3382   return jresult;
3383 }
3384
3385
3386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
3387   void * jresult ;
3388   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
3389   Dali::Degree arg2 ;
3390   Dali::Degree *argp2 ;
3391   Dali::Radian *result = 0 ;
3392
3393   arg1 = (Dali::Radian *)jarg1;
3394   argp2 = (Dali::Degree *)jarg2;
3395   if (!argp2) {
3396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
3397     return 0;
3398   }
3399   arg2 = *argp2;
3400   {
3401     try {
3402       result = (Dali::Radian *) &(arg1)->operator =(arg2);
3403     } CALL_CATCH_EXCEPTION(0);
3404   }
3405
3406   jresult = (void *)result;
3407   return jresult;
3408 }
3409
3410
3411 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
3412   float jresult ;
3413   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
3414   float result;
3415
3416   arg1 = (Dali::Radian *)jarg1;
3417   {
3418     try {
3419       result = (float)((Dali::Radian const *)arg1)->operator float();
3420     } CALL_CATCH_EXCEPTION(0);
3421   }
3422
3423   jresult = result;
3424   return jresult;
3425 }
3426
3427
3428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
3429   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
3430   float arg2 ;
3431
3432   arg1 = (Dali::Radian *)jarg1;
3433   arg2 = (float)jarg2;
3434   if (arg1) (arg1)->radian = arg2;
3435 }
3436
3437
3438 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
3439   float jresult ;
3440   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
3441   float result;
3442
3443   arg1 = (Dali::Radian *)jarg1;
3444   result = (float) ((arg1)->radian);
3445   jresult = result;
3446   return jresult;
3447 }
3448
3449
3450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
3451   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
3452
3453   arg1 = (Dali::Radian *)jarg1;
3454   {
3455     try {
3456       delete arg1;
3457     } CALL_CATCH_EXCEPTION();
3458   }
3459
3460 }
3461
3462
3463 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
3464   bool jresult ;
3465   Dali::Radian arg1 ;
3466   Dali::Radian arg2 ;
3467   Dali::Radian *argp1 ;
3468   Dali::Radian *argp2 ;
3469   bool result;
3470
3471   argp1 = (Dali::Radian *)jarg1;
3472   if (!argp1) {
3473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3474     return 0;
3475   }
3476   arg1 = *argp1;
3477   argp2 = (Dali::Radian *)jarg2;
3478   if (!argp2) {
3479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3480     return 0;
3481   }
3482   arg2 = *argp2;
3483   {
3484     try {
3485       result = (bool)Dali::operator ==(arg1,arg2);
3486     } CALL_CATCH_EXCEPTION(0);
3487   }
3488
3489   jresult = result;
3490   return jresult;
3491 }
3492
3493
3494 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
3495   bool jresult ;
3496   Dali::Radian arg1 ;
3497   Dali::Radian arg2 ;
3498   Dali::Radian *argp1 ;
3499   Dali::Radian *argp2 ;
3500   bool result;
3501
3502   argp1 = (Dali::Radian *)jarg1;
3503   if (!argp1) {
3504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3505     return 0;
3506   }
3507   arg1 = *argp1;
3508   argp2 = (Dali::Radian *)jarg2;
3509   if (!argp2) {
3510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3511     return 0;
3512   }
3513   arg2 = *argp2;
3514   {
3515     try {
3516       result = (bool)Dali::operator !=(arg1,arg2);
3517     } CALL_CATCH_EXCEPTION(0);
3518   }
3519
3520   jresult = result;
3521   return jresult;
3522 }
3523
3524
3525 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
3526   bool jresult ;
3527   Dali::Radian arg1 ;
3528   Dali::Degree arg2 ;
3529   Dali::Radian *argp1 ;
3530   Dali::Degree *argp2 ;
3531   bool result;
3532
3533   argp1 = (Dali::Radian *)jarg1;
3534   if (!argp1) {
3535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3536     return 0;
3537   }
3538   arg1 = *argp1;
3539   argp2 = (Dali::Degree *)jarg2;
3540   if (!argp2) {
3541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
3542     return 0;
3543   }
3544   arg2 = *argp2;
3545   {
3546     try {
3547       result = (bool)Dali::operator ==(arg1,arg2);
3548     } CALL_CATCH_EXCEPTION(0);
3549   }
3550
3551   jresult = result;
3552   return jresult;
3553 }
3554
3555
3556 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
3557   bool jresult ;
3558   Dali::Radian arg1 ;
3559   Dali::Degree arg2 ;
3560   Dali::Radian *argp1 ;
3561   Dali::Degree *argp2 ;
3562   bool result;
3563
3564   argp1 = (Dali::Radian *)jarg1;
3565   if (!argp1) {
3566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3567     return 0;
3568   }
3569   arg1 = *argp1;
3570   argp2 = (Dali::Degree *)jarg2;
3571   if (!argp2) {
3572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
3573     return 0;
3574   }
3575   arg2 = *argp2;
3576   {
3577     try {
3578       result = (bool)Dali::operator !=(arg1,arg2);
3579     } CALL_CATCH_EXCEPTION(0);
3580   }
3581
3582   jresult = result;
3583   return jresult;
3584 }
3585
3586
3587 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
3588   bool jresult ;
3589   Dali::Degree arg1 ;
3590   Dali::Radian arg2 ;
3591   Dali::Degree *argp1 ;
3592   Dali::Radian *argp2 ;
3593   bool result;
3594
3595   argp1 = (Dali::Degree *)jarg1;
3596   if (!argp1) {
3597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
3598     return 0;
3599   }
3600   arg1 = *argp1;
3601   argp2 = (Dali::Radian *)jarg2;
3602   if (!argp2) {
3603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3604     return 0;
3605   }
3606   arg2 = *argp2;
3607   {
3608     try {
3609       result = (bool)Dali::operator ==(arg1,arg2);
3610     } CALL_CATCH_EXCEPTION(0);
3611   }
3612
3613   jresult = result;
3614   return jresult;
3615 }
3616
3617
3618 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
3619   bool jresult ;
3620   Dali::Degree arg1 ;
3621   Dali::Radian arg2 ;
3622   Dali::Degree *argp1 ;
3623   Dali::Radian *argp2 ;
3624   bool result;
3625
3626   argp1 = (Dali::Degree *)jarg1;
3627   if (!argp1) {
3628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
3629     return 0;
3630   }
3631   arg1 = *argp1;
3632   argp2 = (Dali::Radian *)jarg2;
3633   if (!argp2) {
3634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3635     return 0;
3636   }
3637   arg2 = *argp2;
3638   {
3639     try {
3640       result = (bool)Dali::operator !=(arg1,arg2);
3641     } CALL_CATCH_EXCEPTION(0);
3642   }
3643
3644   jresult = result;
3645   return jresult;
3646 }
3647
3648
3649 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
3650   bool jresult ;
3651   Dali::Radian arg1 ;
3652   Dali::Radian arg2 ;
3653   Dali::Radian *argp1 ;
3654   Dali::Radian *argp2 ;
3655   bool result;
3656
3657   argp1 = (Dali::Radian *)jarg1;
3658   if (!argp1) {
3659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3660     return 0;
3661   }
3662   arg1 = *argp1;
3663   argp2 = (Dali::Radian *)jarg2;
3664   if (!argp2) {
3665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3666     return 0;
3667   }
3668   arg2 = *argp2;
3669   {
3670     try {
3671       result = (bool)Dali::operator >(arg1,arg2);
3672     } CALL_CATCH_EXCEPTION(0);
3673   }
3674
3675   jresult = result;
3676   return jresult;
3677 }
3678
3679
3680 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
3681   bool jresult ;
3682   Dali::Radian arg1 ;
3683   Dali::Degree arg2 ;
3684   Dali::Radian *argp1 ;
3685   Dali::Degree *argp2 ;
3686   bool result;
3687
3688   argp1 = (Dali::Radian *)jarg1;
3689   if (!argp1) {
3690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3691     return 0;
3692   }
3693   arg1 = *argp1;
3694   argp2 = (Dali::Degree *)jarg2;
3695   if (!argp2) {
3696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
3697     return 0;
3698   }
3699   arg2 = *argp2;
3700   {
3701     try {
3702       result = (bool)Dali::operator >(arg1,arg2);
3703     } CALL_CATCH_EXCEPTION(0);
3704   }
3705
3706   jresult = result;
3707   return jresult;
3708 }
3709
3710
3711 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
3712   bool jresult ;
3713   Dali::Degree arg1 ;
3714   Dali::Radian arg2 ;
3715   Dali::Degree *argp1 ;
3716   Dali::Radian *argp2 ;
3717   bool result;
3718
3719   argp1 = (Dali::Degree *)jarg1;
3720   if (!argp1) {
3721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
3722     return 0;
3723   }
3724   arg1 = *argp1;
3725   argp2 = (Dali::Radian *)jarg2;
3726   if (!argp2) {
3727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3728     return 0;
3729   }
3730   arg2 = *argp2;
3731   {
3732     try {
3733       result = (bool)Dali::operator >(arg1,arg2);
3734     } CALL_CATCH_EXCEPTION(0);
3735   }
3736
3737   jresult = result;
3738   return jresult;
3739 }
3740
3741
3742 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
3743   bool jresult ;
3744   Dali::Radian arg1 ;
3745   Dali::Radian arg2 ;
3746   Dali::Radian *argp1 ;
3747   Dali::Radian *argp2 ;
3748   bool result;
3749
3750   argp1 = (Dali::Radian *)jarg1;
3751   if (!argp1) {
3752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3753     return 0;
3754   }
3755   arg1 = *argp1;
3756   argp2 = (Dali::Radian *)jarg2;
3757   if (!argp2) {
3758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3759     return 0;
3760   }
3761   arg2 = *argp2;
3762   {
3763     try {
3764       result = (bool)Dali::operator <(arg1,arg2);
3765     } CALL_CATCH_EXCEPTION(0);
3766   }
3767
3768   jresult = result;
3769   return jresult;
3770 }
3771
3772
3773 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
3774   bool jresult ;
3775   Dali::Radian arg1 ;
3776   Dali::Degree arg2 ;
3777   Dali::Radian *argp1 ;
3778   Dali::Degree *argp2 ;
3779   bool result;
3780
3781   argp1 = (Dali::Radian *)jarg1;
3782   if (!argp1) {
3783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3784     return 0;
3785   }
3786   arg1 = *argp1;
3787   argp2 = (Dali::Degree *)jarg2;
3788   if (!argp2) {
3789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
3790     return 0;
3791   }
3792   arg2 = *argp2;
3793   {
3794     try {
3795       result = (bool)Dali::operator <(arg1,arg2);
3796     } CALL_CATCH_EXCEPTION(0);
3797   }
3798
3799   jresult = result;
3800   return jresult;
3801 }
3802
3803
3804 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
3805   bool jresult ;
3806   Dali::Degree arg1 ;
3807   Dali::Radian arg2 ;
3808   Dali::Degree *argp1 ;
3809   Dali::Radian *argp2 ;
3810   bool result;
3811
3812   argp1 = (Dali::Degree *)jarg1;
3813   if (!argp1) {
3814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
3815     return 0;
3816   }
3817   arg1 = *argp1;
3818   argp2 = (Dali::Radian *)jarg2;
3819   if (!argp2) {
3820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3821     return 0;
3822   }
3823   arg2 = *argp2;
3824   {
3825     try {
3826       result = (bool)Dali::operator <(arg1,arg2);
3827     } CALL_CATCH_EXCEPTION(0);
3828   }
3829
3830   jresult = result;
3831   return jresult;
3832 }
3833
3834
3835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
3836   void * jresult ;
3837   Dali::Radian arg1 ;
3838   float arg2 ;
3839   Dali::Radian *argp1 ;
3840   Dali::Radian result;
3841
3842   argp1 = (Dali::Radian *)jarg1;
3843   if (!argp1) {
3844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3845     return 0;
3846   }
3847   arg1 = *argp1;
3848   arg2 = (float)jarg2;
3849   {
3850     try {
3851       result = Dali::operator *(arg1,arg2);
3852     } CALL_CATCH_EXCEPTION(0);
3853   }
3854
3855   jresult = new Dali::Radian((const Dali::Radian &)result);
3856   return jresult;
3857 }
3858
3859
3860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
3861   void * jresult ;
3862   Dali::Radian arg1 ;
3863   Dali::Radian *argp1 ;
3864   Dali::Radian result;
3865
3866   argp1 = (Dali::Radian *)jarg1;
3867   if (!argp1) {
3868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3869     return 0;
3870   }
3871   arg1 = *argp1;
3872   {
3873     try {
3874       result = Dali::operator -(arg1);
3875     } CALL_CATCH_EXCEPTION(0);
3876   }
3877
3878   jresult = new Dali::Radian((const Dali::Radian &)result);
3879   return jresult;
3880 }
3881
3882
3883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
3884   void * jresult ;
3885   Dali::Radian arg1 ;
3886   float arg2 ;
3887   float arg3 ;
3888   Dali::Radian *argp1 ;
3889   Dali::Radian result;
3890
3891   argp1 = (Dali::Radian *)jarg1;
3892   if (!argp1) {
3893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3894     return 0;
3895   }
3896   arg1 = *argp1;
3897   arg2 = (float)jarg2;
3898   arg3 = (float)jarg3;
3899   {
3900     try {
3901       result = Dali::Clamp(arg1,arg2,arg3);
3902     } CALL_CATCH_EXCEPTION(0);
3903   }
3904
3905   jresult = new Dali::Radian((const Dali::Radian &)result);
3906   return jresult;
3907 }
3908
3909
3910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
3911   void * jresult ;
3912   Dali::Matrix *result = 0 ;
3913
3914   {
3915     try {
3916       result = (Dali::Matrix *)new Dali::Matrix();
3917     } CALL_CATCH_EXCEPTION(0);
3918   }
3919
3920   jresult = (void *)result;
3921   return jresult;
3922 }
3923
3924
3925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(bool jarg1) {
3926   void * jresult ;
3927   bool arg1 ;
3928   Dali::Matrix *result = 0 ;
3929
3930   arg1 = jarg1 ? true : false;
3931   {
3932     try {
3933       result = (Dali::Matrix *)new Dali::Matrix(arg1);
3934     } CALL_CATCH_EXCEPTION(0);
3935   }
3936
3937   jresult = (void *)result;
3938   return jresult;
3939 }
3940
3941
3942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
3943   void * jresult ;
3944   float *arg1 = (float *) 0 ;
3945   Dali::Matrix *result = 0 ;
3946
3947   arg1 = jarg1;
3948   {
3949     try {
3950       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
3951     } CALL_CATCH_EXCEPTION(0);
3952   }
3953
3954   jresult = (void *)result;
3955
3956
3957   return jresult;
3958 }
3959
3960
3961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
3962   void * jresult ;
3963   Dali::Quaternion *arg1 = 0 ;
3964   Dali::Matrix *result = 0 ;
3965
3966   arg1 = (Dali::Quaternion *)jarg1;
3967   if (!arg1) {
3968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
3969     return 0;
3970   }
3971   {
3972     try {
3973       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
3974     } CALL_CATCH_EXCEPTION(0);
3975   }
3976
3977   jresult = (void *)result;
3978   return jresult;
3979 }
3980
3981
3982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
3983   void * jresult ;
3984   Dali::Matrix *arg1 = 0 ;
3985   Dali::Matrix *result = 0 ;
3986
3987   arg1 = (Dali::Matrix *)jarg1;
3988   if (!arg1) {
3989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
3990     return 0;
3991   }
3992   {
3993     try {
3994       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
3995     } CALL_CATCH_EXCEPTION(0);
3996   }
3997
3998   jresult = (void *)result;
3999   return jresult;
4000 }
4001
4002
4003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
4004   void * jresult ;
4005   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4006   Dali::Matrix *arg2 = 0 ;
4007   Dali::Matrix *result = 0 ;
4008
4009   arg1 = (Dali::Matrix *)jarg1;
4010   arg2 = (Dali::Matrix *)jarg2;
4011   if (!arg2) {
4012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
4013     return 0;
4014   }
4015   {
4016     try {
4017       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
4018     } CALL_CATCH_EXCEPTION(0);
4019   }
4020
4021   jresult = (void *)result;
4022   return jresult;
4023 }
4024
4025
4026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
4027   void * jresult ;
4028   Dali::Matrix *result = 0 ;
4029
4030   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
4031   jresult = (void *)result;
4032   return jresult;
4033 }
4034
4035
4036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
4037   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4038
4039   arg1 = (Dali::Matrix *)jarg1;
4040   {
4041     try {
4042       (arg1)->SetIdentity();
4043     } CALL_CATCH_EXCEPTION();
4044   }
4045
4046 }
4047
4048
4049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
4050   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4051   Dali::Vector3 *arg2 = 0 ;
4052
4053   arg1 = (Dali::Matrix *)jarg1;
4054   arg2 = (Dali::Vector3 *)jarg2;
4055   if (!arg2) {
4056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4057     return ;
4058   }
4059   {
4060     try {
4061       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
4062     } CALL_CATCH_EXCEPTION();
4063   }
4064
4065 }
4066
4067
4068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
4069   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4070   Dali::Matrix *arg2 = 0 ;
4071
4072   arg1 = (Dali::Matrix *)jarg1;
4073   arg2 = (Dali::Matrix *)jarg2;
4074   if (!arg2) {
4075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
4076     return ;
4077   }
4078   {
4079     try {
4080       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
4081     } CALL_CATCH_EXCEPTION();
4082   }
4083
4084 }
4085
4086
4087 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
4088   bool jresult ;
4089   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4090   bool result;
4091
4092   arg1 = (Dali::Matrix *)jarg1;
4093   {
4094     try {
4095       result = (bool)(arg1)->Invert();
4096     } CALL_CATCH_EXCEPTION(0);
4097   }
4098
4099   jresult = result;
4100   return jresult;
4101 }
4102
4103
4104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
4105   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4106
4107   arg1 = (Dali::Matrix *)jarg1;
4108   {
4109     try {
4110       (arg1)->Transpose();
4111     } CALL_CATCH_EXCEPTION();
4112   }
4113
4114 }
4115
4116
4117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
4118   void * jresult ;
4119   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4120   Dali::Vector3 result;
4121
4122   arg1 = (Dali::Matrix *)jarg1;
4123   {
4124     try {
4125       result = ((Dali::Matrix const *)arg1)->GetXAxis();
4126     } CALL_CATCH_EXCEPTION(0);
4127   }
4128
4129   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4130   return jresult;
4131 }
4132
4133
4134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
4135   void * jresult ;
4136   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4137   Dali::Vector3 result;
4138
4139   arg1 = (Dali::Matrix *)jarg1;
4140   {
4141     try {
4142       result = ((Dali::Matrix const *)arg1)->GetYAxis();
4143     } CALL_CATCH_EXCEPTION(0);
4144   }
4145
4146   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4147   return jresult;
4148 }
4149
4150
4151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
4152   void * jresult ;
4153   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4154   Dali::Vector3 result;
4155
4156   arg1 = (Dali::Matrix *)jarg1;
4157   {
4158     try {
4159       result = ((Dali::Matrix const *)arg1)->GetZAxis();
4160     } CALL_CATCH_EXCEPTION(0);
4161   }
4162
4163   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4164   return jresult;
4165 }
4166
4167
4168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
4169   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4170   Dali::Vector3 *arg2 = 0 ;
4171
4172   arg1 = (Dali::Matrix *)jarg1;
4173   arg2 = (Dali::Vector3 *)jarg2;
4174   if (!arg2) {
4175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4176     return ;
4177   }
4178   {
4179     try {
4180       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
4181     } CALL_CATCH_EXCEPTION();
4182   }
4183
4184 }
4185
4186
4187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
4188   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4189   Dali::Vector3 *arg2 = 0 ;
4190
4191   arg1 = (Dali::Matrix *)jarg1;
4192   arg2 = (Dali::Vector3 *)jarg2;
4193   if (!arg2) {
4194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4195     return ;
4196   }
4197   {
4198     try {
4199       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
4200     } CALL_CATCH_EXCEPTION();
4201   }
4202
4203 }
4204
4205
4206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
4207   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4208   Dali::Vector3 *arg2 = 0 ;
4209
4210   arg1 = (Dali::Matrix *)jarg1;
4211   arg2 = (Dali::Vector3 *)jarg2;
4212   if (!arg2) {
4213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4214     return ;
4215   }
4216   {
4217     try {
4218       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
4219     } CALL_CATCH_EXCEPTION();
4220   }
4221
4222 }
4223
4224
4225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
4226   void * jresult ;
4227   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4228   Dali::Vector4 *result = 0 ;
4229
4230   arg1 = (Dali::Matrix *)jarg1;
4231   {
4232     try {
4233       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
4234     } CALL_CATCH_EXCEPTION(0);
4235   }
4236
4237   jresult = (void *)result;
4238   return jresult;
4239 }
4240
4241
4242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
4243   void * jresult ;
4244   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4245   Dali::Vector3 *result = 0 ;
4246
4247   arg1 = (Dali::Matrix *)jarg1;
4248   {
4249     try {
4250       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
4251     } CALL_CATCH_EXCEPTION(0);
4252   }
4253
4254   jresult = (void *)result;
4255   return jresult;
4256 }
4257
4258
4259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
4260   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4261   Dali::Vector4 *arg2 = 0 ;
4262
4263   arg1 = (Dali::Matrix *)jarg1;
4264   arg2 = (Dali::Vector4 *)jarg2;
4265   if (!arg2) {
4266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4267     return ;
4268   }
4269   {
4270     try {
4271       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
4272     } CALL_CATCH_EXCEPTION();
4273   }
4274
4275 }
4276
4277
4278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
4279   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4280   Dali::Vector3 *arg2 = 0 ;
4281
4282   arg1 = (Dali::Matrix *)jarg1;
4283   arg2 = (Dali::Vector3 *)jarg2;
4284   if (!arg2) {
4285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4286     return ;
4287   }
4288   {
4289     try {
4290       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
4291     } CALL_CATCH_EXCEPTION();
4292   }
4293
4294 }
4295
4296
4297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
4298   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4299
4300   arg1 = (Dali::Matrix *)jarg1;
4301   {
4302     try {
4303       (arg1)->OrthoNormalize();
4304     } CALL_CATCH_EXCEPTION();
4305   }
4306
4307 }
4308
4309
4310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
4311   void * jresult ;
4312   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4313   float *result = 0 ;
4314
4315   arg1 = (Dali::Matrix *)jarg1;
4316   {
4317     try {
4318       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
4319     } CALL_CATCH_EXCEPTION(0);
4320   }
4321
4322   jresult = (void *)result;
4323   return jresult;
4324 }
4325
4326
4327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
4328   Dali::Matrix *arg1 = 0 ;
4329   Dali::Matrix *arg2 = 0 ;
4330   Dali::Matrix *arg3 = 0 ;
4331
4332   arg1 = (Dali::Matrix *)jarg1;
4333   if (!arg1) {
4334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
4335     return ;
4336   }
4337   arg2 = (Dali::Matrix *)jarg2;
4338   if (!arg2) {
4339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
4340     return ;
4341   }
4342   arg3 = (Dali::Matrix *)jarg3;
4343   if (!arg3) {
4344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
4345     return ;
4346   }
4347   {
4348     try {
4349       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
4350     } CALL_CATCH_EXCEPTION();
4351   }
4352
4353 }
4354
4355
4356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
4357   Dali::Matrix *arg1 = 0 ;
4358   Dali::Matrix *arg2 = 0 ;
4359   Dali::Quaternion *arg3 = 0 ;
4360
4361   arg1 = (Dali::Matrix *)jarg1;
4362   if (!arg1) {
4363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
4364     return ;
4365   }
4366   arg2 = (Dali::Matrix *)jarg2;
4367   if (!arg2) {
4368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
4369     return ;
4370   }
4371   arg3 = (Dali::Quaternion *)jarg3;
4372   if (!arg3) {
4373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
4374     return ;
4375   }
4376   {
4377     try {
4378       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
4379     } CALL_CATCH_EXCEPTION();
4380   }
4381
4382 }
4383
4384
4385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
4386   void * jresult ;
4387   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4388   Dali::Vector4 *arg2 = 0 ;
4389   Dali::Vector4 result;
4390
4391   arg1 = (Dali::Matrix *)jarg1;
4392   if (!arg1) {
4393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
4394     return 0;
4395   }
4396   arg2 = (Dali::Vector4 *)jarg2;
4397   if (!arg2) {
4398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4399     return 0;
4400   }
4401   {
4402     try {
4403       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
4404     } CALL_CATCH_EXCEPTION(0);
4405   }
4406
4407   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
4408   return jresult;
4409 }
4410
4411
4412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_3(void * nuiMatrixLhs, void * nuiMatrixRhs) {
4413   void * jresult ;
4414   Dali::Matrix *lhsPtr = (Dali::Matrix *) 0 ;
4415   Dali::Matrix *rhsPtr = (Dali::Matrix *) 0 ;
4416   Dali::Matrix result(false);
4417
4418   lhsPtr = (Dali::Matrix *)nuiMatrixLhs;
4419   if (!lhsPtr) {
4420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix const & type is null", 0);
4421     return 0;
4422   }
4423   rhsPtr = (Dali::Matrix *)nuiMatrixRhs;
4424   if (!rhsPtr) {
4425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix const & type is null", 0);
4426     return 0;
4427   }
4428   {
4429     try {
4430       result = ((Dali::Matrix const *)lhsPtr)->operator *((Dali::Matrix const &)*rhsPtr);
4431     } CALL_CATCH_EXCEPTION(0);
4432   }
4433
4434   jresult = new Dali::Matrix((const Dali::Matrix &)result);
4435   return jresult;
4436 }
4437
4438
4439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_4(void * nuiMatrixLhs, void * nuiMatrixRhs) {
4440   // Faster mulitply operation without memcpy
4441
4442   Dali::Matrix *jresult = (Dali::Matrix *)0;
4443   Dali::Matrix *lhsPtr  = (Dali::Matrix *)0;
4444   Dali::Matrix *rhsPtr  = (Dali::Matrix *)0;
4445
4446   lhsPtr = (Dali::Matrix *)nuiMatrixLhs;
4447   if (!lhsPtr) {
4448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix const & type is null", 0);
4449     return 0;
4450   }
4451   rhsPtr = (Dali::Matrix *)nuiMatrixRhs;
4452   if (!rhsPtr) {
4453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix const & type is null", 0);
4454     return 0;
4455   }
4456   {
4457     try {
4458       jresult = new Dali::Matrix(false);
4459       Dali::Matrix::Multiply((Dali::Matrix &)*jresult,(Dali::Matrix const &)*rhsPtr,(Dali::Matrix const &)*lhsPtr);
4460     } CALL_CATCH_EXCEPTION(0);
4461   }
4462
4463   return jresult;
4464 }
4465
4466
4467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_MultiplyAssign(void * nuiMatrix, void * nuiMatrixRhs) {
4468   void * jresult = 0;
4469   Dali::Matrix *lhsPtr = (Dali::Matrix *) 0 ;
4470   Dali::Matrix *rhsPtr = (Dali::Matrix *) 0 ;
4471   Dali::Matrix *retPtr = (Dali::Matrix *) 0 ;
4472
4473   lhsPtr = (Dali::Matrix *)nuiMatrix;
4474   if (!lhsPtr) {
4475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix const & type is null", 0);
4476     return 0;
4477   }
4478   rhsPtr = (Dali::Matrix *)nuiMatrixRhs;
4479   if (!rhsPtr) {
4480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix const & type is null", 0);
4481     return 0;
4482   }
4483   {
4484     try {
4485       retPtr = (Dali::Matrix *) &(lhsPtr)->operator *=((Dali::Matrix const &)*rhsPtr);
4486     } CALL_CATCH_EXCEPTION(0);
4487   }
4488
4489   jresult = (void *)retPtr;
4490   return jresult;
4491 }
4492
4493
4494 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
4495   bool jresult ;
4496   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4497   Dali::Matrix *arg2 = 0 ;
4498   bool result;
4499
4500   arg1 = (Dali::Matrix *)jarg1;
4501   arg2 = (Dali::Matrix *)jarg2;
4502   if (!arg2) {
4503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
4504     return 0;
4505   }
4506   {
4507     try {
4508       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
4509     } CALL_CATCH_EXCEPTION(0);
4510   }
4511
4512   jresult = result;
4513   return jresult;
4514 }
4515
4516
4517 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
4518   bool jresult ;
4519   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4520   Dali::Matrix *arg2 = 0 ;
4521   bool result;
4522
4523   arg1 = (Dali::Matrix *)jarg1;
4524   arg2 = (Dali::Matrix *)jarg2;
4525   if (!arg2) {
4526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
4527     return 0;
4528   }
4529   {
4530     try {
4531       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
4532     } CALL_CATCH_EXCEPTION(0);
4533   }
4534
4535   jresult = result;
4536   return jresult;
4537 }
4538
4539 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix_ValueOfIndex__SWIG_0(void * nuiMatrix, unsigned int index) {
4540   float jresult ;
4541   Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ;
4542
4543   pMatrix = (Dali::Matrix *)nuiMatrix;
4544   if (!pMatrix) {
4545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
4546     return 0;
4547   }
4548   if (index >= 16) {
4549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 16.)", 0);
4550     return 0;
4551   }
4552   {
4553     try {
4554       const float* temp = ((Dali::Matrix const *)pMatrix)->AsFloat();
4555       jresult = temp[index];
4556     } CALL_CATCH_EXCEPTION(0);
4557   }
4558   return jresult;
4559 }
4560
4561 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix_ValueOfIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn) {
4562   float jresult ;
4563   Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ;
4564
4565   pMatrix = (Dali::Matrix *)nuiMatrix;
4566   if (!pMatrix) {
4567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
4568     return 0;
4569   }
4570   if (indexRow >= 4) {
4571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 4.)", 0);
4572     return 0;
4573   }
4574   if (indexColumn >= 4) {
4575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 4.)", 0);
4576     return 0;
4577   }
4578   {
4579     try {
4580       const float* temp = ((Dali::Matrix const *)pMatrix)->AsFloat();
4581       jresult = temp[(indexColumn << 2) | indexRow];
4582     } CALL_CATCH_EXCEPTION(0);
4583   }
4584   return jresult;
4585 }
4586
4587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetValueAtIndex__SWIG_0(void * nuiMatrix, unsigned int index, float value) {
4588   Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ;
4589
4590   pMatrix = (Dali::Matrix *)nuiMatrix;
4591   if (!pMatrix) {
4592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
4593     return;
4594   }
4595   if (index >= 16) {
4596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 16.)", 0);
4597     return;
4598   }
4599   {
4600     try {
4601       float* temp = ((Dali::Matrix *)pMatrix)->AsFloat();
4602       temp[index] = value;
4603     } CALL_CATCH_EXCEPTION();
4604   }
4605 }
4606
4607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetValueAtIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn, float value) {
4608   Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ;
4609
4610   pMatrix = (Dali::Matrix *)nuiMatrix;
4611   if (!pMatrix) {
4612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
4613     return;
4614   }
4615   if (indexRow >= 4) {
4616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 4.)", 0);
4617     return;
4618   }
4619   if (indexColumn >= 4) {
4620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 4.)", 0);
4621     return;
4622   }
4623   {
4624     try {
4625       float* temp = ((Dali::Matrix *)pMatrix)->AsFloat();
4626       temp[(indexColumn << 2) | indexRow] = value;
4627     } CALL_CATCH_EXCEPTION();
4628   }
4629 }
4630
4631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
4632   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4633   Dali::Vector3 *arg2 = 0 ;
4634   Dali::Quaternion *arg3 = 0 ;
4635   Dali::Vector3 *arg4 = 0 ;
4636
4637   arg1 = (Dali::Matrix *)jarg1;
4638   arg2 = (Dali::Vector3 *)jarg2;
4639   if (!arg2) {
4640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4641     return ;
4642   }
4643   arg3 = (Dali::Quaternion *)jarg3;
4644   if (!arg3) {
4645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
4646     return ;
4647   }
4648   arg4 = (Dali::Vector3 *)jarg4;
4649   if (!arg4) {
4650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4651     return ;
4652   }
4653   {
4654     try {
4655       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
4656     } CALL_CATCH_EXCEPTION();
4657   }
4658
4659 }
4660
4661
4662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
4663   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4664   Dali::Vector3 *arg2 = 0 ;
4665   Dali::Quaternion *arg3 = 0 ;
4666   Dali::Vector3 *arg4 = 0 ;
4667
4668   arg1 = (Dali::Matrix *)jarg1;
4669   arg2 = (Dali::Vector3 *)jarg2;
4670   if (!arg2) {
4671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4672     return ;
4673   }
4674   arg3 = (Dali::Quaternion *)jarg3;
4675   if (!arg3) {
4676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
4677     return ;
4678   }
4679   arg4 = (Dali::Vector3 *)jarg4;
4680   if (!arg4) {
4681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4682     return ;
4683   }
4684   {
4685     try {
4686       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
4687     } CALL_CATCH_EXCEPTION();
4688   }
4689
4690 }
4691
4692
4693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
4694   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4695   Dali::Vector3 *arg2 = 0 ;
4696   Dali::Vector3 *arg3 = 0 ;
4697   Dali::Vector3 *arg4 = 0 ;
4698   Dali::Vector3 *arg5 = 0 ;
4699
4700   arg1 = (Dali::Matrix *)jarg1;
4701   arg2 = (Dali::Vector3 *)jarg2;
4702   if (!arg2) {
4703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4704     return ;
4705   }
4706   arg3 = (Dali::Vector3 *)jarg3;
4707   if (!arg3) {
4708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4709     return ;
4710   }
4711   arg4 = (Dali::Vector3 *)jarg4;
4712   if (!arg4) {
4713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4714     return ;
4715   }
4716   arg5 = (Dali::Vector3 *)jarg5;
4717   if (!arg5) {
4718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4719     return ;
4720   }
4721   {
4722     try {
4723       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
4724     } CALL_CATCH_EXCEPTION();
4725   }
4726
4727 }
4728
4729
4730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
4731   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4732   Dali::Vector3 *arg2 = 0 ;
4733   Dali::Quaternion *arg3 = 0 ;
4734   Dali::Vector3 *arg4 = 0 ;
4735
4736   arg1 = (Dali::Matrix *)jarg1;
4737   arg2 = (Dali::Vector3 *)jarg2;
4738   if (!arg2) {
4739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
4740     return ;
4741   }
4742   arg3 = (Dali::Quaternion *)jarg3;
4743   if (!arg3) {
4744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
4745     return ;
4746   }
4747   arg4 = (Dali::Vector3 *)jarg4;
4748   if (!arg4) {
4749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
4750     return ;
4751   }
4752   {
4753     try {
4754       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
4755     } CALL_CATCH_EXCEPTION();
4756   }
4757
4758 }
4759
4760
4761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
4762   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4763
4764   arg1 = (Dali::Matrix *)jarg1;
4765   {
4766     try {
4767       delete arg1;
4768     } CALL_CATCH_EXCEPTION();
4769   }
4770
4771 }
4772
4773
4774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
4775   void * jresult ;
4776   Dali::Matrix3 *result = 0 ;
4777
4778   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
4779   jresult = (void *)result;
4780   return jresult;
4781 }
4782
4783
4784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
4785   void * jresult ;
4786   Dali::Matrix3 *result = 0 ;
4787
4788   {
4789     try {
4790       result = (Dali::Matrix3 *)new Dali::Matrix3();
4791     } CALL_CATCH_EXCEPTION(0);
4792   }
4793
4794   jresult = (void *)result;
4795   return jresult;
4796 }
4797
4798
4799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
4800   void * jresult ;
4801   Dali::Matrix3 *arg1 = 0 ;
4802   Dali::Matrix3 *result = 0 ;
4803
4804   arg1 = (Dali::Matrix3 *)jarg1;
4805   if (!arg1) {
4806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
4807     return 0;
4808   }
4809   {
4810     try {
4811       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
4812     } CALL_CATCH_EXCEPTION(0);
4813   }
4814
4815   jresult = (void *)result;
4816   return jresult;
4817 }
4818
4819
4820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
4821   void * jresult ;
4822   Dali::Matrix *arg1 = 0 ;
4823   Dali::Matrix3 *result = 0 ;
4824
4825   arg1 = (Dali::Matrix *)jarg1;
4826   if (!arg1) {
4827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
4828     return 0;
4829   }
4830   {
4831     try {
4832       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
4833     } CALL_CATCH_EXCEPTION(0);
4834   }
4835
4836   jresult = (void *)result;
4837   return jresult;
4838 }
4839
4840
4841 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) {
4842   void * jresult ;
4843   float arg1 ;
4844   float arg2 ;
4845   float arg3 ;
4846   float arg4 ;
4847   float arg5 ;
4848   float arg6 ;
4849   float arg7 ;
4850   float arg8 ;
4851   float arg9 ;
4852   Dali::Matrix3 *result = 0 ;
4853
4854   arg1 = (float)jarg1;
4855   arg2 = (float)jarg2;
4856   arg3 = (float)jarg3;
4857   arg4 = (float)jarg4;
4858   arg5 = (float)jarg5;
4859   arg6 = (float)jarg6;
4860   arg7 = (float)jarg7;
4861   arg8 = (float)jarg8;
4862   arg9 = (float)jarg9;
4863   {
4864     try {
4865       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
4866     } CALL_CATCH_EXCEPTION(0);
4867   }
4868
4869   jresult = (void *)result;
4870   return jresult;
4871 }
4872
4873
4874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
4875   void * jresult ;
4876   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
4877   Dali::Matrix3 *arg2 = 0 ;
4878   Dali::Matrix3 *result = 0 ;
4879
4880   arg1 = (Dali::Matrix3 *)jarg1;
4881   arg2 = (Dali::Matrix3 *)jarg2;
4882   if (!arg2) {
4883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
4884     return 0;
4885   }
4886   {
4887     try {
4888       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
4889     } CALL_CATCH_EXCEPTION(0);
4890   }
4891
4892   jresult = (void *)result;
4893   return jresult;
4894 }
4895
4896
4897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
4898   void * jresult ;
4899   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
4900   Dali::Matrix *arg2 = 0 ;
4901   Dali::Matrix3 *result = 0 ;
4902
4903   arg1 = (Dali::Matrix3 *)jarg1;
4904   arg2 = (Dali::Matrix *)jarg2;
4905   if (!arg2) {
4906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
4907     return 0;
4908   }
4909   {
4910     try {
4911       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
4912     } CALL_CATCH_EXCEPTION(0);
4913   }
4914
4915   jresult = (void *)result;
4916   return jresult;
4917 }
4918
4919
4920 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
4921   bool jresult ;
4922   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
4923   Dali::Matrix3 *arg2 = 0 ;
4924   bool result;
4925
4926   arg1 = (Dali::Matrix3 *)jarg1;
4927   arg2 = (Dali::Matrix3 *)jarg2;
4928   if (!arg2) {
4929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
4930     return 0;
4931   }
4932   {
4933     try {
4934       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
4935     } CALL_CATCH_EXCEPTION(0);
4936   }
4937
4938   jresult = result;
4939   return jresult;
4940 }
4941
4942
4943 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
4944   bool jresult ;
4945   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
4946   Dali::Matrix3 *arg2 = 0 ;
4947   bool result;
4948
4949   arg1 = (Dali::Matrix3 *)jarg1;
4950   arg2 = (Dali::Matrix3 *)jarg2;
4951   if (!arg2) {
4952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
4953     return 0;
4954   }
4955   {
4956     try {
4957       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
4958     } CALL_CATCH_EXCEPTION(0);
4959   }
4960
4961   jresult = result;
4962   return jresult;
4963 }
4964
4965
4966 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_ValueOfIndex__SWIG_0(void * nuiMatrix, unsigned int index) {
4967   float jresult ;
4968   Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ;
4969
4970   pMatrix = (Dali::Matrix3 *)nuiMatrix;
4971   if (!pMatrix) {
4972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
4973     return 0;
4974   }
4975   if (index >= 9) {
4976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 9.)", 0);
4977     return 0;
4978   }
4979   {
4980     try {
4981       const float* temp = ((Dali::Matrix3 const *)pMatrix)->AsFloat();
4982       jresult = temp[index];
4983     } CALL_CATCH_EXCEPTION(0);
4984   }
4985   return jresult;
4986 }
4987
4988 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_ValueOfIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn) {
4989   float jresult ;
4990   Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ;
4991
4992   pMatrix = (Dali::Matrix3 *)nuiMatrix;
4993   if (!pMatrix) {
4994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
4995     return 0;
4996   }
4997   if (indexRow >= 3) {
4998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 3.)", 0);
4999     return 0;
5000   }
5001   if (indexColumn >= 3) {
5002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 3.)", 0);
5003     return 0;
5004   }
5005   {
5006     try {
5007       const float* temp = ((Dali::Matrix3 const *)pMatrix)->AsFloat();
5008       jresult = temp[indexColumn * 3 + indexRow];
5009     } CALL_CATCH_EXCEPTION(0);
5010   }
5011   return jresult;
5012 }
5013
5014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetValueAtIndex__SWIG_0(void * nuiMatrix, unsigned int index, float value) {
5015   Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ;
5016
5017   pMatrix = (Dali::Matrix3 *)nuiMatrix;
5018   if (!pMatrix) {
5019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
5020     return;
5021   }
5022   if (index >= 9) {
5023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 9.)", 0);
5024     return;
5025   }
5026   {
5027     try {
5028       float* temp = ((Dali::Matrix3 *)pMatrix)->AsFloat();
5029       temp[index] = value;
5030     } CALL_CATCH_EXCEPTION();
5031   }
5032 }
5033
5034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetValueAtIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn, float value) {
5035   Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ;
5036
5037   pMatrix = (Dali::Matrix3 *)nuiMatrix;
5038   if (!pMatrix) {
5039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
5040     return;
5041   }
5042   if (indexRow >= 3) {
5043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 3.)", 0);
5044     return;
5045   }
5046   if (indexColumn >= 3) {
5047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 3.)", 0);
5048     return;
5049   }
5050   {
5051     try {
5052       float* temp = ((Dali::Matrix3 *)pMatrix)->AsFloat();
5053       temp[indexColumn * 3 + indexRow] = value;
5054     } CALL_CATCH_EXCEPTION();
5055   }
5056 }
5057
5058
5059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
5060   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
5061
5062   arg1 = (Dali::Matrix3 *)jarg1;
5063   {
5064     try {
5065       delete arg1;
5066     } CALL_CATCH_EXCEPTION();
5067   }
5068
5069 }
5070
5071
5072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
5073   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
5074
5075   arg1 = (Dali::Matrix3 *)jarg1;
5076   {
5077     try {
5078       (arg1)->SetIdentity();
5079     } CALL_CATCH_EXCEPTION();
5080   }
5081
5082 }
5083
5084
5085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
5086   void * jresult ;
5087   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
5088   float *result = 0 ;
5089
5090   arg1 = (Dali::Matrix3 *)jarg1;
5091   {
5092     try {
5093       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
5094     } CALL_CATCH_EXCEPTION(0);
5095   }
5096
5097   jresult = (void *)result;
5098   return jresult;
5099 }
5100
5101
5102 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
5103   bool jresult ;
5104   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
5105   bool result;
5106
5107   arg1 = (Dali::Matrix3 *)jarg1;
5108   {
5109     try {
5110       result = (bool)(arg1)->Invert();
5111     } CALL_CATCH_EXCEPTION(0);
5112   }
5113
5114   jresult = result;
5115   return jresult;
5116 }
5117
5118
5119 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
5120   bool jresult ;
5121   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
5122   bool result;
5123
5124   arg1 = (Dali::Matrix3 *)jarg1;
5125   {
5126     try {
5127       result = (bool)(arg1)->Transpose();
5128     } CALL_CATCH_EXCEPTION(0);
5129   }
5130
5131   jresult = result;
5132   return jresult;
5133 }
5134
5135
5136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
5137   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
5138   float arg2 ;
5139
5140   arg1 = (Dali::Matrix3 *)jarg1;
5141   arg2 = (float)jarg2;
5142   {
5143     try {
5144       (arg1)->Scale(arg2);
5145     } CALL_CATCH_EXCEPTION();
5146   }
5147
5148 }
5149
5150
5151 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
5152   float jresult ;
5153   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
5154   float result;
5155
5156   arg1 = (Dali::Matrix3 *)jarg1;
5157   {
5158     try {
5159       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
5160     } CALL_CATCH_EXCEPTION(0);
5161   }
5162
5163   jresult = result;
5164   return jresult;
5165 }
5166
5167
5168 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
5169   bool jresult ;
5170   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
5171   bool result;
5172
5173   arg1 = (Dali::Matrix3 *)jarg1;
5174   {
5175     try {
5176       result = (bool)(arg1)->ScaledInverseTranspose();
5177     } CALL_CATCH_EXCEPTION(0);
5178   }
5179
5180   jresult = result;
5181   return jresult;
5182 }
5183
5184
5185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
5186   Dali::Matrix3 *arg1 = 0 ;
5187   Dali::Matrix3 *arg2 = 0 ;
5188   Dali::Matrix3 *arg3 = 0 ;
5189
5190   arg1 = (Dali::Matrix3 *)jarg1;
5191   if (!arg1) {
5192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
5193     return ;
5194   }
5195   arg2 = (Dali::Matrix3 *)jarg2;
5196   if (!arg2) {
5197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
5198     return ;
5199   }
5200   arg3 = (Dali::Matrix3 *)jarg3;
5201   if (!arg3) {
5202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
5203     return ;
5204   }
5205   {
5206     try {
5207       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
5208     } CALL_CATCH_EXCEPTION();
5209   }
5210
5211 }
5212
5213
5214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Multiply__SWIG_1(void * jarg1, void * jarg2) {
5215   void * jresult ;
5216   Dali::Matrix3 *arg1 = 0 ;
5217   Dali::Vector3 *arg2 = 0 ;
5218   Dali::Vector3 result;
5219
5220   arg1 = (Dali::Matrix3 *)jarg1;
5221   if (!arg1) {
5222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
5223     return 0;
5224   }
5225   arg2 = (Dali::Vector3 *)jarg2;
5226   if (!arg2) {
5227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5228     return 0;
5229   }
5230   {
5231     try {
5232       result = ((Dali::Matrix3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5233     } CALL_CATCH_EXCEPTION(0);
5234   }
5235
5236   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5237   return jresult;
5238 }
5239
5240
5241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Multiply__SWIG_2(void * nuiMatrix3Lhs, void * nuiMatrix3Rhs) {
5242   void * jresult ;
5243   Dali::Matrix3 *lhsPtr = 0 ;
5244   Dali::Matrix3 *rhsPtr = 0 ;
5245   Dali::Matrix3 result;
5246
5247   lhsPtr = (Dali::Matrix3 *)nuiMatrix3Lhs;
5248   if (!lhsPtr) {
5249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix3 const & type is null", 0);
5250     return 0;
5251   }
5252   rhsPtr = (Dali::Matrix3 *)nuiMatrix3Rhs;
5253   if (!rhsPtr) {
5254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix3 const & type is null", 0);
5255     return 0;
5256   }
5257   {
5258     try {
5259       result = ((Dali::Matrix3 const *)lhsPtr)->operator *((Dali::Matrix3 const &)*rhsPtr);
5260     } CALL_CATCH_EXCEPTION(0);
5261   }
5262
5263   jresult = new Dali::Matrix3((const Dali::Matrix3 &)result);
5264   return jresult;
5265 }
5266
5267
5268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Multiply__SWIG_3(void * nuiMatrix3Lhs, void * nuiMatrix3Rhs) {
5269   // Faster mulitply operation without memcpy
5270
5271   Dali::Matrix3 *jresult = 0;
5272   Dali::Matrix3 *lhsPtr  = 0;
5273   Dali::Matrix3 *rhsPtr  = 0;
5274
5275   lhsPtr = (Dali::Matrix3 *)nuiMatrix3Lhs;
5276   if (!lhsPtr) {
5277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix3 const & type is null", 0);
5278     return 0;
5279   }
5280   rhsPtr = (Dali::Matrix3 *)nuiMatrix3Rhs;
5281   if (!rhsPtr) {
5282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix3 const & type is null", 0);
5283     return 0;
5284   }
5285   {
5286     try {
5287       jresult = new Dali::Matrix3();
5288       Dali::Matrix3::Multiply((Dali::Matrix3 &)*jresult,(Dali::Matrix3 const &)*rhsPtr,(Dali::Matrix3 const &)*lhsPtr);
5289     } CALL_CATCH_EXCEPTION(0);
5290   }
5291
5292   return jresult;
5293 }
5294
5295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_MultiplyAssign(void * nuiMatrix, void * nuiMatrixRhs) {
5296   void * jresult = 0;
5297   Dali::Matrix3 *lhsPtr = (Dali::Matrix3 *) 0 ;
5298   Dali::Matrix3 *rhsPtr = (Dali::Matrix3 *) 0 ;
5299   Dali::Matrix3 *retPtr = (Dali::Matrix3 *) 0 ;
5300
5301   lhsPtr = (Dali::Matrix3 *)nuiMatrix;
5302   if (!lhsPtr) {
5303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix3 const & type is null", 0);
5304     return 0;
5305   }
5306   rhsPtr = (Dali::Matrix3 *)nuiMatrixRhs;
5307   if (!rhsPtr) {
5308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix3 const & type is null", 0);
5309     return 0;
5310   }
5311   {
5312     try {
5313       retPtr = (Dali::Matrix3 *) &(lhsPtr)->operator *=((Dali::Matrix3 const &)*rhsPtr);
5314     } CALL_CATCH_EXCEPTION(0);
5315   }
5316
5317   jresult = (void *)retPtr;
5318   return jresult;
5319 }
5320
5321
5322 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
5323   float jresult ;
5324   float arg1 ;
5325   float arg2 ;
5326   float result;
5327
5328   arg1 = (float)jarg1;
5329   arg2 = (float)jarg2;
5330   {
5331     try {
5332       result = (float)Dali::Random::Range(arg1,arg2);
5333     } CALL_CATCH_EXCEPTION(0);
5334   }
5335
5336   jresult = result;
5337   return jresult;
5338 }
5339
5340
5341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
5342   void * jresult ;
5343   Dali::Vector4 result;
5344
5345   {
5346     try {
5347       result = Dali::Random::Axis();
5348     } CALL_CATCH_EXCEPTION(0);
5349   }
5350
5351   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5352   return jresult;
5353 }
5354
5355
5356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
5357   void * jresult ;
5358   Dali::AngleAxis *result = 0 ;
5359
5360   {
5361     try {
5362       result = (Dali::AngleAxis *)new Dali::AngleAxis();
5363     } CALL_CATCH_EXCEPTION(0);
5364   }
5365
5366   jresult = (void *)result;
5367   return jresult;
5368 }
5369
5370
5371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
5372   void * jresult ;
5373   Dali::Radian arg1 ;
5374   Dali::Vector3 *arg2 = 0 ;
5375   Dali::Radian *argp1 ;
5376   Dali::AngleAxis *result = 0 ;
5377
5378   argp1 = (Dali::Radian *)jarg1;
5379   if (!argp1) {
5380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
5381     return 0;
5382   }
5383   arg1 = *argp1;
5384   arg2 = (Dali::Vector3 *)jarg2;
5385   if (!arg2) {
5386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5387     return 0;
5388   }
5389   {
5390     try {
5391       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
5392     } CALL_CATCH_EXCEPTION(0);
5393   }
5394
5395   jresult = (void *)result;
5396   return jresult;
5397 }
5398
5399
5400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
5401   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
5402   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
5403
5404   arg1 = (Dali::AngleAxis *)jarg1;
5405   arg2 = (Dali::Radian *)jarg2;
5406   if (arg1) (arg1)->angle = *arg2;
5407 }
5408
5409
5410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
5411   void * jresult ;
5412   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
5413   Dali::Radian *result = 0 ;
5414
5415   arg1 = (Dali::AngleAxis *)jarg1;
5416   result = (Dali::Radian *)& ((arg1)->angle);
5417   jresult = (void *)result;
5418   return jresult;
5419 }
5420
5421
5422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
5423   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
5424   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
5425
5426   arg1 = (Dali::AngleAxis *)jarg1;
5427   arg2 = (Dali::Vector3 *)jarg2;
5428   if (arg1) (arg1)->axis = *arg2;
5429 }
5430
5431
5432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
5433   void * jresult ;
5434   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
5435   Dali::Vector3 *result = 0 ;
5436
5437   arg1 = (Dali::AngleAxis *)jarg1;
5438   result = (Dali::Vector3 *)& ((arg1)->axis);
5439   jresult = (void *)result;
5440   return jresult;
5441 }
5442
5443
5444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
5445   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
5446
5447   arg1 = (Dali::AngleAxis *)jarg1;
5448   {
5449     try {
5450       delete arg1;
5451     } CALL_CATCH_EXCEPTION();
5452   }
5453
5454 }
5455
5456
5457 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
5458   bool jresult ;
5459   Dali::AngleAxis *arg1 = 0 ;
5460   Dali::AngleAxis *arg2 = 0 ;
5461   bool result;
5462
5463   arg1 = (Dali::AngleAxis *)jarg1;
5464   if (!arg1) {
5465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
5466     return 0;
5467   }
5468   arg2 = (Dali::AngleAxis *)jarg2;
5469   if (!arg2) {
5470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
5471     return 0;
5472   }
5473   {
5474     try {
5475       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
5476     } CALL_CATCH_EXCEPTION(0);
5477   }
5478
5479   jresult = result;
5480   return jresult;
5481 }
5482
5483
5484 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
5485   unsigned int jresult ;
5486   unsigned int arg1 ;
5487   unsigned int result;
5488
5489   arg1 = (unsigned int)jarg1;
5490   {
5491     try {
5492       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
5493     } CALL_CATCH_EXCEPTION(0);
5494   }
5495
5496   jresult = result;
5497   return jresult;
5498 }
5499
5500
5501 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
5502   bool jresult ;
5503   unsigned int arg1 ;
5504   bool result;
5505
5506   arg1 = (unsigned int)jarg1;
5507   {
5508     try {
5509       result = (bool)Dali::IsPowerOfTwo(arg1);
5510     } CALL_CATCH_EXCEPTION(0);
5511   }
5512
5513   jresult = result;
5514   return jresult;
5515 }
5516
5517
5518 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
5519   float jresult ;
5520   float arg1 ;
5521   float arg2 ;
5522   float result;
5523
5524   arg1 = (float)jarg1;
5525   arg2 = (float)jarg2;
5526   {
5527     try {
5528       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
5529     } CALL_CATCH_EXCEPTION(0);
5530   }
5531
5532   jresult = result;
5533   return jresult;
5534 }
5535
5536
5537 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
5538   bool jresult ;
5539   float arg1 ;
5540   bool result;
5541
5542   arg1 = (float)jarg1;
5543   {
5544     try {
5545       result = (bool)Dali::EqualsZero(arg1);
5546     } CALL_CATCH_EXCEPTION(0);
5547   }
5548
5549   jresult = result;
5550   return jresult;
5551 }
5552
5553
5554 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
5555   bool jresult ;
5556   float arg1 ;
5557   float arg2 ;
5558   bool result;
5559
5560   arg1 = (float)jarg1;
5561   arg2 = (float)jarg2;
5562   {
5563     try {
5564       result = (bool)Dali::Equals(arg1,arg2);
5565     } CALL_CATCH_EXCEPTION(0);
5566   }
5567
5568   jresult = result;
5569   return jresult;
5570 }
5571
5572
5573 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
5574   bool jresult ;
5575   float arg1 ;
5576   float arg2 ;
5577   float arg3 ;
5578   bool result;
5579
5580   arg1 = (float)jarg1;
5581   arg2 = (float)jarg2;
5582   arg3 = (float)jarg3;
5583   {
5584     try {
5585       result = (bool)Dali::Equals(arg1,arg2,arg3);
5586     } CALL_CATCH_EXCEPTION(0);
5587   }
5588
5589   jresult = result;
5590   return jresult;
5591 }
5592
5593
5594 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
5595   float jresult ;
5596   float arg1 ;
5597   int arg2 ;
5598   float result;
5599
5600   arg1 = (float)jarg1;
5601   arg2 = (int)jarg2;
5602   {
5603     try {
5604       result = (float)Dali::Round(arg1,arg2);
5605     } CALL_CATCH_EXCEPTION(0);
5606   }
5607
5608   jresult = result;
5609   return jresult;
5610 }
5611
5612
5613 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
5614   float jresult ;
5615   float arg1 ;
5616   float arg2 ;
5617   float arg3 ;
5618   float result;
5619
5620   arg1 = (float)jarg1;
5621   arg2 = (float)jarg2;
5622   arg3 = (float)jarg3;
5623   {
5624     try {
5625       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
5626     } CALL_CATCH_EXCEPTION(0);
5627   }
5628
5629   jresult = result;
5630   return jresult;
5631 }
5632
5633
5634 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
5635   float jresult ;
5636   float arg1 ;
5637   float arg2 ;
5638   float arg3 ;
5639   float arg4 ;
5640   float result;
5641
5642   arg1 = (float)jarg1;
5643   arg2 = (float)jarg2;
5644   arg3 = (float)jarg3;
5645   arg4 = (float)jarg4;
5646   {
5647     try {
5648       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
5649     } CALL_CATCH_EXCEPTION(0);
5650   }
5651
5652   jresult = result;
5653   return jresult;
5654 }
5655
5656
5657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
5658   void * jresult ;
5659   Dali::Handle *arg1 = 0 ;
5660   Dali::Property::Index arg2 ;
5661   Dali::Property *result = 0 ;
5662
5663   arg1 = (Dali::Handle *)jarg1;
5664   if (!arg1) {
5665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
5666     return 0;
5667   }
5668   arg2 = (Dali::Property::Index)jarg2;
5669   {
5670     try {
5671       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
5672     } CALL_CATCH_EXCEPTION(0);
5673   }
5674
5675   jresult = (void *)result;
5676   return jresult;
5677 }
5678
5679
5680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
5681   void * jresult ;
5682   Dali::Handle *arg1 = 0 ;
5683   Dali::Property::Index arg2 ;
5684   int arg3 ;
5685   Dali::Property *result = 0 ;
5686
5687   arg1 = (Dali::Handle *)jarg1;
5688   if (!arg1) {
5689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
5690     return 0;
5691   }
5692   arg2 = (Dali::Property::Index)jarg2;
5693   arg3 = (int)jarg3;
5694   {
5695     try {
5696       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
5697     } CALL_CATCH_EXCEPTION(0);
5698   }
5699
5700   jresult = (void *)result;
5701   return jresult;
5702 }
5703
5704
5705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
5706   void * jresult ;
5707   Dali::Handle *arg1 = 0 ;
5708   std::string *arg2 = 0 ;
5709   Dali::Property *result = 0 ;
5710
5711   arg1 = (Dali::Handle *)jarg1;
5712   if (!arg1) {
5713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
5714     return 0;
5715   }
5716   if (!jarg2) {
5717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
5718     return 0;
5719   }
5720   std::string arg2_str(jarg2);
5721   arg2 = &arg2_str;
5722   {
5723     try {
5724       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
5725     } CALL_CATCH_EXCEPTION(0);
5726   }
5727
5728   jresult = (void *)result;
5729
5730   //argout typemap for const std::string&
5731
5732   return jresult;
5733 }
5734
5735
5736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
5737   void * jresult ;
5738   Dali::Handle *arg1 = 0 ;
5739   std::string *arg2 = 0 ;
5740   int arg3 ;
5741   Dali::Property *result = 0 ;
5742
5743   arg1 = (Dali::Handle *)jarg1;
5744   if (!arg1) {
5745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
5746     return 0;
5747   }
5748   if (!jarg2) {
5749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
5750     return 0;
5751   }
5752   std::string arg2_str(jarg2);
5753   arg2 = &arg2_str;
5754   arg3 = (int)jarg3;
5755   {
5756     try {
5757       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
5758     } CALL_CATCH_EXCEPTION(0);
5759   }
5760
5761   jresult = (void *)result;
5762
5763   //argout typemap for const std::string&
5764
5765   return jresult;
5766 }
5767
5768
5769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
5770   Dali::Property *arg1 = (Dali::Property *) 0 ;
5771
5772   arg1 = (Dali::Property *)jarg1;
5773   {
5774     try {
5775       delete arg1;
5776     } CALL_CATCH_EXCEPTION();
5777   }
5778
5779 }
5780
5781
5782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
5783   Dali::Property *arg1 = (Dali::Property *) 0 ;
5784   Dali::Handle *arg2 = 0 ;
5785
5786   arg1 = (Dali::Property *)jarg1;
5787   arg2 = (Dali::Handle *)jarg2;
5788   if (!arg2) {
5789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
5790     return ;
5791   }
5792   if (arg1) (arg1)->object = *arg2;
5793 }
5794
5795
5796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
5797   void * jresult ;
5798   Dali::Property *arg1 = (Dali::Property *) 0 ;
5799   Dali::Handle *result = 0 ;
5800
5801   arg1 = (Dali::Property *)jarg1;
5802   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
5803   jresult = (void *)result;
5804   return jresult;
5805 }
5806
5807
5808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
5809   Dali::Property *arg1 = (Dali::Property *) 0 ;
5810   Dali::Property::Index arg2 ;
5811
5812   arg1 = (Dali::Property *)jarg1;
5813   arg2 = (Dali::Property::Index)jarg2;
5814   if (arg1) (arg1)->propertyIndex = arg2;
5815 }
5816
5817
5818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
5819   int jresult ;
5820   Dali::Property *arg1 = (Dali::Property *) 0 ;
5821   Dali::Property::Index result;
5822
5823   arg1 = (Dali::Property *)jarg1;
5824   result = (Dali::Property::Index) ((arg1)->propertyIndex);
5825   jresult = result;
5826   return jresult;
5827 }
5828
5829
5830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
5831   Dali::Property *arg1 = (Dali::Property *) 0 ;
5832   int arg2 ;
5833
5834   arg1 = (Dali::Property *)jarg1;
5835   arg2 = (int)jarg2;
5836   if (arg1) (arg1)->componentIndex = arg2;
5837 }
5838
5839
5840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
5841   int jresult ;
5842   Dali::Property *arg1 = (Dali::Property *) 0 ;
5843   int result;
5844
5845   arg1 = (Dali::Property *)jarg1;
5846   result = (int) ((arg1)->componentIndex);
5847   jresult = result;
5848   return jresult;
5849 }
5850
5851
5852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
5853   void * jresult ;
5854   Dali::Property::Array *result = 0 ;
5855
5856   {
5857     try {
5858       result = (Dali::Property::Array *)new Dali::Property::Array();
5859     } CALL_CATCH_EXCEPTION(0);
5860   }
5861
5862   jresult = (void *)result;
5863   return jresult;
5864 }
5865
5866
5867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
5868   void * jresult ;
5869   Dali::Property::Array *arg1 = 0 ;
5870   Dali::Property::Array *result = 0 ;
5871
5872   arg1 = (Dali::Property::Array *)jarg1;
5873   if (!arg1) {
5874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
5875     return 0;
5876   }
5877   {
5878     try {
5879       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
5880     } CALL_CATCH_EXCEPTION(0);
5881   }
5882
5883   jresult = (void *)result;
5884   return jresult;
5885 }
5886
5887
5888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
5889   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
5890
5891   arg1 = (Dali::Property::Array *)jarg1;
5892   {
5893     try {
5894       delete arg1;
5895     } CALL_CATCH_EXCEPTION();
5896   }
5897
5898 }
5899
5900
5901 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
5902   unsigned long jresult ;
5903   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
5904   Dali::Property::Array::SizeType result;
5905
5906   arg1 = (Dali::Property::Array *)jarg1;
5907   {
5908     try {
5909       result = ((Dali::Property::Array const *)arg1)->Size();
5910     } CALL_CATCH_EXCEPTION(0);
5911   }
5912
5913   jresult = (unsigned long)result;
5914   return jresult;
5915 }
5916
5917
5918 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
5919   unsigned long jresult ;
5920   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
5921   Dali::Property::Array::SizeType result;
5922
5923   arg1 = (Dali::Property::Array *)jarg1;
5924   {
5925     try {
5926       result = ((Dali::Property::Array const *)arg1)->Count();
5927     } CALL_CATCH_EXCEPTION(0);
5928   }
5929
5930   jresult = (unsigned long)result;
5931   return jresult;
5932 }
5933
5934
5935 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
5936   bool jresult ;
5937   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
5938   bool result;
5939
5940   arg1 = (Dali::Property::Array *)jarg1;
5941   {
5942     try {
5943       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
5944     } CALL_CATCH_EXCEPTION(0);
5945   }
5946
5947   jresult = result;
5948   return jresult;
5949 }
5950
5951
5952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
5953   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
5954
5955   arg1 = (Dali::Property::Array *)jarg1;
5956   {
5957     try {
5958       (arg1)->Clear();
5959     } CALL_CATCH_EXCEPTION();
5960   }
5961
5962 }
5963
5964
5965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
5966   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
5967   Dali::Property::Array::SizeType arg2 ;
5968
5969   arg1 = (Dali::Property::Array *)jarg1;
5970   arg2 = (Dali::Property::Array::SizeType)jarg2;
5971   {
5972     try {
5973       (arg1)->Reserve(arg2);
5974     } CALL_CATCH_EXCEPTION();
5975   }
5976
5977 }
5978
5979
5980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
5981   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
5982   Dali::Property::Array::SizeType arg2 ;
5983
5984   arg1 = (Dali::Property::Array *)jarg1;
5985   arg2 = (Dali::Property::Array::SizeType)jarg2;
5986   {
5987     try {
5988       (arg1)->Resize(arg2);
5989     } CALL_CATCH_EXCEPTION();
5990   }
5991
5992 }
5993
5994
5995 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
5996   unsigned long jresult ;
5997   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
5998   Dali::Property::Array::SizeType result;
5999
6000   arg1 = (Dali::Property::Array *)jarg1;
6001   {
6002     try {
6003       result = (arg1)->Capacity();
6004     } CALL_CATCH_EXCEPTION(0);
6005   }
6006
6007   jresult = (unsigned long)result;
6008   return jresult;
6009 }
6010
6011
6012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
6013   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
6014   Dali::Property::Value *arg2 = 0 ;
6015
6016   arg1 = (Dali::Property::Array *)jarg1;
6017   arg2 = (Dali::Property::Value *)jarg2;
6018   if (!arg2) {
6019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
6020     return ;
6021   }
6022   {
6023     try {
6024       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
6025     } CALL_CATCH_EXCEPTION();
6026   }
6027
6028 }
6029
6030
6031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
6032   void * jresult ;
6033   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
6034   Dali::Property::Value *arg2 = 0 ;
6035   Dali::Property::Array *result = 0 ;
6036
6037   arg1 = (Dali::Property::Array *)jarg1;
6038   arg2 = (Dali::Property::Value *)jarg2;
6039   if (!arg2) {
6040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
6041     return 0;
6042   }
6043   {
6044     try {
6045       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
6046     } CALL_CATCH_EXCEPTION(0);
6047   }
6048
6049   jresult = (void *)result;
6050   return jresult;
6051 }
6052
6053
6054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
6055   void * jresult ;
6056   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
6057   Dali::Property::Array::SizeType arg2 ;
6058   Dali::Property::Value *result = 0 ;
6059
6060   arg1 = (Dali::Property::Array *)jarg1;
6061   arg2 = (Dali::Property::Array::SizeType)jarg2;
6062   {
6063     try {
6064       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
6065     } CALL_CATCH_EXCEPTION(0);
6066   }
6067
6068   jresult = (void *)result;
6069   return jresult;
6070 }
6071
6072
6073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
6074   void * jresult ;
6075   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
6076   Dali::Property::Array::SizeType arg2 ;
6077   Dali::Property::Value *result = 0 ;
6078
6079   arg1 = (Dali::Property::Array *)jarg1;
6080   arg2 = (Dali::Property::Array::SizeType)jarg2;
6081   {
6082     try {
6083       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
6084     } CALL_CATCH_EXCEPTION(0);
6085   }
6086
6087   jresult = (void *)result;
6088   return jresult;
6089 }
6090
6091
6092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
6093   void * jresult ;
6094   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
6095   Dali::Property::Array *arg2 = 0 ;
6096   Dali::Property::Array *result = 0 ;
6097
6098   arg1 = (Dali::Property::Array *)jarg1;
6099   arg2 = (Dali::Property::Array *)jarg2;
6100   if (!arg2) {
6101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
6102     return 0;
6103   }
6104   {
6105     try {
6106       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
6107     } CALL_CATCH_EXCEPTION(0);
6108   }
6109
6110   jresult = (void *)result;
6111   return jresult;
6112 }
6113
6114
6115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
6116   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
6117   enum Dali::Property::Key::Type arg2 ;
6118
6119   arg1 = (Dali::Property::Key *)jarg1;
6120   arg2 = (enum Dali::Property::Key::Type)jarg2;
6121   if (arg1) (arg1)->type = arg2;
6122 }
6123
6124
6125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
6126   int jresult ;
6127   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
6128   enum Dali::Property::Key::Type result;
6129
6130   arg1 = (Dali::Property::Key *)jarg1;
6131   result = (enum Dali::Property::Key::Type) ((arg1)->type);
6132   jresult = (int)result;
6133   return jresult;
6134 }
6135
6136
6137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
6138   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
6139   Dali::Property::Index arg2 ;
6140
6141   arg1 = (Dali::Property::Key *)jarg1;
6142   arg2 = (Dali::Property::Index)jarg2;
6143   if (arg1) (arg1)->indexKey = arg2;
6144 }
6145
6146
6147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
6148   int jresult ;
6149   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
6150   Dali::Property::Index result;
6151
6152   arg1 = (Dali::Property::Key *)jarg1;
6153   result = (Dali::Property::Index) ((arg1)->indexKey);
6154   jresult = result;
6155   return jresult;
6156 }
6157
6158
6159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
6160   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
6161   std::string *arg2 = 0 ;
6162
6163   arg1 = (Dali::Property::Key *)jarg1;
6164   if (!jarg2) {
6165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
6166     return ;
6167   }
6168   std::string arg2_str(jarg2);
6169   arg2 = &arg2_str;
6170   if (arg1) (arg1)->stringKey = *arg2;
6171
6172   //argout typemap for const std::string&
6173
6174 }
6175
6176
6177 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
6178   char * jresult ;
6179   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
6180   std::string *result = 0 ;
6181
6182   arg1 = (Dali::Property::Key *)jarg1;
6183   result = (std::string *) & ((arg1)->stringKey);
6184   jresult = SWIG_csharp_string_callback(result->c_str());
6185   return jresult;
6186 }
6187
6188
6189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
6190   void * jresult ;
6191   std::string *arg1 = 0 ;
6192   Dali::Property::Key *result = 0 ;
6193
6194   if (!jarg1) {
6195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
6196     return 0;
6197   }
6198   std::string arg1_str(jarg1);
6199   arg1 = &arg1_str;
6200   {
6201     try {
6202       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
6203     } CALL_CATCH_EXCEPTION(0);
6204   }
6205
6206   jresult = (void *)result;
6207
6208   //argout typemap for const std::string&
6209
6210   return jresult;
6211 }
6212
6213
6214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
6215   void * jresult ;
6216   Dali::Property::Index arg1 ;
6217   Dali::Property::Key *result = 0 ;
6218
6219   arg1 = (Dali::Property::Index)jarg1;
6220   {
6221     try {
6222       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
6223     } CALL_CATCH_EXCEPTION(0);
6224   }
6225
6226   jresult = (void *)result;
6227   return jresult;
6228 }
6229
6230
6231 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
6232   bool jresult ;
6233   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
6234   std::string *arg2 = 0 ;
6235   bool result;
6236
6237   arg1 = (Dali::Property::Key *)jarg1;
6238   if (!jarg2) {
6239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
6240     return 0;
6241   }
6242   std::string arg2_str(jarg2);
6243   arg2 = &arg2_str;
6244   {
6245     try {
6246       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
6247     } CALL_CATCH_EXCEPTION(0);
6248   }
6249
6250   jresult = result;
6251
6252   //argout typemap for const std::string&
6253
6254   return jresult;
6255 }
6256
6257
6258 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
6259   bool jresult ;
6260   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
6261   Dali::Property::Index arg2 ;
6262   bool result;
6263
6264   arg1 = (Dali::Property::Key *)jarg1;
6265   arg2 = (Dali::Property::Index)jarg2;
6266   {
6267     try {
6268       result = (bool)(arg1)->operator ==(arg2);
6269     } CALL_CATCH_EXCEPTION(0);
6270   }
6271
6272   jresult = result;
6273   return jresult;
6274 }
6275
6276
6277 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
6278   bool jresult ;
6279   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
6280   Dali::Property::Key *arg2 = 0 ;
6281   bool result;
6282
6283   arg1 = (Dali::Property::Key *)jarg1;
6284   arg2 = (Dali::Property::Key *)jarg2;
6285   if (!arg2) {
6286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
6287     return 0;
6288   }
6289   {
6290     try {
6291       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
6292     } CALL_CATCH_EXCEPTION(0);
6293   }
6294
6295   jresult = result;
6296   return jresult;
6297 }
6298
6299
6300 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
6301   bool jresult ;
6302   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
6303   std::string *arg2 = 0 ;
6304   bool result;
6305
6306   arg1 = (Dali::Property::Key *)jarg1;
6307   if (!jarg2) {
6308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
6309     return 0;
6310   }
6311   std::string arg2_str(jarg2);
6312   arg2 = &arg2_str;
6313   {
6314     try {
6315       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
6316     } CALL_CATCH_EXCEPTION(0);
6317   }
6318
6319   jresult = result;
6320
6321   //argout typemap for const std::string&
6322
6323   return jresult;
6324 }
6325
6326
6327 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
6328   bool jresult ;
6329   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
6330   Dali::Property::Index arg2 ;
6331   bool result;
6332
6333   arg1 = (Dali::Property::Key *)jarg1;
6334   arg2 = (Dali::Property::Index)jarg2;
6335   {
6336     try {
6337       result = (bool)(arg1)->operator !=(arg2);
6338     } CALL_CATCH_EXCEPTION(0);
6339   }
6340
6341   jresult = result;
6342   return jresult;
6343 }
6344
6345
6346 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
6347   bool jresult ;
6348   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
6349   Dali::Property::Key *arg2 = 0 ;
6350   bool result;
6351
6352   arg1 = (Dali::Property::Key *)jarg1;
6353   arg2 = (Dali::Property::Key *)jarg2;
6354   if (!arg2) {
6355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
6356     return 0;
6357   }
6358   {
6359     try {
6360       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
6361     } CALL_CATCH_EXCEPTION(0);
6362   }
6363
6364   jresult = result;
6365   return jresult;
6366 }
6367
6368
6369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
6370   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
6371
6372   arg1 = (Dali::Property::Key *)jarg1;
6373   {
6374     try {
6375       delete arg1;
6376     } CALL_CATCH_EXCEPTION();
6377   }
6378
6379 }
6380
6381
6382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
6383   void * jresult ;
6384   Dali::Property::Map *result = 0 ;
6385
6386   {
6387     try {
6388       result = (Dali::Property::Map *)new Dali::Property::Map();
6389     } CALL_CATCH_EXCEPTION(0);
6390   }
6391
6392   jresult = (void *)result;
6393   return jresult;
6394 }
6395
6396
6397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
6398   void * jresult ;
6399   Dali::Property::Map *arg1 = 0 ;
6400   Dali::Property::Map *result = 0 ;
6401
6402   arg1 = (Dali::Property::Map *)jarg1;
6403   if (!arg1) {
6404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
6405     return 0;
6406   }
6407   {
6408     try {
6409       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
6410     } CALL_CATCH_EXCEPTION(0);
6411   }
6412
6413   jresult = (void *)result;
6414   return jresult;
6415 }
6416
6417
6418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
6419   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6420
6421   arg1 = (Dali::Property::Map *)jarg1;
6422   {
6423     try {
6424       delete arg1;
6425     } CALL_CATCH_EXCEPTION();
6426   }
6427
6428 }
6429
6430
6431 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
6432   unsigned long jresult ;
6433   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6434   Dali::Property::Map::SizeType result;
6435
6436   arg1 = (Dali::Property::Map *)jarg1;
6437   {
6438     try {
6439       result = ((Dali::Property::Map const *)arg1)->Count();
6440     } CALL_CATCH_EXCEPTION(0);
6441   }
6442
6443   jresult = (unsigned long)result;
6444   return jresult;
6445 }
6446
6447
6448 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
6449   bool jresult ;
6450   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6451   bool result;
6452
6453   arg1 = (Dali::Property::Map *)jarg1;
6454   {
6455     try {
6456       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
6457     } CALL_CATCH_EXCEPTION(0);
6458   }
6459
6460   jresult = result;
6461   return jresult;
6462 }
6463
6464
6465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
6466   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6467   char *arg2 = (char *) 0 ;
6468   Dali::Property::Value *arg3 = 0 ;
6469
6470   arg1 = (Dali::Property::Map *)jarg1;
6471   arg2 = (char *)jarg2;
6472   arg3 = (Dali::Property::Value *)jarg3;
6473   if (!arg3) {
6474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
6475     return ;
6476   }
6477   {
6478     try {
6479       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
6480     } CALL_CATCH_EXCEPTION();
6481   }
6482
6483 }
6484
6485
6486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Int__SWIG_0(void * jarg1, const char * jarg2, int jarg3) {
6487   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6488
6489   arg1 = (Dali::Property::Map *)jarg1;
6490   {
6491     try {
6492       (arg1)->Insert(jarg2,(Dali::Property::Value const &)(jarg3));
6493     } CALL_CATCH_EXCEPTION();
6494   }
6495
6496 }
6497
6498
6499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Bool__SWIG_0(void * jarg1, const char * jarg2, bool jarg3) {
6500   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6501
6502   arg1 = (Dali::Property::Map *)jarg1;
6503   {
6504     try {
6505       (arg1)->Insert(jarg2,(Dali::Property::Value const &)(jarg3));
6506     } CALL_CATCH_EXCEPTION();
6507   }
6508
6509 }
6510
6511
6512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Float__SWIG_0(void * jarg1, const char * jarg2, float jarg3) {
6513   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6514
6515   arg1 = (Dali::Property::Map *)jarg1;
6516   {
6517     try {
6518       (arg1)->Insert(jarg2,(Dali::Property::Value const &)(jarg3));
6519     } CALL_CATCH_EXCEPTION();
6520   }
6521
6522 }
6523
6524
6525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_String__SWIG_0(void * jarg1, const char * jarg2, const char * jarg3) {
6526   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6527
6528   arg1 = (Dali::Property::Map *)jarg1;
6529   {
6530     try {
6531       (arg1)->Insert(jarg2,(Dali::Property::Value const &)(jarg3));
6532     } CALL_CATCH_EXCEPTION();
6533   }
6534
6535 }
6536
6537
6538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Vector2__SWIG_0(void * jarg1, const char * jarg2, float jarg3, float jarg4) {
6539   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6540
6541   arg1 = (Dali::Property::Map *)jarg1;
6542   {
6543     try {
6544       (arg1)->Insert(jarg2,(Dali::Property::Value const &)(Dali::Vector2(jarg3, jarg4)));
6545     } CALL_CATCH_EXCEPTION();
6546   }
6547
6548 }
6549
6550
6551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Vector3__SWIG_0(void * jarg1, const char * jarg2, float jarg3, float jarg4, float jarg5) {
6552   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6553
6554   arg1 = (Dali::Property::Map *)jarg1;
6555   {
6556     try {
6557       (arg1)->Insert(jarg2,(Dali::Property::Value const &)(Dali::Vector3(jarg3, jarg4, jarg5)));
6558     } CALL_CATCH_EXCEPTION();
6559   }
6560
6561 }
6562
6563
6564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Vector4__SWIG_0(void * jarg1, const char * jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
6565   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6566
6567   arg1 = (Dali::Property::Map *)jarg1;
6568   {
6569     try {
6570       (arg1)->Insert(jarg2,(Dali::Property::Value const &)(Dali::Vector4(jarg3, jarg4, jarg5, jarg6)));
6571     } CALL_CATCH_EXCEPTION();
6572   }
6573
6574 }
6575
6576
6577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
6578   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6579   Dali::Property::Index arg2 ;
6580   Dali::Property::Value *arg3 = 0 ;
6581
6582   arg1 = (Dali::Property::Map *)jarg1;
6583   arg2 = (Dali::Property::Index)jarg2;
6584   arg3 = (Dali::Property::Value *)jarg3;
6585   if (!arg3) {
6586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
6587     return ;
6588   }
6589   {
6590     try {
6591       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
6592     } CALL_CATCH_EXCEPTION();
6593   }
6594
6595 }
6596
6597
6598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Int__SWIG_2(void * jarg1, int jarg2, int jarg3) {
6599   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6600   Dali::Property::Index arg2 ;
6601
6602   arg1 = (Dali::Property::Map *)jarg1;
6603   arg2 = (Dali::Property::Index)jarg2;
6604   {
6605     try {
6606       (arg1)->Insert(arg2,(Dali::Property::Value const &)(jarg3));
6607     } CALL_CATCH_EXCEPTION();
6608   }
6609
6610 }
6611
6612
6613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Bool__SWIG_2(void * jarg1, int jarg2, bool jarg3) {
6614   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6615   Dali::Property::Index arg2 ;
6616
6617   arg1 = (Dali::Property::Map *)jarg1;
6618   arg2 = (Dali::Property::Index)jarg2;
6619   {
6620     try {
6621       (arg1)->Insert(arg2,(Dali::Property::Value const &)(jarg3));
6622     } CALL_CATCH_EXCEPTION();
6623   }
6624
6625 }
6626
6627
6628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Float__SWIG_2(void * jarg1, int jarg2, float jarg3) {
6629   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6630   Dali::Property::Index arg2 ;
6631
6632   arg1 = (Dali::Property::Map *)jarg1;
6633   arg2 = (Dali::Property::Index)jarg2;
6634   {
6635     try {
6636       (arg1)->Insert(arg2,(Dali::Property::Value const &)(jarg3));
6637     } CALL_CATCH_EXCEPTION();
6638   }
6639
6640 }
6641
6642
6643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_String__SWIG_2(void * jarg1, int jarg2, char * jarg3) {
6644   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6645   Dali::Property::Index arg2 ;
6646
6647   arg1 = (Dali::Property::Map *)jarg1;
6648   arg2 = (Dali::Property::Index)jarg2;
6649   {
6650     try {
6651       (arg1)->Insert(arg2,(Dali::Property::Value const &)(jarg3));
6652     } CALL_CATCH_EXCEPTION();
6653   }
6654
6655 }
6656
6657
6658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Vector2__SWIG_2(void * jarg1, int jarg2, float jarg3, float jarg4) {
6659   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6660   Dali::Property::Index arg2 ;
6661
6662   arg1 = (Dali::Property::Map *)jarg1;
6663   arg2 = (Dali::Property::Index)jarg2;
6664   {
6665     try {
6666       (arg1)->Insert(arg2,(Dali::Property::Value const &)(Dali::Vector2(jarg3, jarg4)));
6667     } CALL_CATCH_EXCEPTION();
6668   }
6669
6670 }
6671
6672
6673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Vector3__SWIG_2(void * jarg1, int jarg2, float jarg3, float jarg4, float jarg5) {
6674   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6675   Dali::Property::Index arg2 ;
6676
6677   arg1 = (Dali::Property::Map *)jarg1;
6678   arg2 = (Dali::Property::Index)jarg2;
6679   {
6680     try {
6681       (arg1)->Insert(arg2,(Dali::Property::Value const &)(Dali::Vector3(jarg3, jarg4, jarg5)));
6682     } CALL_CATCH_EXCEPTION();
6683   }
6684
6685 }
6686
6687
6688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Vector4__SWIG_2(void * jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
6689   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6690   Dali::Property::Index arg2 ;
6691
6692   arg1 = (Dali::Property::Map *)jarg1;
6693   arg2 = (Dali::Property::Index)jarg2;
6694   {
6695     try {
6696       (arg1)->Insert(arg2,(Dali::Property::Value const &)(Dali::Vector4(jarg3, jarg4, jarg5, jarg6)));
6697     } CALL_CATCH_EXCEPTION();
6698   }
6699
6700 }
6701
6702
6703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
6704   void * jresult ;
6705   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6706   char *arg2 = (char *) 0 ;
6707   Dali::Property::Value *arg3 = 0 ;
6708   Dali::Property::Map *result = 0 ;
6709
6710   arg1 = (Dali::Property::Map *)jarg1;
6711   arg2 = (char *)jarg2;
6712   arg3 = (Dali::Property::Value *)jarg3;
6713   if (!arg3) {
6714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
6715     return 0;
6716   }
6717   {
6718     try {
6719       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
6720     } CALL_CATCH_EXCEPTION(0);
6721   }
6722
6723   jresult = (void *)result;
6724   return jresult;
6725 }
6726
6727
6728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
6729   void * jresult ;
6730   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6731   Dali::Property::Index arg2 ;
6732   Dali::Property::Value *arg3 = 0 ;
6733   Dali::Property::Map *result = 0 ;
6734
6735   arg1 = (Dali::Property::Map *)jarg1;
6736   arg2 = (Dali::Property::Index)jarg2;
6737   arg3 = (Dali::Property::Value *)jarg3;
6738   if (!arg3) {
6739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
6740     return 0;
6741   }
6742   {
6743     try {
6744       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
6745     } CALL_CATCH_EXCEPTION(0);
6746   }
6747
6748   jresult = (void *)result;
6749   return jresult;
6750 }
6751
6752
6753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
6754   void * jresult ;
6755   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6756   Dali::Property::Map::SizeType arg2 ;
6757   Dali::Property::Value *result = 0 ;
6758
6759   arg1 = (Dali::Property::Map *)jarg1;
6760   arg2 = (Dali::Property::Map::SizeType)jarg2;
6761   {
6762     try {
6763       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
6764     } CALL_CATCH_EXCEPTION(0);
6765   }
6766
6767   jresult = (void *)result;
6768   return jresult;
6769 }
6770
6771
6772 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
6773   char * jresult ;
6774   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6775   Dali::Property::Map::SizeType arg2 ;
6776   std::string *result = 0 ;
6777
6778   arg1 = (Dali::Property::Map *)jarg1;
6779   arg2 = (Dali::Property::Map::SizeType)jarg2;
6780   {
6781     try {
6782       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
6783     } CALL_CATCH_EXCEPTION(0);
6784   }
6785
6786   jresult = SWIG_csharp_string_callback(result->c_str());
6787   return jresult;
6788 }
6789
6790
6791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
6792   void * jresult ;
6793   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6794   Dali::Property::Map::SizeType arg2 ;
6795   SwigValueWrapper< Dali::Property::Key > result;
6796
6797   arg1 = (Dali::Property::Map *)jarg1;
6798   arg2 = (Dali::Property::Map::SizeType)jarg2;
6799   {
6800     try {
6801       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
6802     } CALL_CATCH_EXCEPTION(0);
6803   }
6804
6805   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
6806   return jresult;
6807 }
6808
6809
6810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
6811   void * jresult ;
6812   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6813   Dali::Property::Map::SizeType arg2 ;
6814   StringValuePair *result = 0 ;
6815
6816   arg1 = (Dali::Property::Map *)jarg1;
6817   arg2 = (Dali::Property::Map::SizeType)jarg2;
6818   {
6819     try {
6820       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
6821     } CALL_CATCH_EXCEPTION(0);
6822   }
6823
6824   jresult = (void *)result;
6825   return jresult;
6826 }
6827
6828
6829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
6830   void * jresult ;
6831   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6832   char *arg2 = (char *) 0 ;
6833   Dali::Property::Value *result = 0 ;
6834
6835   arg1 = (Dali::Property::Map *)jarg1;
6836   arg2 = (char *)jarg2;
6837   {
6838     try {
6839       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
6840     } CALL_CATCH_EXCEPTION(0);
6841   }
6842
6843   jresult = (void *)result;
6844   return jresult;
6845 }
6846
6847
6848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
6849   void * jresult ;
6850   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6851   Dali::Property::Index arg2 ;
6852   Dali::Property::Value *result = 0 ;
6853
6854   arg1 = (Dali::Property::Map *)jarg1;
6855   arg2 = (Dali::Property::Index)jarg2;
6856   {
6857     try {
6858       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
6859     } CALL_CATCH_EXCEPTION(0);
6860   }
6861
6862   jresult = (void *)result;
6863   return jresult;
6864 }
6865
6866
6867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
6868   void * jresult ;
6869   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6870   Dali::Property::Index arg2 ;
6871   std::string *arg3 = 0 ;
6872   Dali::Property::Value *result = 0 ;
6873
6874   arg1 = (Dali::Property::Map *)jarg1;
6875   arg2 = (Dali::Property::Index)jarg2;
6876   if (!jarg3) {
6877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
6878     return 0;
6879   }
6880   std::string arg3_str(jarg3);
6881   arg3 = &arg3_str;
6882   {
6883     try {
6884       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
6885     } CALL_CATCH_EXCEPTION(0);
6886   }
6887
6888   jresult = (void *)result;
6889
6890   //argout typemap for const std::string&
6891
6892   return jresult;
6893 }
6894
6895
6896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
6897   void * jresult ;
6898   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6899   std::string *arg2 = 0 ;
6900   Dali::Property::Type arg3 ;
6901   Dali::Property::Value *result = 0 ;
6902
6903   arg1 = (Dali::Property::Map *)jarg1;
6904   if (!jarg2) {
6905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
6906     return 0;
6907   }
6908   std::string arg2_str(jarg2);
6909   arg2 = &arg2_str;
6910   arg3 = (Dali::Property::Type)jarg3;
6911   {
6912     try {
6913       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
6914     } CALL_CATCH_EXCEPTION(0);
6915   }
6916
6917   jresult = (void *)result;
6918
6919   //argout typemap for const std::string&
6920
6921   return jresult;
6922 }
6923
6924
6925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
6926   void * jresult ;
6927   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6928   Dali::Property::Index arg2 ;
6929   Dali::Property::Type arg3 ;
6930   Dali::Property::Value *result = 0 ;
6931
6932   arg1 = (Dali::Property::Map *)jarg1;
6933   arg2 = (Dali::Property::Index)jarg2;
6934   arg3 = (Dali::Property::Type)jarg3;
6935   {
6936     try {
6937       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
6938     } CALL_CATCH_EXCEPTION(0);
6939   }
6940
6941   jresult = (void *)result;
6942   return jresult;
6943 }
6944
6945
6946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
6947   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6948
6949   arg1 = (Dali::Property::Map *)jarg1;
6950   {
6951     try {
6952       (arg1)->Clear();
6953     } CALL_CATCH_EXCEPTION();
6954   }
6955
6956 }
6957
6958
6959 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Map_Remove__SWIG_0(void * map, int key) {
6960   Dali::Property::Map *propertyMap = (Dali::Property::Map *)map;
6961   Dali::Property::Index intKey = (Dali::Property::Index)key;
6962   bool isRemoved = false;
6963   {
6964     try {
6965       isRemoved = propertyMap->Remove(intKey);
6966     } CALL_CATCH_EXCEPTION(0);
6967   }
6968   return isRemoved;
6969 }
6970
6971
6972 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Map_Remove__SWIG_1(void * map, char * key) {
6973   Dali::Property::Map *propertyMap = (Dali::Property::Map *)map;
6974   std::string strKey(key);
6975   bool isRemoved = false;
6976   {
6977     try {
6978       isRemoved = propertyMap->Remove(strKey);
6979     } CALL_CATCH_EXCEPTION(0);
6980   }
6981   return isRemoved;
6982 }
6983
6984
6985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
6986   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6987   Dali::Property::Map *arg2 = 0 ;
6988
6989   arg1 = (Dali::Property::Map *)jarg1;
6990   arg2 = (Dali::Property::Map *)jarg2;
6991   if (!arg2) {
6992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
6993     return ;
6994   }
6995   {
6996     try {
6997       (arg1)->Merge((Dali::Property::Map const &)*arg2);
6998     } CALL_CATCH_EXCEPTION();
6999   }
7000
7001 }
7002
7003
7004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
7005   void * jresult ;
7006   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
7007   std::string *arg2 = 0 ;
7008   Dali::Property::Value *result = 0 ;
7009
7010   arg1 = (Dali::Property::Map *)jarg1;
7011   if (!jarg2) {
7012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
7013     return 0;
7014   }
7015   std::string arg2_str(jarg2);
7016   arg2 = &arg2_str;
7017   {
7018     try {
7019       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
7020     } CALL_CATCH_EXCEPTION(0);
7021   }
7022
7023   jresult = (void *)result;
7024
7025   //argout typemap for const std::string&
7026
7027   return jresult;
7028 }
7029
7030
7031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
7032   void * jresult ;
7033   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
7034   Dali::Property::Index arg2 ;
7035   Dali::Property::Value *result = 0 ;
7036
7037   arg1 = (Dali::Property::Map *)jarg1;
7038   arg2 = (Dali::Property::Index)jarg2;
7039   {
7040     try {
7041       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
7042     } CALL_CATCH_EXCEPTION(0);
7043   }
7044
7045   jresult = (void *)result;
7046   return jresult;
7047 }
7048
7049
7050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
7051   void * jresult ;
7052   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
7053   Dali::Property::Map *arg2 = 0 ;
7054   Dali::Property::Map *result = 0 ;
7055
7056   arg1 = (Dali::Property::Map *)jarg1;
7057   arg2 = (Dali::Property::Map *)jarg2;
7058   if (!arg2) {
7059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
7060     return 0;
7061   }
7062   {
7063     try {
7064       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
7065     } CALL_CATCH_EXCEPTION(0);
7066   }
7067
7068   jresult = (void *)result;
7069   return jresult;
7070 }
7071
7072
7073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) {
7074
7075   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7076
7077   if (!jarg2) {
7078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
7079     return;
7080   }
7081   std::string arg2_str(jarg2);
7082   std::string* arg2 = &arg2_str;
7083
7084   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
7085
7086   {
7087     try {
7088       arg1->operator[]((std::string const &)*arg2) = *arg3;
7089     } CALL_CATCH_EXCEPTION();
7090   }
7091 }
7092
7093
7094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey_IntValue(void* jarg1, const char* jarg2, int jarg3) {
7095
7096   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7097
7098   if (!jarg2) {
7099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
7100     return;
7101   }
7102   Dali::Property::Index arg3 = (Dali::Property::Index)jarg3;
7103
7104   {
7105     try {
7106       arg1->operator[](std::string_view(jarg2)) = (Dali::Property::Value const &)(arg3);
7107     } CALL_CATCH_EXCEPTION();
7108   }
7109 }
7110
7111
7112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey_BoolValue(void* jarg1, const char* jarg2, bool jarg3) {
7113
7114   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7115
7116   if (!jarg2) {
7117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
7118     return;
7119   }
7120
7121   {
7122     try {
7123       arg1->operator[](std::string_view(jarg2)) = (Dali::Property::Value const &)(jarg3);
7124     } CALL_CATCH_EXCEPTION();
7125   }
7126 }
7127
7128
7129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey_FloatValue(void* jarg1, const char* jarg2, float jarg3) {
7130
7131   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7132
7133   if (!jarg2) {
7134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
7135     return;
7136   }
7137
7138   {
7139     try {
7140       arg1->operator[](std::string_view(jarg2)) = (Dali::Property::Value const &)(jarg3);
7141     } CALL_CATCH_EXCEPTION();
7142   }
7143 }
7144
7145
7146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey_StringValue(void* jarg1, const char* jarg2, const char* jarg3) {
7147
7148   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7149
7150   if (!jarg2) {
7151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
7152     return;
7153   }
7154
7155   {
7156     try {
7157       arg1->operator[](std::string_view(jarg2)) = (Dali::Property::Value const &)(jarg3);
7158     } CALL_CATCH_EXCEPTION();
7159   }
7160 }
7161
7162
7163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey_Vector2(void* jarg1, const char* jarg2, float jarg3, float jarg4) {
7164
7165   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7166
7167   if (!jarg2) {
7168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
7169     return;
7170   }
7171
7172   {
7173     try {
7174       arg1->operator[](std::string_view(jarg2)) = (Dali::Property::Value const &)(Dali::Vector2(jarg3, jarg4));
7175     } CALL_CATCH_EXCEPTION();
7176   }
7177 }
7178
7179
7180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey_Vector4(void* jarg1, const char* jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
7181
7182   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7183
7184   if (!jarg2) {
7185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
7186     return;
7187   }
7188
7189   {
7190     try {
7191       arg1->operator[](std::string_view(jarg2)) = (Dali::Property::Value const &)(Dali::Vector4(jarg3, jarg4, jarg5, jarg6));
7192     } CALL_CATCH_EXCEPTION();
7193   }
7194 }
7195
7196
7197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey_Rect(void* jarg1, char* jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
7198
7199   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7200
7201   if (!jarg2) {
7202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
7203     return;
7204   }
7205
7206   {
7207     try {
7208       arg1->operator[](std::string(jarg2)) = (Dali::Property::Value const &)(Dali::Rect< int >(jarg3, jarg4, jarg5, jarg6));
7209     } CALL_CATCH_EXCEPTION();
7210   }
7211 }
7212
7213
7214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
7215
7216   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7217   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
7218   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
7219
7220   {
7221     try {
7222       arg1->operator[](arg2) = *arg3;
7223     } CALL_CATCH_EXCEPTION();
7224   }
7225 }
7226
7227
7228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey_IntValue(void* jarg1, int jarg2, int jarg3) {
7229
7230   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7231   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
7232   Dali::Property::Index arg3 = (Dali::Property::Index)jarg3;
7233
7234   {
7235     try {
7236       arg1->operator[](arg2) = (Dali::Property::Value const &)(arg3);
7237     } CALL_CATCH_EXCEPTION();
7238   }
7239 }
7240
7241
7242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey_BoolValue(void* jarg1, int jarg2, bool jarg3) {
7243
7244   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7245   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
7246   bool arg3 = (bool)jarg3;
7247
7248   {
7249     try {
7250       arg1->operator[](arg2) = (Dali::Property::Value const &)(arg3);
7251     } CALL_CATCH_EXCEPTION();
7252   }
7253 }
7254
7255
7256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey_FloatValue(void* jarg1, int jarg2, float jarg3) {
7257
7258   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7259   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
7260   float arg3 = (float)jarg3;
7261
7262   {
7263     try {
7264       arg1->operator[](arg2) = (Dali::Property::Value const &)(arg3);
7265     } CALL_CATCH_EXCEPTION();
7266   }
7267 }
7268
7269
7270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey_StringValue(void* jarg1, int jarg2, char* jarg3) {
7271
7272   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7273   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
7274   char *arg3 = (char *)jarg3;
7275
7276   {
7277     try {
7278       arg1->operator[](arg2) = (Dali::Property::Value const &)(arg3);
7279     } CALL_CATCH_EXCEPTION();
7280   }
7281 }
7282
7283
7284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey_Vector2(void* jarg1, int jarg2, float jarg3, float jarg4) {
7285
7286   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7287   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
7288
7289   {
7290     try {
7291       arg1->operator[](arg2) = (Dali::Property::Value const &)(Dali::Vector2(jarg3, jarg4));
7292     } CALL_CATCH_EXCEPTION();
7293   }
7294 }
7295
7296
7297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey_Vector4(void* jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
7298
7299   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7300   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
7301
7302   {
7303     try {
7304       arg1->operator[](arg2) = (Dali::Property::Value const &)(Dali::Vector4(jarg3, jarg4, jarg5, jarg6));
7305     } CALL_CATCH_EXCEPTION();
7306   }
7307 }
7308
7309
7310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey_Rect(void* jarg1, int jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
7311
7312   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7313   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
7314   Dali::Rect< int > *arg3 = 0 ;
7315
7316   arg3 = (Dali::Rect< int > *)new Dali::Rect< int >(jarg3, jarg4, jarg5, jarg6);
7317
7318   {
7319     try {
7320       arg1->operator[](arg2) = (Dali::Property::Value const &)(*arg3);
7321     } CALL_CATCH_EXCEPTION();
7322   }
7323 }
7324
7325
7326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
7327   void * jresult ;
7328   Dali::Property::Value *result = 0 ;
7329
7330   {
7331     try {
7332       result = (Dali::Property::Value *)new Dali::Property::Value();
7333     } CALL_CATCH_EXCEPTION(0);
7334   }
7335
7336   jresult = (void *)result;
7337   return jresult;
7338 }
7339
7340
7341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(bool jarg1) {
7342   void * jresult ;
7343   bool arg1 ;
7344   Dali::Property::Value *result = 0 ;
7345
7346   arg1 = jarg1 ? true : false;
7347   {
7348     try {
7349       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
7350     } CALL_CATCH_EXCEPTION(0);
7351   }
7352
7353   jresult = (void *)result;
7354   return jresult;
7355 }
7356
7357
7358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
7359   void * jresult ;
7360   int arg1 ;
7361   Dali::Property::Value *result = 0 ;
7362
7363   arg1 = (int)jarg1;
7364   {
7365     try {
7366       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
7367     } CALL_CATCH_EXCEPTION(0);
7368   }
7369
7370   jresult = (void *)result;
7371   return jresult;
7372 }
7373
7374
7375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
7376   void * jresult ;
7377   float arg1 ;
7378   Dali::Property::Value *result = 0 ;
7379
7380   arg1 = (float)jarg1;
7381   {
7382     try {
7383       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
7384     } CALL_CATCH_EXCEPTION(0);
7385   }
7386
7387   jresult = (void *)result;
7388   return jresult;
7389 }
7390
7391
7392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
7393   void * jresult ;
7394   Dali::Vector2 *arg1 = 0 ;
7395   Dali::Property::Value *result = 0 ;
7396
7397   arg1 = (Dali::Vector2 *)jarg1;
7398   if (!arg1) {
7399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7400     return 0;
7401   }
7402   {
7403     try {
7404       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
7405     } CALL_CATCH_EXCEPTION(0);
7406   }
7407
7408   jresult = (void *)result;
7409   return jresult;
7410 }
7411
7412
7413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
7414   void * jresult ;
7415   Dali::Vector3 *arg1 = 0 ;
7416   Dali::Property::Value *result = 0 ;
7417
7418   arg1 = (Dali::Vector3 *)jarg1;
7419   if (!arg1) {
7420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7421     return 0;
7422   }
7423   {
7424     try {
7425       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
7426     } CALL_CATCH_EXCEPTION(0);
7427   }
7428
7429   jresult = (void *)result;
7430   return jresult;
7431 }
7432
7433
7434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
7435   void * jresult ;
7436   Dali::Vector4 *arg1 = 0 ;
7437   Dali::Property::Value *result = 0 ;
7438
7439   arg1 = (Dali::Vector4 *)jarg1;
7440   if (!arg1) {
7441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7442     return 0;
7443   }
7444   {
7445     try {
7446       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
7447     } CALL_CATCH_EXCEPTION(0);
7448   }
7449
7450   jresult = (void *)result;
7451   return jresult;
7452 }
7453
7454
7455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
7456   void * jresult ;
7457   Dali::Matrix3 *arg1 = 0 ;
7458   Dali::Property::Value *result = 0 ;
7459
7460   arg1 = (Dali::Matrix3 *)jarg1;
7461   if (!arg1) {
7462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
7463     return 0;
7464   }
7465   {
7466     try {
7467       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
7468     } CALL_CATCH_EXCEPTION(0);
7469   }
7470
7471   jresult = (void *)result;
7472   return jresult;
7473 }
7474
7475
7476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
7477   void * jresult ;
7478   Dali::Matrix *arg1 = 0 ;
7479   Dali::Property::Value *result = 0 ;
7480
7481   arg1 = (Dali::Matrix *)jarg1;
7482   if (!arg1) {
7483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7484     return 0;
7485   }
7486   {
7487     try {
7488       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
7489     } CALL_CATCH_EXCEPTION(0);
7490   }
7491
7492   jresult = (void *)result;
7493   return jresult;
7494 }
7495
7496
7497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
7498   void * jresult ;
7499   Dali::Rect< int > *arg1 = 0 ;
7500   Dali::Property::Value *result = 0 ;
7501
7502   arg1 = (Dali::Rect< int > *)jarg1;
7503   if (!arg1) {
7504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
7505     return 0;
7506   }
7507   {
7508     try {
7509       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
7510     } CALL_CATCH_EXCEPTION(0);
7511   }
7512
7513   jresult = (void *)result;
7514   return jresult;
7515 }
7516
7517
7518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
7519   void * jresult ;
7520   Dali::AngleAxis *arg1 = 0 ;
7521   Dali::Property::Value *result = 0 ;
7522
7523   arg1 = (Dali::AngleAxis *)jarg1;
7524   if (!arg1) {
7525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
7526     return 0;
7527   }
7528   {
7529     try {
7530       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
7531     } CALL_CATCH_EXCEPTION(0);
7532   }
7533
7534   jresult = (void *)result;
7535   return jresult;
7536 }
7537
7538
7539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
7540   void * jresult ;
7541   Dali::Quaternion *arg1 = 0 ;
7542   Dali::Property::Value *result = 0 ;
7543
7544   arg1 = (Dali::Quaternion *)jarg1;
7545   if (!arg1) {
7546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7547     return 0;
7548   }
7549   {
7550     try {
7551       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
7552     } CALL_CATCH_EXCEPTION(0);
7553   }
7554
7555   jresult = (void *)result;
7556   return jresult;
7557 }
7558
7559
7560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
7561   void * jresult ;
7562   std::string *arg1 = 0 ;
7563   Dali::Property::Value *result = 0 ;
7564
7565   if (!jarg1) {
7566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
7567     return 0;
7568   }
7569   std::string arg1_str(jarg1);
7570   arg1 = &arg1_str;
7571   {
7572     try {
7573       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
7574     } CALL_CATCH_EXCEPTION(0);
7575   }
7576
7577   jresult = (void *)result;
7578
7579   //argout typemap for const std::string&
7580
7581   return jresult;
7582 }
7583
7584
7585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
7586   void * jresult ;
7587   Dali::Property::Array *arg1 = 0 ;
7588   Dali::Property::Value *result = 0 ;
7589
7590   arg1 = (Dali::Property::Array *)jarg1;
7591   if (!arg1) {
7592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
7593     return 0;
7594   }
7595   {
7596     try {
7597       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
7598     } CALL_CATCH_EXCEPTION(0);
7599   }
7600
7601   jresult = (void *)result;
7602   return jresult;
7603 }
7604
7605
7606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
7607   void * jresult ;
7608   Dali::Property::Map *arg1 = 0 ;
7609   Dali::Property::Value *result = 0 ;
7610
7611   arg1 = (Dali::Property::Map *)jarg1;
7612   if (!arg1) {
7613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
7614     return 0;
7615   }
7616   {
7617     try {
7618       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
7619     } CALL_CATCH_EXCEPTION(0);
7620   }
7621
7622   jresult = (void *)result;
7623   return jresult;
7624 }
7625
7626
7627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
7628   void * jresult ;
7629   Extents *arg1 = 0 ;
7630   Dali::Property::Value *result = 0 ;
7631
7632   arg1 = (Extents *)jarg1;
7633   if (!arg1) {
7634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
7635     return 0;
7636   }
7637   {
7638     try {
7639       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
7640     } CALL_CATCH_EXCEPTION(0);
7641   }
7642
7643   jresult = (void*) result;
7644   return jresult;
7645 }
7646
7647
7648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
7649   void * jresult ;
7650   Dali::Property::Type arg1 ;
7651   Dali::Property::Value *result = 0 ;
7652
7653   arg1 = (Dali::Property::Type)jarg1;
7654   {
7655     try {
7656       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
7657     } CALL_CATCH_EXCEPTION(0);
7658   }
7659
7660   jresult = (void *)result;
7661   return jresult;
7662 }
7663
7664
7665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
7666   void * jresult ;
7667   Dali::Property::Value *arg1 = 0 ;
7668   Dali::Property::Value *result = 0 ;
7669
7670   arg1 = (Dali::Property::Value *)jarg1;
7671   if (!arg1) {
7672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
7673     return 0;
7674   }
7675   {
7676     try {
7677       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
7678     } CALL_CATCH_EXCEPTION(0);
7679   }
7680
7681   jresult = (void *)result;
7682   return jresult;
7683 }
7684
7685
7686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
7687   void * jresult ;
7688   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7689   Dali::Property::Value *arg2 = 0 ;
7690   Dali::Property::Value *result = 0 ;
7691
7692   arg1 = (Dali::Property::Value *)jarg1;
7693   arg2 = (Dali::Property::Value *)jarg2;
7694   if (!arg2) {
7695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
7696     return 0;
7697   }
7698   {
7699     try {
7700       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
7701     } CALL_CATCH_EXCEPTION(0);
7702   }
7703
7704   jresult = (void *)result;
7705   return jresult;
7706 }
7707
7708
7709 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_EqualTo(void * jarg1, void * jarg2) {
7710   bool jresult;
7711   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7712   Dali::Property::Value *arg2 = 0 ;
7713   bool result;
7714
7715   arg1 = (Dali::Property::Value *)jarg1;
7716   arg2 = (Dali::Property::Value *)jarg2;
7717   if (!arg2) {
7718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
7719     return 0;
7720   }
7721   {
7722     try {
7723       result = (bool)((Dali::Property::Value const *)arg1)->operator ==((Dali::Property::Value const &)*arg2);
7724     } CALL_CATCH_EXCEPTION(0);
7725   }
7726
7727   jresult = result;
7728   return jresult;
7729 }
7730
7731 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_NotEqualTo(void * jarg1, void * jarg2) {
7732   bool jresult;
7733   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7734   Dali::Property::Value *arg2 = 0 ;
7735   bool result;
7736
7737   arg1 = (Dali::Property::Value *)jarg1;
7738   arg2 = (Dali::Property::Value *)jarg2;
7739   if (!arg2) {
7740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
7741     return 0;
7742   }
7743   {
7744     try {
7745       result = (bool)((Dali::Property::Value const *)arg1)->operator !=((Dali::Property::Value const &)*arg2);
7746     } CALL_CATCH_EXCEPTION(0);
7747   }
7748
7749   jresult = result;
7750   return jresult;
7751 }
7752
7753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
7754   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7755
7756   arg1 = (Dali::Property::Value *)jarg1;
7757   {
7758     try {
7759       delete arg1;
7760     } CALL_CATCH_EXCEPTION();
7761   }
7762
7763 }
7764
7765
7766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
7767   int jresult ;
7768   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7769   Dali::Property::Type result;
7770
7771   arg1 = (Dali::Property::Value *)jarg1;
7772   {
7773     try {
7774       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
7775     } CALL_CATCH_EXCEPTION(0);
7776   }
7777
7778   jresult = (int)result;
7779   return jresult;
7780 }
7781
7782
7783 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, bool * jarg2) {
7784   bool jresult ;
7785   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7786   bool *arg2 = 0 ;
7787   bool result;
7788
7789   arg1 = (Dali::Property::Value *)jarg1;
7790   arg2 = (bool *)jarg2;
7791   {
7792     try {
7793       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7794     } CALL_CATCH_EXCEPTION(0);
7795   }
7796
7797   jresult = result;
7798   return jresult;
7799 }
7800
7801
7802 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
7803   bool jresult ;
7804   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7805   float *arg2 = 0 ;
7806   bool result;
7807
7808   arg1 = (Dali::Property::Value *)jarg1;
7809   arg2 = (float *)jarg2;
7810   {
7811     try {
7812       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7813     } CALL_CATCH_EXCEPTION(0);
7814   }
7815
7816   jresult = result;
7817   return jresult;
7818 }
7819
7820
7821 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
7822   bool jresult ;
7823   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7824   int *arg2 = 0 ;
7825   bool result;
7826
7827   arg1 = (Dali::Property::Value *)jarg1;
7828   arg2 = (int *)jarg2;
7829   {
7830     try {
7831       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7832     } CALL_CATCH_EXCEPTION(0);
7833   }
7834
7835   jresult = result;
7836   return jresult;
7837 }
7838
7839
7840 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
7841   bool jresult ;
7842   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7843   Dali::Rect< int > *arg2 = 0 ;
7844   bool result;
7845
7846   arg1 = (Dali::Property::Value *)jarg1;
7847   arg2 = (Dali::Rect< int > *)jarg2;
7848   if (!arg2) {
7849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
7850     return 0;
7851   }
7852   {
7853     try {
7854       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7855     } CALL_CATCH_EXCEPTION(0);
7856   }
7857
7858   jresult = result;
7859   return jresult;
7860 }
7861
7862
7863 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
7864   bool jresult ;
7865   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7866   Dali::Vector2 *arg2 = 0 ;
7867   bool result;
7868
7869   arg1 = (Dali::Property::Value *)jarg1;
7870   arg2 = (Dali::Vector2 *)jarg2;
7871   if (!arg2) {
7872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
7873     return 0;
7874   }
7875   {
7876     try {
7877       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7878     } CALL_CATCH_EXCEPTION(0);
7879   }
7880
7881   jresult = result;
7882   return jresult;
7883 }
7884
7885
7886 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
7887   bool jresult ;
7888   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7889   Dali::Vector3 *arg2 = 0 ;
7890   bool result;
7891
7892   arg1 = (Dali::Property::Value *)jarg1;
7893   arg2 = (Dali::Vector3 *)jarg2;
7894   if (!arg2) {
7895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
7896     return 0;
7897   }
7898   {
7899     try {
7900       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7901     } CALL_CATCH_EXCEPTION(0);
7902   }
7903
7904   jresult = result;
7905   return jresult;
7906 }
7907
7908
7909 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
7910   bool jresult ;
7911   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7912   Dali::Vector4 *arg2 = 0 ;
7913   bool result;
7914
7915   arg1 = (Dali::Property::Value *)jarg1;
7916   arg2 = (Dali::Vector4 *)jarg2;
7917   if (!arg2) {
7918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
7919     return 0;
7920   }
7921   {
7922     try {
7923       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7924     } CALL_CATCH_EXCEPTION(0);
7925   }
7926
7927   jresult = result;
7928   return jresult;
7929 }
7930
7931
7932 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
7933   bool jresult ;
7934   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7935   Dali::Matrix3 *arg2 = 0 ;
7936   bool result;
7937
7938   arg1 = (Dali::Property::Value *)jarg1;
7939   arg2 = (Dali::Matrix3 *)jarg2;
7940   if (!arg2) {
7941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
7942     return 0;
7943   }
7944   {
7945     try {
7946       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7947     } CALL_CATCH_EXCEPTION(0);
7948   }
7949
7950   jresult = result;
7951   return jresult;
7952 }
7953
7954
7955 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
7956   bool jresult ;
7957   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7958   Dali::Matrix *arg2 = 0 ;
7959   bool result;
7960
7961   arg1 = (Dali::Property::Value *)jarg1;
7962   arg2 = (Dali::Matrix *)jarg2;
7963   if (!arg2) {
7964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
7965     return 0;
7966   }
7967   {
7968     try {
7969       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7970     } CALL_CATCH_EXCEPTION(0);
7971   }
7972
7973   jresult = result;
7974   return jresult;
7975 }
7976
7977
7978 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
7979   bool jresult ;
7980   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7981   Dali::AngleAxis *arg2 = 0 ;
7982   bool result;
7983
7984   arg1 = (Dali::Property::Value *)jarg1;
7985   arg2 = (Dali::AngleAxis *)jarg2;
7986   if (!arg2) {
7987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
7988     return 0;
7989   }
7990   {
7991     try {
7992       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7993     } CALL_CATCH_EXCEPTION(0);
7994   }
7995
7996   jresult = result;
7997   return jresult;
7998 }
7999
8000
8001 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
8002   bool jresult ;
8003   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
8004   Dali::Quaternion *arg2 = 0 ;
8005   bool result;
8006
8007   arg1 = (Dali::Property::Value *)jarg1;
8008   arg2 = (Dali::Quaternion *)jarg2;
8009   if (!arg2) {
8010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
8011     return 0;
8012   }
8013   {
8014     try {
8015       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
8016     } CALL_CATCH_EXCEPTION(0);
8017   }
8018
8019   jresult = result;
8020   return jresult;
8021 }
8022
8023
8024 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
8025   bool jresult ;
8026   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
8027   std::string *arg2 = 0 ;
8028   bool result;
8029
8030   arg1 = (Dali::Property::Value *)jarg1;
8031
8032   //typemap in
8033   std::string temp;
8034   arg2 = &temp;
8035
8036   {
8037     try {
8038       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
8039     } CALL_CATCH_EXCEPTION(0);
8040   }
8041
8042   jresult = result;
8043
8044   //Typemap argout in c++ file.
8045   //This will convert c++ string to c# string
8046   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
8047
8048   return jresult;
8049 }
8050
8051
8052 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
8053   bool jresult ;
8054   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
8055   Dali::Property::Array *arg2 = 0 ;
8056   bool result;
8057
8058   arg1 = (Dali::Property::Value *)jarg1;
8059   arg2 = (Dali::Property::Array *)jarg2;
8060   if (!arg2) {
8061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
8062     return 0;
8063   }
8064   {
8065     try {
8066       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
8067     } CALL_CATCH_EXCEPTION(0);
8068   }
8069
8070   jresult = result;
8071   return jresult;
8072 }
8073
8074
8075 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
8076   bool jresult ;
8077   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
8078   Dali::Property::Map *arg2 = 0 ;
8079   bool result;
8080
8081   arg1 = (Dali::Property::Value *)jarg1;
8082   arg2 = (Dali::Property::Map *)jarg2;
8083   if (!arg2) {
8084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
8085     return 0;
8086   }
8087   {
8088     try {
8089       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
8090     } CALL_CATCH_EXCEPTION(0);
8091   }
8092
8093   jresult = result;
8094   return jresult;
8095 }
8096
8097
8098 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
8099   bool jresult ;
8100   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
8101   Extents *arg2 = 0 ;
8102   bool result;
8103
8104   arg1 = (Dali::Property::Value *)jarg1;
8105   arg2 = (Extents *)jarg2;
8106   if (!arg2) {
8107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
8108     return 0;
8109   }
8110   {
8111     try {
8112       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
8113     } CALL_CATCH_EXCEPTION(0);
8114   }
8115   jresult = result;
8116   return jresult;
8117 }
8118
8119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
8120   void * jresult ;
8121   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
8122   Dali::Property::Array *result = 0 ;
8123
8124   arg1 = (Dali::Property::Value *)jarg1;
8125   {
8126     try {
8127       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
8128     } CALL_CATCH_EXCEPTION(0);
8129   }
8130
8131   jresult = (void *)result;
8132   return jresult;
8133 }
8134
8135
8136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
8137   void * jresult ;
8138   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
8139   Dali::Property::Map *result = 0 ;
8140
8141   arg1 = (Dali::Property::Value *)jarg1;
8142   {
8143     try {
8144       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
8145     } CALL_CATCH_EXCEPTION(0);
8146   }
8147
8148   jresult = (void *)result;
8149   return jresult;
8150 }
8151
8152
8153 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
8154   char * jresult ;
8155   Dali::Property::Type arg1 ;
8156   char *result = 0 ;
8157
8158   arg1 = (Dali::Property::Type)jarg1;
8159   {
8160     try {
8161       result = (char *)Dali::PropertyTypes::GetName(arg1);
8162     } CALL_CATCH_EXCEPTION(0);
8163   }
8164
8165   jresult = SWIG_csharp_string_callback((const char *)result);
8166   return jresult;
8167 }
8168
8169
8170 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
8171   bool jresult ;
8172   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
8173   std::string *arg2 = 0 ;
8174   Dali::Property::Map *arg3 = 0 ;
8175   bool result;
8176
8177   arg1 = (Dali::BaseObject *)jarg1;
8178   if (!jarg2) {
8179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
8180     return 0;
8181   }
8182   std::string arg2_str(jarg2);
8183   arg2 = &arg2_str;
8184   arg3 = (Dali::Property::Map *)jarg3;
8185   if (!arg3) {
8186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
8187     return 0;
8188   }
8189   {
8190     try {
8191       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
8192     } CALL_CATCH_EXCEPTION(0);
8193   }
8194
8195   jresult = result;
8196
8197   //argout typemap for const std::string&
8198
8199   return jresult;
8200 }
8201
8202
8203 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
8204   char * jresult ;
8205   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
8206   std::string *result = 0 ;
8207
8208   arg1 = (Dali::BaseObject *)jarg1;
8209   {
8210     try {
8211       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
8212     } CALL_CATCH_EXCEPTION(0);
8213   }
8214
8215   jresult = SWIG_csharp_string_callback(result->c_str());
8216   return jresult;
8217 }
8218
8219
8220 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
8221   bool jresult ;
8222   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
8223   Dali::TypeInfo *arg2 = 0 ;
8224   bool result;
8225
8226   arg1 = (Dali::BaseObject *)jarg1;
8227   arg2 = (Dali::TypeInfo *)jarg2;
8228   if (!arg2) {
8229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
8230     return 0;
8231   }
8232   {
8233     try {
8234       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
8235     } CALL_CATCH_EXCEPTION(0);
8236   }
8237
8238   jresult = result;
8239   return jresult;
8240 }
8241
8242
8243 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
8244   bool jresult ;
8245   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
8246   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
8247   std::string *arg3 = 0 ;
8248   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
8249   bool result;
8250
8251   arg1 = (Dali::BaseObject *)jarg1;
8252   arg2 = (ConnectionTrackerInterface *)jarg2;
8253   if (!jarg3) {
8254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
8255     return 0;
8256   }
8257   std::string arg3_str(jarg3);
8258   arg3 = &arg3_str;
8259   arg4 = (FunctorDelegate *)jarg4;
8260   {
8261     try {
8262       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
8263     } CALL_CATCH_EXCEPTION(0);
8264   }
8265
8266   jresult = result;
8267
8268   //argout typemap for const std::string&
8269
8270   return jresult;
8271 }
8272
8273
8274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
8275   void * jresult ;
8276   Dali::BaseHandle *arg1 = 0 ;
8277   Dali::BaseObject *result = 0 ;
8278
8279   arg1 = (Dali::BaseHandle *)jarg1;
8280   if (!arg1) {
8281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
8282     return 0;
8283   }
8284   {
8285     try {
8286       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
8287     } CALL_CATCH_EXCEPTION(0);
8288   }
8289
8290   jresult = (void *)result;
8291   return jresult;
8292 }
8293
8294
8295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
8296   void * jresult ;
8297   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
8298   Dali::BaseHandle *result = 0 ;
8299
8300   arg1 = (Dali::BaseObject *)jarg1;
8301   {
8302     try {
8303       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
8304     } CALL_CATCH_EXCEPTION(0);
8305   }
8306
8307   jresult = (void *)result;
8308   return jresult;
8309 }
8310
8311
8312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
8313   void * jresult ;
8314   Dali::BaseHandle *result = 0 ;
8315
8316   {
8317     try {
8318       result = (Dali::BaseHandle *)new Dali::BaseHandle();
8319     } CALL_CATCH_EXCEPTION(0);
8320   }
8321
8322   jresult = (void *)result;
8323   return jresult;
8324 }
8325
8326
8327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
8328   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8329
8330   arg1 = (Dali::BaseHandle *)jarg1;
8331   {
8332     try {
8333       delete arg1;
8334     } CALL_CATCH_EXCEPTION();
8335   }
8336
8337 }
8338
8339
8340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
8341   void * jresult ;
8342   Dali::BaseHandle *arg1 = 0 ;
8343   Dali::BaseHandle *result = 0 ;
8344
8345   arg1 = (Dali::BaseHandle *)jarg1;
8346   if (!arg1) {
8347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
8348     return 0;
8349   }
8350   {
8351     try {
8352       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
8353     } CALL_CATCH_EXCEPTION(0);
8354   }
8355
8356   jresult = (void *)result;
8357   return jresult;
8358 }
8359
8360
8361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
8362   void * jresult ;
8363   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8364   Dali::BaseHandle *arg2 = 0 ;
8365   Dali::BaseHandle *result = 0 ;
8366
8367   arg1 = (Dali::BaseHandle *)jarg1;
8368   arg2 = (Dali::BaseHandle *)jarg2;
8369   if (!arg2) {
8370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
8371     return 0;
8372   }
8373   {
8374     try {
8375       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
8376     } CALL_CATCH_EXCEPTION(0);
8377   }
8378
8379   jresult = (void *)result;
8380   return jresult;
8381 }
8382
8383
8384 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
8385   bool jresult ;
8386   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8387   std::string *arg2 = 0 ;
8388   Dali::Property::Map *arg3 = 0 ;
8389   bool result;
8390
8391   arg1 = (Dali::BaseHandle *)jarg1;
8392   if (!jarg2) {
8393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
8394     return 0;
8395   }
8396   std::string arg2_str(jarg2);
8397   arg2 = &arg2_str;
8398   arg3 = (Dali::Property::Map *)jarg3;
8399   if (!arg3) {
8400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
8401     return 0;
8402   }
8403   {
8404     try {
8405       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
8406     } CALL_CATCH_EXCEPTION(0);
8407   }
8408
8409   jresult = result;
8410
8411   //argout typemap for const std::string&
8412
8413   return jresult;
8414 }
8415
8416
8417 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
8418   char * jresult ;
8419   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8420   std::string *result = 0 ;
8421
8422   arg1 = (Dali::BaseHandle *)jarg1;
8423   {
8424     try {
8425       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
8426     } CALL_CATCH_EXCEPTION(0);
8427   }
8428
8429   jresult = SWIG_csharp_string_callback(result->c_str());
8430   return jresult;
8431 }
8432
8433
8434 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
8435   bool jresult ;
8436   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8437   Dali::TypeInfo *arg2 = 0 ;
8438   bool result;
8439
8440   arg1 = (Dali::BaseHandle *)jarg1;
8441   arg2 = (Dali::TypeInfo *)jarg2;
8442   if (!arg2) {
8443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
8444     return 0;
8445   }
8446   {
8447     try {
8448       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
8449     } CALL_CATCH_EXCEPTION(0);
8450   }
8451
8452   jresult = result;
8453   return jresult;
8454 }
8455
8456
8457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
8458   void * jresult ;
8459   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8460   Dali::BaseObject *result = 0 ;
8461
8462   arg1 = (Dali::BaseHandle *)jarg1;
8463   {
8464     try {
8465       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
8466     } CALL_CATCH_EXCEPTION(0);
8467   }
8468
8469   jresult = (void *)result;
8470   return jresult;
8471 }
8472
8473
8474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
8475   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8476
8477   arg1 = (Dali::BaseHandle *)jarg1;
8478   {
8479     try {
8480       (arg1)->Reset();
8481     } CALL_CATCH_EXCEPTION();
8482   }
8483
8484 }
8485
8486
8487 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
8488   bool jresult ;
8489   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8490   Dali::BaseHandle *arg2 = 0 ;
8491   bool result;
8492
8493   arg1 = (Dali::BaseHandle *)jarg1;
8494   arg2 = (Dali::BaseHandle *)jarg2;
8495   if (!arg2) {
8496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
8497     return 0;
8498   }
8499   {
8500     try {
8501       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
8502     } CALL_CATCH_EXCEPTION(0);
8503   }
8504
8505   jresult = result;
8506   return jresult;
8507 }
8508
8509
8510 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
8511   bool jresult ;
8512   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8513   Dali::BaseHandle *arg2 = 0 ;
8514   bool result;
8515
8516   arg1 = (Dali::BaseHandle *)jarg1;
8517   arg2 = (Dali::BaseHandle *)jarg2;
8518   if (!arg2) {
8519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
8520     return 0;
8521   }
8522   {
8523     try {
8524       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
8525     } CALL_CATCH_EXCEPTION(0);
8526   }
8527
8528   jresult = result;
8529   return jresult;
8530 }
8531
8532
8533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
8534   void * jresult ;
8535   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8536   Dali::RefObject *result = 0 ;
8537
8538   arg1 = (Dali::BaseHandle *)jarg1;
8539   {
8540     try {
8541       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
8542     } CALL_CATCH_EXCEPTION(0);
8543   }
8544
8545   jresult = (void *)result;
8546   return jresult;
8547 }
8548
8549
8550 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
8551   bool jresult ;
8552   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8553   bool result;
8554
8555   arg1 = (Dali::BaseHandle *)jarg1;
8556   {
8557     try {
8558       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
8559     } CALL_CATCH_EXCEPTION(0);
8560   }
8561
8562   jresult = result;
8563   return jresult;
8564 }
8565
8566
8567 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
8568   bool jresult ;
8569   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8570   Dali::BaseHandle *arg2 = 0 ;
8571   bool result;
8572
8573   arg1 = (Dali::BaseHandle *)jarg1;
8574   arg2 = (Dali::BaseHandle *)jarg2;
8575   if (!arg2) {
8576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
8577     return 0;
8578   }
8579   {
8580     try {
8581       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
8582     } CALL_CATCH_EXCEPTION(0);
8583   }
8584
8585   jresult = result;
8586   return jresult;
8587 }
8588
8589
8590 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
8591   bool jresult ;
8592   Dali::BaseHandle *arg1 = 0 ;
8593   Dali::BaseHandle *arg2 = 0 ;
8594   bool result;
8595
8596   arg1 = (Dali::BaseHandle *)jarg1;
8597   if (!arg1) {
8598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
8599     return 0;
8600   }
8601   arg2 = (Dali::BaseHandle *)jarg2;
8602   if (!arg2) {
8603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
8604     return 0;
8605   }
8606   {
8607     try {
8608       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
8609     } CALL_CATCH_EXCEPTION(0);
8610   }
8611
8612   jresult = result;
8613   return jresult;
8614 }
8615
8616
8617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
8618   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
8619
8620   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
8621   {
8622     try {
8623       delete arg1;
8624     } CALL_CATCH_EXCEPTION();
8625   }
8626
8627 }
8628
8629
8630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
8631   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
8632   SlotObserver *arg2 = (SlotObserver *) 0 ;
8633   CallbackBase *arg3 = (CallbackBase *) 0 ;
8634
8635   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
8636   arg2 = (SlotObserver *)jarg2;
8637   arg3 = (CallbackBase *)jarg3;
8638   {
8639     try {
8640       (arg1)->SignalConnected(arg2,arg3);
8641     } CALL_CATCH_EXCEPTION();
8642   }
8643
8644 }
8645
8646
8647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
8648   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
8649
8650   arg1 = (Dali::SignalObserver *)jarg1;
8651   {
8652     try {
8653       delete arg1;
8654     } CALL_CATCH_EXCEPTION();
8655   }
8656
8657 }
8658
8659
8660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
8661   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
8662   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
8663   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
8664
8665   arg1 = (Dali::SignalObserver *)jarg1;
8666   arg2 = (Dali::SlotObserver *)jarg2;
8667   arg3 = (Dali::CallbackBase *)jarg3;
8668   {
8669     try {
8670       (arg1)->SignalDisconnected(arg2,arg3);
8671     } CALL_CATCH_EXCEPTION();
8672   }
8673
8674 }
8675
8676
8677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
8678   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
8679
8680   arg1 = (Dali::SlotObserver *)jarg1;
8681   {
8682     try {
8683       delete arg1;
8684     } CALL_CATCH_EXCEPTION();
8685   }
8686
8687 }
8688
8689
8690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
8691   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
8692   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
8693
8694   arg1 = (Dali::SlotObserver *)jarg1;
8695   arg2 = (Dali::CallbackBase *)jarg2;
8696   {
8697     try {
8698       (arg1)->SlotDisconnected(arg2);
8699     } CALL_CATCH_EXCEPTION();
8700   }
8701
8702 }
8703
8704
8705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
8706   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
8707
8708   arg1 = (Dali::ConnectionTracker *)jarg1;
8709   {
8710     try {
8711       delete arg1;
8712     } CALL_CATCH_EXCEPTION();
8713   }
8714
8715 }
8716
8717
8718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
8719   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
8720
8721   arg1 = (Dali::ConnectionTracker *)jarg1;
8722   {
8723     try {
8724       (arg1)->DisconnectAll();
8725     } CALL_CATCH_EXCEPTION();
8726   }
8727
8728 }
8729
8730
8731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
8732   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
8733   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
8734   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
8735
8736   arg1 = (Dali::ConnectionTracker *)jarg1;
8737   arg2 = (Dali::SlotObserver *)jarg2;
8738   arg3 = (Dali::CallbackBase *)jarg3;
8739   {
8740     try {
8741       (arg1)->SignalConnected(arg2,arg3);
8742     } CALL_CATCH_EXCEPTION();
8743   }
8744
8745 }
8746
8747
8748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
8749   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
8750   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
8751   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
8752
8753   arg1 = (Dali::ConnectionTracker *)jarg1;
8754   arg2 = (Dali::SlotObserver *)jarg2;
8755   arg3 = (Dali::CallbackBase *)jarg3;
8756   {
8757     try {
8758       (arg1)->SignalDisconnected(arg2,arg3);
8759     } CALL_CATCH_EXCEPTION();
8760   }
8761
8762 }
8763
8764
8765 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
8766   unsigned long jresult ;
8767   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
8768   std::size_t result;
8769
8770   arg1 = (Dali::ConnectionTracker *)jarg1;
8771   {
8772     try {
8773       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
8774     } CALL_CATCH_EXCEPTION(0);
8775   }
8776
8777   jresult = (unsigned long)result;
8778   return jresult;
8779 }
8780
8781
8782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
8783   void * jresult ;
8784   Dali::ObjectRegistry *result = 0 ;
8785
8786   {
8787     try {
8788       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
8789     } CALL_CATCH_EXCEPTION(0);
8790   }
8791
8792   jresult = (void *)result;
8793   return jresult;
8794 }
8795
8796
8797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
8798   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
8799
8800   arg1 = (Dali::ObjectRegistry *)jarg1;
8801   {
8802     try {
8803       delete arg1;
8804     } CALL_CATCH_EXCEPTION();
8805   }
8806
8807 }
8808
8809
8810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
8811   void * jresult ;
8812   Dali::ObjectRegistry *arg1 = 0 ;
8813   Dali::ObjectRegistry *result = 0 ;
8814
8815   arg1 = (Dali::ObjectRegistry *)jarg1;
8816   if (!arg1) {
8817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
8818     return 0;
8819   }
8820   {
8821     try {
8822       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
8823     } CALL_CATCH_EXCEPTION(0);
8824   }
8825
8826   jresult = (void *)result;
8827   return jresult;
8828 }
8829
8830
8831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
8832   void * jresult ;
8833   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
8834   Dali::ObjectRegistry *arg2 = 0 ;
8835   Dali::ObjectRegistry *result = 0 ;
8836
8837   arg1 = (Dali::ObjectRegistry *)jarg1;
8838   arg2 = (Dali::ObjectRegistry *)jarg2;
8839   if (!arg2) {
8840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
8841     return 0;
8842   }
8843   {
8844     try {
8845       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
8846     } CALL_CATCH_EXCEPTION(0);
8847   }
8848
8849   jresult = (void *)result;
8850   return jresult;
8851 }
8852
8853
8854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
8855   void * jresult ;
8856   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
8857   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
8858
8859   arg1 = (Dali::ObjectRegistry *)jarg1;
8860   {
8861     try {
8862       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
8863     } CALL_CATCH_EXCEPTION(0);
8864   }
8865
8866   jresult = (void *)result;
8867   return jresult;
8868 }
8869
8870
8871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
8872   void * jresult ;
8873   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
8874   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
8875
8876   arg1 = (Dali::ObjectRegistry *)jarg1;
8877   {
8878     try {
8879       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
8880     } CALL_CATCH_EXCEPTION(0);
8881   }
8882
8883   jresult = (void *)result;
8884   return jresult;
8885 }
8886
8887
8888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
8889   void * jresult ;
8890   Dali::PropertyCondition *result = 0 ;
8891
8892   {
8893     try {
8894       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
8895     } CALL_CATCH_EXCEPTION(0);
8896   }
8897
8898   jresult = (void *)result;
8899   return jresult;
8900 }
8901
8902
8903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
8904   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
8905
8906   arg1 = (Dali::PropertyCondition *)jarg1;
8907   {
8908     try {
8909       delete arg1;
8910     } CALL_CATCH_EXCEPTION();
8911   }
8912
8913 }
8914
8915
8916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
8917   void * jresult ;
8918   Dali::PropertyCondition *arg1 = 0 ;
8919   Dali::PropertyCondition *result = 0 ;
8920
8921   arg1 = (Dali::PropertyCondition *)jarg1;
8922   if (!arg1) {
8923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
8924     return 0;
8925   }
8926   {
8927     try {
8928       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
8929     } CALL_CATCH_EXCEPTION(0);
8930   }
8931
8932   jresult = (void *)result;
8933   return jresult;
8934 }
8935
8936
8937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
8938   void * jresult ;
8939   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
8940   Dali::PropertyCondition *arg2 = 0 ;
8941   Dali::PropertyCondition *result = 0 ;
8942
8943   arg1 = (Dali::PropertyCondition *)jarg1;
8944   arg2 = (Dali::PropertyCondition *)jarg2;
8945   if (!arg2) {
8946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
8947     return 0;
8948   }
8949   {
8950     try {
8951       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
8952     } CALL_CATCH_EXCEPTION(0);
8953   }
8954
8955   jresult = (void *)result;
8956   return jresult;
8957 }
8958
8959
8960 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
8961   unsigned long jresult ;
8962   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
8963   std::size_t result;
8964
8965   arg1 = (Dali::PropertyCondition *)jarg1;
8966   {
8967     try {
8968       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
8969     } CALL_CATCH_EXCEPTION(0);
8970   }
8971   jresult = (unsigned long)result;
8972   return jresult;
8973 }
8974
8975
8976 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
8977   float jresult ;
8978   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
8979   std::size_t arg2 ;
8980   float result;
8981
8982   arg1 = (Dali::PropertyCondition *)jarg1;
8983   arg2 = (std::size_t)jarg2;
8984   {
8985     try {
8986       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
8987     } CALL_CATCH_EXCEPTION(0);
8988   }
8989   jresult = result;
8990   return jresult;
8991 }
8992
8993
8994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
8995   void * jresult ;
8996   float arg1 ;
8997   Dali::PropertyCondition result;
8998
8999   arg1 = (float)jarg1;
9000   {
9001     try {
9002       result = Dali::LessThanCondition(arg1);
9003     } CALL_CATCH_EXCEPTION(0);
9004   }
9005
9006   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
9007   return jresult;
9008 }
9009
9010
9011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
9012   void * jresult ;
9013   float arg1 ;
9014   Dali::PropertyCondition result;
9015
9016   arg1 = (float)jarg1;
9017   {
9018     try {
9019       result = Dali::GreaterThanCondition(arg1);
9020     } CALL_CATCH_EXCEPTION(0);
9021   }
9022
9023   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
9024   return jresult;
9025 }
9026
9027
9028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
9029   void * jresult ;
9030   float arg1 ;
9031   float arg2 ;
9032   Dali::PropertyCondition result;
9033
9034   arg1 = (float)jarg1;
9035   arg2 = (float)jarg2;
9036   {
9037     try {
9038       result = Dali::InsideCondition(arg1,arg2);
9039     } CALL_CATCH_EXCEPTION(0);
9040   }
9041
9042   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
9043   return jresult;
9044 }
9045
9046
9047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
9048   void * jresult ;
9049   float arg1 ;
9050   float arg2 ;
9051   Dali::PropertyCondition result;
9052
9053   arg1 = (float)jarg1;
9054   arg2 = (float)jarg2;
9055   {
9056     try {
9057       result = Dali::OutsideCondition(arg1,arg2);
9058     } CALL_CATCH_EXCEPTION(0);
9059   }
9060
9061   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
9062   return jresult;
9063 }
9064
9065
9066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
9067   void * jresult ;
9068   float arg1 ;
9069   float arg2 ;
9070   Dali::PropertyCondition result;
9071
9072   arg1 = (float)jarg1;
9073   arg2 = (float)jarg2;
9074   {
9075     try {
9076       result = Dali::StepCondition(arg1,arg2);
9077     } CALL_CATCH_EXCEPTION(0);
9078   }
9079
9080   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
9081   return jresult;
9082 }
9083
9084
9085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
9086   void * jresult ;
9087   float arg1 ;
9088   Dali::PropertyCondition result;
9089
9090   arg1 = (float)jarg1;
9091   {
9092     try {
9093       result = Dali::StepCondition(arg1);
9094     } CALL_CATCH_EXCEPTION(0);
9095   }
9096
9097   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
9098   return jresult;
9099 }
9100
9101
9102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
9103   void * jresult ;
9104   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
9105   Dali::PropertyCondition result;
9106
9107   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
9108   if (!arg1) {
9109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
9110     return 0;
9111   }
9112   {
9113     try {
9114       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
9115     } CALL_CATCH_EXCEPTION(0);
9116   }
9117
9118   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
9119   return jresult;
9120 }
9121
9122
9123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
9124   void * jresult ;
9125   Dali::PropertyNotification *result = 0 ;
9126
9127   {
9128     try {
9129       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
9130     } CALL_CATCH_EXCEPTION(0);
9131   }
9132
9133   jresult = (void *)result;
9134   return jresult;
9135 }
9136
9137
9138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
9139   void * jresult ;
9140   Dali::BaseHandle arg1 ;
9141   Dali::BaseHandle *argp1 ;
9142   Dali::PropertyNotification result;
9143
9144   argp1 = (Dali::BaseHandle *)jarg1;
9145   if (!argp1) {
9146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
9147     return 0;
9148   }
9149   arg1 = *argp1;
9150   {
9151     try {
9152       result = Dali::PropertyNotification::DownCast(arg1);
9153     } CALL_CATCH_EXCEPTION(0);
9154   }
9155
9156   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
9157   return jresult;
9158 }
9159
9160
9161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
9162   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
9163
9164   arg1 = (Dali::PropertyNotification *)jarg1;
9165   {
9166     try {
9167       delete arg1;
9168     } CALL_CATCH_EXCEPTION();
9169   }
9170
9171 }
9172
9173
9174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
9175   void * jresult ;
9176   Dali::PropertyNotification *arg1 = 0 ;
9177   Dali::PropertyNotification *result = 0 ;
9178
9179   arg1 = (Dali::PropertyNotification *)jarg1;
9180   if (!arg1) {
9181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
9182     return 0;
9183   }
9184   {
9185     try {
9186       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
9187     } CALL_CATCH_EXCEPTION(0);
9188   }
9189
9190   jresult = (void *)result;
9191   return jresult;
9192 }
9193
9194
9195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
9196   void * jresult ;
9197   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
9198   Dali::PropertyNotification *arg2 = 0 ;
9199   Dali::PropertyNotification *result = 0 ;
9200
9201   arg1 = (Dali::PropertyNotification *)jarg1;
9202   arg2 = (Dali::PropertyNotification *)jarg2;
9203   if (!arg2) {
9204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
9205     return 0;
9206   }
9207   {
9208     try {
9209       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
9210     } CALL_CATCH_EXCEPTION(0);
9211   }
9212
9213   jresult = (void *)result;
9214   return jresult;
9215 }
9216
9217
9218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
9219   void * jresult ;
9220   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
9221   Dali::PropertyCondition result;
9222
9223   arg1 = (Dali::PropertyNotification *)jarg1;
9224   {
9225     try {
9226       result = (arg1)->GetCondition();
9227     } CALL_CATCH_EXCEPTION(0);
9228   }
9229
9230   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
9231   return jresult;
9232 }
9233
9234
9235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
9236   void * jresult ;
9237   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
9238   Dali::Handle result;
9239
9240   arg1 = (Dali::PropertyNotification *)jarg1;
9241   {
9242     try {
9243       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
9244     } CALL_CATCH_EXCEPTION(0);
9245   }
9246
9247   jresult = new Dali::Handle((const Dali::Handle &)result);
9248   return jresult;
9249 }
9250
9251
9252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
9253   int jresult ;
9254   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
9255   Dali::Property::Index result;
9256
9257   arg1 = (Dali::PropertyNotification *)jarg1;
9258   {
9259     try {
9260       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
9261     } CALL_CATCH_EXCEPTION(0);
9262   }
9263
9264   jresult = result;
9265   return jresult;
9266 }
9267
9268
9269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
9270   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
9271   Dali::PropertyNotification::NotifyMode arg2 ;
9272
9273   arg1 = (Dali::PropertyNotification *)jarg1;
9274   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
9275   {
9276     try {
9277       (arg1)->SetNotifyMode(arg2);
9278     } CALL_CATCH_EXCEPTION();
9279   }
9280
9281 }
9282
9283
9284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
9285   int jresult ;
9286   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
9287   Dali::PropertyNotification::NotifyMode result;
9288
9289   arg1 = (Dali::PropertyNotification *)jarg1;
9290   {
9291     try {
9292       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
9293     } CALL_CATCH_EXCEPTION(0);
9294   }
9295
9296   jresult = (int)result;
9297   return jresult;
9298 }
9299
9300
9301 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
9302   bool jresult ;
9303   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
9304   bool result;
9305
9306   arg1 = (Dali::PropertyNotification *)jarg1;
9307   {
9308     try {
9309       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
9310     } CALL_CATCH_EXCEPTION(0);
9311   }
9312
9313   jresult = result;
9314   return jresult;
9315 }
9316
9317
9318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
9319   void * jresult ;
9320   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
9321   Dali::PropertyNotifySignalType *result = 0 ;
9322
9323   arg1 = (Dali::PropertyNotification *)jarg1;
9324   {
9325     try {
9326       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
9327     } CALL_CATCH_EXCEPTION(0);
9328   }
9329
9330   jresult = (void *)result;
9331   return jresult;
9332 }
9333
9334
9335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
9336   void * jresult ;
9337   Dali::Handle *result = 0 ;
9338
9339   {
9340     try {
9341       result = (Dali::Handle *)new Dali::Handle();
9342     } CALL_CATCH_EXCEPTION(0);
9343   }
9344
9345   jresult = (void *)result;
9346   return jresult;
9347 }
9348
9349
9350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
9351   void * jresult ;
9352   Dali::Handle result;
9353
9354   {
9355     try {
9356       result = Dali::Handle::New();
9357     } CALL_CATCH_EXCEPTION(0);
9358   }
9359
9360   jresult = new Dali::Handle((const Dali::Handle &)result);
9361   return jresult;
9362 }
9363
9364
9365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
9366   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9367
9368   arg1 = (Dali::Handle *)jarg1;
9369   {
9370     try {
9371       delete arg1;
9372     } CALL_CATCH_EXCEPTION();
9373   }
9374
9375 }
9376
9377
9378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
9379   void * jresult ;
9380   Dali::Handle *arg1 = 0 ;
9381   Dali::Handle *result = 0 ;
9382
9383   arg1 = (Dali::Handle *)jarg1;
9384   if (!arg1) {
9385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
9386     return 0;
9387   }
9388   {
9389     try {
9390       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
9391     } CALL_CATCH_EXCEPTION(0);
9392   }
9393
9394   jresult = (void *)result;
9395   return jresult;
9396 }
9397
9398
9399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
9400   void * jresult ;
9401   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9402   Dali::Handle *arg2 = 0 ;
9403   Dali::Handle *result = 0 ;
9404
9405   arg1 = (Dali::Handle *)jarg1;
9406   arg2 = (Dali::Handle *)jarg2;
9407   if (!arg2) {
9408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
9409     return 0;
9410   }
9411   {
9412     try {
9413       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
9414     } CALL_CATCH_EXCEPTION(0);
9415   }
9416
9417   jresult = (void *)result;
9418   return jresult;
9419 }
9420
9421
9422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
9423   void * jresult ;
9424   Dali::BaseHandle arg1 ;
9425   Dali::BaseHandle *argp1 ;
9426   Dali::Handle result;
9427
9428   argp1 = (Dali::BaseHandle *)jarg1;
9429   if (!argp1) {
9430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
9431     return 0;
9432   }
9433   arg1 = *argp1;
9434   {
9435     try {
9436       result = Dali::Handle::DownCast(arg1);
9437     } CALL_CATCH_EXCEPTION(0);
9438   }
9439
9440   jresult = new Dali::Handle((const Dali::Handle &)result);
9441   return jresult;
9442 }
9443
9444
9445 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
9446   bool jresult ;
9447   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9448   Dali::Handle::Capability arg2 ;
9449   bool result;
9450
9451   arg1 = (Dali::Handle *)jarg1;
9452   arg2 = (Dali::Handle::Capability)jarg2;
9453   {
9454     try {
9455       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
9456     } CALL_CATCH_EXCEPTION(0);
9457   }
9458
9459   jresult = result;
9460   return jresult;
9461 }
9462
9463
9464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
9465   unsigned int jresult ;
9466   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9467   unsigned int result;
9468
9469   arg1 = (Dali::Handle *)jarg1;
9470   {
9471     try {
9472       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
9473     } CALL_CATCH_EXCEPTION(0);
9474   }
9475
9476   jresult = result;
9477   return jresult;
9478 }
9479
9480
9481 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
9482   char * jresult ;
9483   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9484   Dali::Property::Index arg2 ;
9485   std::string result;
9486
9487   arg1 = (Dali::Handle *)jarg1;
9488   arg2 = (Dali::Property::Index)jarg2;
9489   {
9490     try {
9491       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
9492     } CALL_CATCH_EXCEPTION(0);
9493   }
9494
9495   jresult = SWIG_csharp_string_callback((&result)->c_str());
9496   return jresult;
9497 }
9498
9499
9500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
9501   int jresult ;
9502   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9503   std::string *arg2 = 0 ;
9504   Dali::Property::Index result;
9505
9506   arg1 = (Dali::Handle *)jarg1;
9507   if (!jarg2) {
9508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9509     return 0;
9510   }
9511   std::string arg2_str(jarg2);
9512   arg2 = &arg2_str;
9513   {
9514     try {
9515       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
9516     } CALL_CATCH_EXCEPTION(0);
9517   }
9518
9519   jresult = result;
9520
9521   //argout typemap for const std::string&
9522
9523   return jresult;
9524 }
9525
9526
9527 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
9528   bool jresult ;
9529   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9530   Dali::Property::Index arg2 ;
9531   bool result;
9532
9533   arg1 = (Dali::Handle *)jarg1;
9534   arg2 = (Dali::Property::Index)jarg2;
9535   {
9536     try {
9537       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
9538     } CALL_CATCH_EXCEPTION(0);
9539   }
9540
9541   jresult = result;
9542   return jresult;
9543 }
9544
9545
9546 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
9547   bool jresult ;
9548   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9549   Dali::Property::Index arg2 ;
9550   bool result;
9551
9552   arg1 = (Dali::Handle *)jarg1;
9553   arg2 = (Dali::Property::Index)jarg2;
9554   {
9555     try {
9556       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
9557     } CALL_CATCH_EXCEPTION(0);
9558   }
9559
9560   jresult = result;
9561   return jresult;
9562 }
9563
9564
9565 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
9566   bool jresult ;
9567   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9568   Dali::Property::Index arg2 ;
9569   bool result;
9570
9571   arg1 = (Dali::Handle *)jarg1;
9572   arg2 = (Dali::Property::Index)jarg2;
9573   {
9574     try {
9575       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
9576     } CALL_CATCH_EXCEPTION(0);
9577   }
9578
9579   jresult = result;
9580   return jresult;
9581 }
9582
9583
9584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
9585   int jresult ;
9586   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9587   Dali::Property::Index arg2 ;
9588   Dali::Property::Type result;
9589
9590   arg1 = (Dali::Handle *)jarg1;
9591   arg2 = (Dali::Property::Index)jarg2;
9592   {
9593     try {
9594       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
9595     } CALL_CATCH_EXCEPTION(0);
9596   }
9597
9598   jresult = (int)result;
9599   return jresult;
9600 }
9601
9602
9603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
9604   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9605   Dali::Property::Index arg2 ;
9606   Dali::Property::Value *arg3 = 0 ;
9607
9608   arg1 = (Dali::Handle *)jarg1;
9609   arg2 = (Dali::Property::Index)jarg2;
9610   arg3 = (Dali::Property::Value *)jarg3;
9611   if (!arg3) {
9612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
9613     return ;
9614   }
9615   {
9616     try {
9617       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
9618     } CALL_CATCH_EXCEPTION();
9619   }
9620
9621 }
9622
9623
9624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
9625   int jresult ;
9626   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9627   std::string *arg2 = 0 ;
9628   Dali::Property::Value *arg3 = 0 ;
9629   Dali::Property::Index result;
9630
9631   arg1 = (Dali::Handle *)jarg1;
9632   if (!jarg2) {
9633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9634     return 0;
9635   }
9636   std::string arg2_str(jarg2);
9637   arg2 = &arg2_str;
9638   arg3 = (Dali::Property::Value *)jarg3;
9639   if (!arg3) {
9640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
9641     return 0;
9642   }
9643   {
9644     try {
9645       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
9646     } CALL_CATCH_EXCEPTION(0);
9647   }
9648
9649   jresult = result;
9650
9651   //argout typemap for const std::string&
9652
9653   return jresult;
9654 }
9655
9656
9657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
9658   int jresult ;
9659   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9660   std::string *arg2 = 0 ;
9661   Dali::Property::Value *arg3 = 0 ;
9662   Dali::Property::AccessMode arg4 ;
9663   Dali::Property::Index result;
9664
9665   arg1 = (Dali::Handle *)jarg1;
9666   if (!jarg2) {
9667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9668     return 0;
9669   }
9670   std::string arg2_str(jarg2);
9671   arg2 = &arg2_str;
9672   arg3 = (Dali::Property::Value *)jarg3;
9673   if (!arg3) {
9674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
9675     return 0;
9676   }
9677   arg4 = (Dali::Property::AccessMode)jarg4;
9678   {
9679     try {
9680       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
9681     } CALL_CATCH_EXCEPTION(0);
9682   }
9683
9684   jresult = result;
9685
9686   //argout typemap for const std::string&
9687
9688   return jresult;
9689 }
9690
9691
9692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
9693   void * jresult ;
9694   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9695   Dali::Property::Index arg2 ;
9696   Dali::Property::Value result;
9697
9698   arg1 = (Dali::Handle *)jarg1;
9699   arg2 = (Dali::Property::Index)jarg2;
9700   {
9701     try {
9702       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
9703     } CALL_CATCH_EXCEPTION(0);
9704   }
9705
9706   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
9707   return jresult;
9708 }
9709
9710
9711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetCurrentProperty(void * jarg1, int jarg2) {
9712   void * jresult ;
9713   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9714   Dali::Property::Index arg2 ;
9715   Dali::Property::Value result;
9716
9717   arg1 = (Dali::Handle *)jarg1;
9718   arg2 = (Dali::Property::Index)jarg2;
9719   {
9720     try {
9721       result = ((Dali::Handle const *)arg1)->GetCurrentProperty(arg2);
9722     } CALL_CATCH_EXCEPTION(0);
9723   }
9724
9725   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
9726   return jresult;
9727 }
9728
9729
9730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
9731   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9732   Dali::Property::IndexContainer *arg2 = 0 ;
9733
9734   arg1 = (Dali::Handle *)jarg1;
9735   arg2 = (Dali::Property::IndexContainer *)jarg2;
9736   if (!arg2) {
9737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
9738     return ;
9739   }
9740   {
9741     try {
9742       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
9743     } CALL_CATCH_EXCEPTION();
9744   }
9745
9746 }
9747
9748
9749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
9750   void * jresult ;
9751   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9752   Dali::Property::Index arg2 ;
9753   Dali::PropertyCondition *arg3 = 0 ;
9754   Dali::PropertyNotification result;
9755
9756   arg1 = (Dali::Handle *)jarg1;
9757   arg2 = (Dali::Property::Index)jarg2;
9758   arg3 = (Dali::PropertyCondition *)jarg3;
9759   if (!arg3) {
9760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
9761     return 0;
9762   }
9763   {
9764     try {
9765       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
9766     } CALL_CATCH_EXCEPTION(0);
9767   }
9768
9769   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
9770   return jresult;
9771 }
9772
9773
9774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
9775   void * jresult ;
9776   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9777   Dali::Property::Index arg2 ;
9778   int arg3 ;
9779   Dali::PropertyCondition *arg4 = 0 ;
9780   Dali::PropertyNotification result;
9781
9782   arg1 = (Dali::Handle *)jarg1;
9783   arg2 = (Dali::Property::Index)jarg2;
9784   arg3 = (int)jarg3;
9785   arg4 = (Dali::PropertyCondition *)jarg4;
9786   if (!arg4) {
9787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
9788     return 0;
9789   }
9790   {
9791     try {
9792       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
9793     } CALL_CATCH_EXCEPTION(0);
9794   }
9795
9796   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
9797   return jresult;
9798 }
9799
9800
9801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
9802   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9803   Dali::PropertyNotification arg2 ;
9804   Dali::PropertyNotification *argp2 ;
9805
9806   arg1 = (Dali::Handle *)jarg1;
9807   argp2 = (Dali::PropertyNotification *)jarg2;
9808   if (!argp2) {
9809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
9810     return ;
9811   }
9812   arg2 = *argp2;
9813   {
9814     try {
9815       (arg1)->RemovePropertyNotification(arg2);
9816     } CALL_CATCH_EXCEPTION();
9817   }
9818
9819 }
9820
9821
9822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
9823   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9824
9825   arg1 = (Dali::Handle *)jarg1;
9826   {
9827     try {
9828       (arg1)->RemovePropertyNotifications();
9829     } CALL_CATCH_EXCEPTION();
9830   }
9831
9832 }
9833
9834
9835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
9836   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9837
9838   arg1 = (Dali::Handle *)jarg1;
9839   {
9840     try {
9841       (arg1)->RemoveConstraints();
9842     } CALL_CATCH_EXCEPTION();
9843   }
9844
9845 }
9846
9847
9848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
9849   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9850   unsigned int arg2 ;
9851
9852   arg1 = (Dali::Handle *)jarg1;
9853   arg2 = (unsigned int)jarg2;
9854   {
9855     try {
9856       (arg1)->RemoveConstraints(arg2);
9857     } CALL_CATCH_EXCEPTION();
9858   }
9859
9860 }
9861
9862
9863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
9864   void * jresult ;
9865   Dali::Handle result;
9866
9867   {
9868     try {
9869       result = Dali::WeightObject::New();
9870     } CALL_CATCH_EXCEPTION(0);
9871   }
9872
9873   jresult = new Dali::Handle((const Dali::Handle &)result);
9874   return jresult;
9875 }
9876
9877
9878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
9879   void * jresult ;
9880   Dali::TypeInfo *result = 0 ;
9881
9882   {
9883     try {
9884       result = (Dali::TypeInfo *)new Dali::TypeInfo();
9885     } CALL_CATCH_EXCEPTION(0);
9886   }
9887
9888   jresult = (void *)result;
9889   return jresult;
9890 }
9891
9892
9893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
9894   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
9895
9896   arg1 = (Dali::TypeInfo *)jarg1;
9897   {
9898     try {
9899       delete arg1;
9900     } CALL_CATCH_EXCEPTION();
9901   }
9902
9903 }
9904
9905
9906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
9907   void * jresult ;
9908   Dali::TypeInfo *arg1 = 0 ;
9909   Dali::TypeInfo *result = 0 ;
9910
9911   arg1 = (Dali::TypeInfo *)jarg1;
9912   if (!arg1) {
9913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
9914     return 0;
9915   }
9916   {
9917     try {
9918       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
9919     } CALL_CATCH_EXCEPTION(0);
9920   }
9921
9922   jresult = (void *)result;
9923   return jresult;
9924 }
9925
9926
9927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
9928   void * jresult ;
9929   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
9930   Dali::TypeInfo *arg2 = 0 ;
9931   Dali::TypeInfo *result = 0 ;
9932
9933   arg1 = (Dali::TypeInfo *)jarg1;
9934   arg2 = (Dali::TypeInfo *)jarg2;
9935   if (!arg2) {
9936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
9937     return 0;
9938   }
9939   {
9940     try {
9941       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
9942     } CALL_CATCH_EXCEPTION(0);
9943   }
9944
9945   jresult = (void *)result;
9946   return jresult;
9947 }
9948
9949
9950 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
9951   char * jresult ;
9952   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
9953   std::string *result = 0 ;
9954
9955   arg1 = (Dali::TypeInfo *)jarg1;
9956   {
9957     try {
9958       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
9959     } CALL_CATCH_EXCEPTION(0);
9960   }
9961
9962   jresult = SWIG_csharp_string_callback(result->c_str());
9963   return jresult;
9964 }
9965
9966
9967 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
9968   char * jresult ;
9969   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
9970   std::string *result = 0 ;
9971
9972   arg1 = (Dali::TypeInfo *)jarg1;
9973   {
9974     try {
9975       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
9976     } CALL_CATCH_EXCEPTION(0);
9977   }
9978
9979   jresult = SWIG_csharp_string_callback(result->c_str());
9980   return jresult;
9981 }
9982
9983
9984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
9985   void * jresult ;
9986   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
9987   Dali::BaseHandle result;
9988
9989   arg1 = (Dali::TypeInfo *)jarg1;
9990   {
9991     try {
9992       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
9993     } CALL_CATCH_EXCEPTION(0);
9994   }
9995
9996   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
9997   return jresult;
9998 }
9999
10000
10001 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
10002   unsigned long jresult ;
10003   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
10004   size_t result;
10005
10006   arg1 = (Dali::TypeInfo *)jarg1;
10007   {
10008     try {
10009       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
10010     } CALL_CATCH_EXCEPTION(0);
10011   }
10012
10013   jresult = (unsigned long)result;
10014   return jresult;
10015 }
10016
10017
10018 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
10019   char * jresult ;
10020   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
10021   size_t arg2 ;
10022   std::string result;
10023
10024   arg1 = (Dali::TypeInfo *)jarg1;
10025   arg2 = (size_t)jarg2;
10026   {
10027     try {
10028       result = (arg1)->GetActionName(arg2);
10029     } CALL_CATCH_EXCEPTION(0);
10030   }
10031
10032   jresult = SWIG_csharp_string_callback((&result)->c_str());
10033   return jresult;
10034 }
10035
10036
10037 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
10038   unsigned long jresult ;
10039   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
10040   size_t result;
10041
10042   arg1 = (Dali::TypeInfo *)jarg1;
10043   {
10044     try {
10045       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
10046     } CALL_CATCH_EXCEPTION(0);
10047   }
10048
10049   jresult = (unsigned long)result;
10050   return jresult;
10051 }
10052
10053
10054 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
10055   char * jresult ;
10056   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
10057   size_t arg2 ;
10058   std::string result;
10059
10060   arg1 = (Dali::TypeInfo *)jarg1;
10061   arg2 = (size_t)jarg2;
10062   {
10063     try {
10064       result = (arg1)->GetSignalName(arg2);
10065     } CALL_CATCH_EXCEPTION(0);
10066   }
10067
10068   jresult = SWIG_csharp_string_callback((&result)->c_str());
10069   return jresult;
10070 }
10071
10072
10073 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
10074   unsigned long jresult ;
10075   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
10076   size_t result;
10077
10078   arg1 = (Dali::TypeInfo *)jarg1;
10079   {
10080     try {
10081       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
10082     } CALL_CATCH_EXCEPTION(0);
10083   }
10084
10085   jresult = (unsigned long)result;
10086   return jresult;
10087 }
10088
10089
10090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
10091   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
10092   Dali::Property::IndexContainer *arg2 = 0 ;
10093
10094   arg1 = (Dali::TypeInfo *)jarg1;
10095   arg2 = (Dali::Property::IndexContainer *)jarg2;
10096   if (!arg2) {
10097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
10098     return ;
10099   }
10100   {
10101     try {
10102       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
10103     } CALL_CATCH_EXCEPTION();
10104   }
10105
10106 }
10107
10108
10109 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
10110   char * jresult ;
10111   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
10112   Dali::Property::Index arg2 ;
10113   std::string_view result;
10114
10115   arg1 = (Dali::TypeInfo *)jarg1;
10116   arg2 = (Dali::Property::Index)jarg2;
10117   {
10118     try {
10119       result = ((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
10120     } CALL_CATCH_EXCEPTION(0);
10121   }
10122
10123   jresult = SWIG_csharp_string_callback(result.data());
10124   return jresult;
10125 }
10126
10127
10128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
10129   void * jresult ;
10130   Dali::TypeRegistry result;
10131
10132   {
10133     try {
10134       result = Dali::TypeRegistry::Get();
10135     } CALL_CATCH_EXCEPTION(0);
10136   }
10137
10138   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
10139   return jresult;
10140 }
10141
10142
10143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
10144   void * jresult ;
10145   Dali::TypeRegistry *result = 0 ;
10146
10147   {
10148     try {
10149       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
10150     } CALL_CATCH_EXCEPTION(0);
10151   }
10152
10153   jresult = (void *)result;
10154   return jresult;
10155 }
10156
10157
10158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
10159   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
10160
10161   arg1 = (Dali::TypeRegistry *)jarg1;
10162   {
10163     try {
10164       delete arg1;
10165     } CALL_CATCH_EXCEPTION();
10166   }
10167
10168 }
10169
10170
10171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
10172   void * jresult ;
10173   Dali::TypeRegistry *arg1 = 0 ;
10174   Dali::TypeRegistry *result = 0 ;
10175
10176   arg1 = (Dali::TypeRegistry *)jarg1;
10177   if (!arg1) {
10178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
10179     return 0;
10180   }
10181   {
10182     try {
10183       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
10184     } CALL_CATCH_EXCEPTION(0);
10185   }
10186
10187   jresult = (void *)result;
10188   return jresult;
10189 }
10190
10191
10192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
10193   void * jresult ;
10194   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
10195   Dali::TypeRegistry *arg2 = 0 ;
10196   Dali::TypeRegistry *result = 0 ;
10197
10198   arg1 = (Dali::TypeRegistry *)jarg1;
10199   arg2 = (Dali::TypeRegistry *)jarg2;
10200   if (!arg2) {
10201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
10202     return 0;
10203   }
10204   {
10205     try {
10206       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
10207     } CALL_CATCH_EXCEPTION(0);
10208   }
10209
10210   jresult = (void *)result;
10211   return jresult;
10212 }
10213
10214
10215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
10216   void * jresult ;
10217   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
10218   std::string *arg2 = 0 ;
10219   Dali::TypeInfo result;
10220
10221   arg1 = (Dali::TypeRegistry *)jarg1;
10222   if (!jarg2) {
10223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10224     return 0;
10225   }
10226   std::string arg2_str(jarg2);
10227   arg2 = &arg2_str;
10228   {
10229     try {
10230       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
10231     } CALL_CATCH_EXCEPTION(0);
10232   }
10233
10234   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
10235
10236   //argout typemap for const std::string&
10237
10238   return jresult;
10239 }
10240
10241
10242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
10243   void * jresult ;
10244   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
10245   std::type_info *arg2 = 0 ;
10246   Dali::TypeInfo result;
10247
10248   arg1 = (Dali::TypeRegistry *)jarg1;
10249   arg2 = (std::type_info *)jarg2;
10250   if (!arg2) {
10251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
10252     return 0;
10253   }
10254   {
10255     try {
10256       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
10257     } CALL_CATCH_EXCEPTION(0);
10258   }
10259
10260   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
10261   return jresult;
10262 }
10263
10264
10265 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
10266   unsigned long jresult ;
10267   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
10268   size_t result;
10269
10270   arg1 = (Dali::TypeRegistry *)jarg1;
10271   {
10272     try {
10273       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
10274     } CALL_CATCH_EXCEPTION(0);
10275   }
10276
10277   jresult = (unsigned long)result;
10278   return jresult;
10279 }
10280
10281
10282 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
10283   char * jresult ;
10284   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
10285   size_t arg2 ;
10286   std::string result;
10287
10288   arg1 = (Dali::TypeRegistry *)jarg1;
10289   arg2 = (size_t)jarg2;
10290   {
10291     try {
10292       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
10293     } CALL_CATCH_EXCEPTION(0);
10294   }
10295
10296   jresult = SWIG_csharp_string_callback((&result)->c_str());
10297   return jresult;
10298 }
10299
10300
10301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
10302   void * jresult ;
10303   std::type_info *arg1 = 0 ;
10304   std::type_info *arg2 = 0 ;
10305   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
10306   Dali::TypeRegistration *result = 0 ;
10307
10308   arg1 = (std::type_info *)jarg1;
10309   if (!arg1) {
10310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
10311     return 0;
10312   }
10313   arg2 = (std::type_info *)jarg2;
10314   if (!arg2) {
10315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
10316     return 0;
10317   }
10318   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
10319   {
10320     try {
10321       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
10322     } CALL_CATCH_EXCEPTION(0);
10323   }
10324
10325   jresult = (void *)result;
10326   return jresult;
10327 }
10328
10329
10330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, bool jarg4) {
10331   void * jresult ;
10332   std::type_info *arg1 = 0 ;
10333   std::type_info *arg2 = 0 ;
10334   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
10335   bool arg4 ;
10336   Dali::TypeRegistration *result = 0 ;
10337
10338   arg1 = (std::type_info *)jarg1;
10339   if (!arg1) {
10340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
10341     return 0;
10342   }
10343   arg2 = (std::type_info *)jarg2;
10344   if (!arg2) {
10345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
10346     return 0;
10347   }
10348   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
10349   arg4 = jarg4 ? true : false;
10350   {
10351     try {
10352       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
10353     } CALL_CATCH_EXCEPTION(0);
10354   }
10355
10356   jresult = (void *)result;
10357   return jresult;
10358 }
10359
10360
10361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
10362   void * jresult ;
10363   std::string *arg1 = 0 ;
10364   std::type_info *arg2 = 0 ;
10365   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
10366   Dali::TypeRegistration *result = 0 ;
10367
10368   if (!jarg1) {
10369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10370     return 0;
10371   }
10372   std::string arg1_str(jarg1);
10373   arg1 = &arg1_str;
10374   arg2 = (std::type_info *)jarg2;
10375   if (!arg2) {
10376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
10377     return 0;
10378   }
10379   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
10380   {
10381     try {
10382       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
10383     } CALL_CATCH_EXCEPTION(0);
10384   }
10385
10386   jresult = (void *)result;
10387
10388   //argout typemap for const std::string&
10389
10390   return jresult;
10391 }
10392
10393
10394 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
10395   char * jresult ;
10396   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
10397   std::string result;
10398
10399   arg1 = (Dali::TypeRegistration *)jarg1;
10400   {
10401     try {
10402       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
10403     } CALL_CATCH_EXCEPTION(0);
10404   }
10405
10406   jresult = SWIG_csharp_string_callback((&result)->c_str());
10407   return jresult;
10408 }
10409
10410
10411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
10412   std::string *arg1 = 0 ;
10413   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
10414
10415   if (!jarg1) {
10416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10417     return ;
10418   }
10419   std::string arg1_str(jarg1);
10420   arg1 = &arg1_str;
10421   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
10422   {
10423     try {
10424       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
10425     } CALL_CATCH_EXCEPTION();
10426   }
10427
10428
10429   //argout typemap for const std::string&
10430
10431 }
10432
10433
10434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
10435   std::string *arg1 = 0 ;
10436   std::string *arg2 = 0 ;
10437   int arg3 ;
10438   Dali::Property::Type arg4 ;
10439   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
10440   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
10441
10442   if (!jarg1) {
10443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10444     return ;
10445   }
10446   std::string arg1_str(jarg1);
10447   arg1 = &arg1_str;
10448   if (!jarg2) {
10449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10450     return ;
10451   }
10452   std::string arg2_str(jarg2);
10453   arg2 = &arg2_str;
10454   arg3 = (int)jarg3;
10455   arg4 = (Dali::Property::Type)jarg4;
10456   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
10457   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
10458   {
10459     try {
10460       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
10461     } CALL_CATCH_EXCEPTION();
10462   }
10463
10464
10465   //argout typemap for const std::string&
10466
10467
10468   //argout typemap for const std::string&
10469
10470 }
10471
10472
10473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
10474   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
10475
10476   arg1 = (Dali::TypeRegistration *)jarg1;
10477   {
10478     try {
10479       delete arg1;
10480     } CALL_CATCH_EXCEPTION();
10481   }
10482
10483 }
10484
10485
10486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
10487   void * jresult ;
10488   Dali::TypeRegistration *arg1 = 0 ;
10489   std::string *arg2 = 0 ;
10490   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
10491   Dali::SignalConnectorType *result = 0 ;
10492
10493   arg1 = (Dali::TypeRegistration *)jarg1;
10494   if (!arg1) {
10495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
10496     return 0;
10497   }
10498   if (!jarg2) {
10499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10500     return 0;
10501   }
10502   std::string arg2_str(jarg2);
10503   arg2 = &arg2_str;
10504   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
10505   {
10506     try {
10507       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
10508     } CALL_CATCH_EXCEPTION(0);
10509   }
10510
10511   jresult = (void *)result;
10512
10513   //argout typemap for const std::string&
10514
10515   return jresult;
10516 }
10517
10518
10519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
10520   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
10521
10522   arg1 = (Dali::SignalConnectorType *)jarg1;
10523   {
10524     try {
10525       delete arg1;
10526     } CALL_CATCH_EXCEPTION();
10527   }
10528
10529 }
10530
10531
10532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
10533   void * jresult ;
10534   Dali::TypeRegistration *arg1 = 0 ;
10535   std::string *arg2 = 0 ;
10536   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
10537   Dali::TypeAction *result = 0 ;
10538
10539   arg1 = (Dali::TypeRegistration *)jarg1;
10540   if (!arg1) {
10541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
10542     return 0;
10543   }
10544   if (!jarg2) {
10545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10546     return 0;
10547   }
10548   std::string arg2_str(jarg2);
10549   arg2 = &arg2_str;
10550   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
10551   {
10552     try {
10553       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
10554     } CALL_CATCH_EXCEPTION(0);
10555   }
10556
10557   jresult = (void *)result;
10558
10559   //argout typemap for const std::string&
10560
10561   return jresult;
10562 }
10563
10564
10565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
10566   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
10567
10568   arg1 = (Dali::TypeAction *)jarg1;
10569   {
10570     try {
10571       delete arg1;
10572     } CALL_CATCH_EXCEPTION();
10573   }
10574
10575 }
10576
10577
10578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
10579   void * jresult ;
10580   Dali::TypeRegistration *arg1 = 0 ;
10581   std::string *arg2 = 0 ;
10582   Dali::Property::Index arg3 ;
10583   Dali::Property::Type arg4 ;
10584   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
10585   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
10586   Dali::PropertyRegistration *result = 0 ;
10587
10588   arg1 = (Dali::TypeRegistration *)jarg1;
10589   if (!arg1) {
10590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
10591     return 0;
10592   }
10593   if (!jarg2) {
10594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10595     return 0;
10596   }
10597   std::string arg2_str(jarg2);
10598   arg2 = &arg2_str;
10599   arg3 = (Dali::Property::Index)jarg3;
10600   arg4 = (Dali::Property::Type)jarg4;
10601   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
10602   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
10603   {
10604     try {
10605       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
10606     } CALL_CATCH_EXCEPTION(0);
10607   }
10608
10609   jresult = (void *)result;
10610
10611   //argout typemap for const std::string&
10612
10613   return jresult;
10614 }
10615
10616
10617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
10618   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
10619
10620   arg1 = (Dali::PropertyRegistration *)jarg1;
10621   {
10622     try {
10623       delete arg1;
10624     } CALL_CATCH_EXCEPTION();
10625   }
10626
10627 }
10628
10629
10630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
10631   void * jresult ;
10632   Dali::TypeRegistration *arg1 = 0 ;
10633   std::string *arg2 = 0 ;
10634   Dali::Property::Index arg3 ;
10635   Dali::Property::Type arg4 ;
10636   Dali::AnimatablePropertyRegistration *result = 0 ;
10637
10638   arg1 = (Dali::TypeRegistration *)jarg1;
10639   if (!arg1) {
10640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
10641     return 0;
10642   }
10643   if (!jarg2) {
10644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10645     return 0;
10646   }
10647   std::string arg2_str(jarg2);
10648   arg2 = &arg2_str;
10649   arg3 = (Dali::Property::Index)jarg3;
10650   arg4 = (Dali::Property::Type)jarg4;
10651   {
10652     try {
10653       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
10654     } CALL_CATCH_EXCEPTION(0);
10655   }
10656
10657   jresult = (void *)result;
10658
10659   //argout typemap for const std::string&
10660
10661   return jresult;
10662 }
10663
10664
10665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
10666   void * jresult ;
10667   Dali::TypeRegistration *arg1 = 0 ;
10668   std::string *arg2 = 0 ;
10669   Dali::Property::Index arg3 ;
10670   Dali::Property::Value *arg4 = 0 ;
10671   Dali::AnimatablePropertyRegistration *result = 0 ;
10672
10673   arg1 = (Dali::TypeRegistration *)jarg1;
10674   if (!arg1) {
10675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
10676     return 0;
10677   }
10678   if (!jarg2) {
10679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10680     return 0;
10681   }
10682   std::string arg2_str(jarg2);
10683   arg2 = &arg2_str;
10684   arg3 = (Dali::Property::Index)jarg3;
10685   arg4 = (Dali::Property::Value *)jarg4;
10686   if (!arg4) {
10687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10688     return 0;
10689   }
10690   {
10691     try {
10692       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
10693     } CALL_CATCH_EXCEPTION(0);
10694   }
10695
10696   jresult = (void *)result;
10697
10698   //argout typemap for const std::string&
10699
10700   return jresult;
10701 }
10702
10703
10704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
10705   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
10706
10707   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
10708   {
10709     try {
10710       delete arg1;
10711     } CALL_CATCH_EXCEPTION();
10712   }
10713
10714 }
10715
10716
10717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
10718   void * jresult ;
10719   Dali::TypeRegistration *arg1 = 0 ;
10720   std::string *arg2 = 0 ;
10721   Dali::Property::Index arg3 ;
10722   Dali::Property::Index arg4 ;
10723   unsigned int arg5 ;
10724   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
10725
10726   arg1 = (Dali::TypeRegistration *)jarg1;
10727   if (!arg1) {
10728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
10729     return 0;
10730   }
10731   if (!jarg2) {
10732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10733     return 0;
10734   }
10735   std::string arg2_str(jarg2);
10736   arg2 = &arg2_str;
10737   arg3 = (Dali::Property::Index)jarg3;
10738   arg4 = (Dali::Property::Index)jarg4;
10739   arg5 = (unsigned int)jarg5;
10740   {
10741     try {
10742       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
10743     } CALL_CATCH_EXCEPTION(0);
10744   }
10745
10746   jresult = (void *)result;
10747
10748   //argout typemap for const std::string&
10749
10750   return jresult;
10751 }
10752
10753
10754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
10755   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
10756
10757   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
10758   {
10759     try {
10760       delete arg1;
10761     } CALL_CATCH_EXCEPTION();
10762   }
10763
10764 }
10765
10766
10767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
10768   void * jresult ;
10769   Dali::TypeRegistration *arg1 = 0 ;
10770   std::string *arg2 = 0 ;
10771   Dali::Property::Index arg3 ;
10772   Dali::Property::Type arg4 ;
10773   Dali::ChildPropertyRegistration *result = 0 ;
10774
10775   arg1 = (Dali::TypeRegistration *)jarg1;
10776   if (!arg1) {
10777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
10778     return 0;
10779   }
10780   if (!jarg2) {
10781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10782     return 0;
10783   }
10784   std::string arg2_str(jarg2);
10785   arg2 = &arg2_str;
10786   arg3 = (Dali::Property::Index)jarg3;
10787   arg4 = (Dali::Property::Type)jarg4;
10788   {
10789     try {
10790       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
10791     } CALL_CATCH_EXCEPTION(0);
10792   }
10793
10794   jresult = (void *)result;
10795
10796   //argout typemap for const std::string&
10797
10798   return jresult;
10799 }
10800
10801
10802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
10803   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
10804
10805   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
10806   {
10807     try {
10808       delete arg1;
10809     } CALL_CATCH_EXCEPTION();
10810   }
10811
10812 }
10813
10814
10815 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
10816   bool jresult ;
10817   std::string *arg1 = 0 ;
10818   std::type_info *arg2 = 0 ;
10819   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
10820   bool result;
10821
10822   if (!jarg1) {
10823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10824     return 0;
10825   }
10826   std::string arg1_str(jarg1);
10827   arg1 = &arg1_str;
10828   arg2 = (std::type_info *)jarg2;
10829   if (!arg2) {
10830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
10831     return 0;
10832   }
10833   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
10834   {
10835     try {
10836       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
10837     } CALL_CATCH_EXCEPTION(0);
10838   }
10839
10840   jresult = result;
10841
10842   //argout typemap for const std::string&
10843
10844   return jresult;
10845 }
10846
10847
10848 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
10849   bool jresult ;
10850   std::string *arg1 = 0 ;
10851   std::string *arg2 = 0 ;
10852   Dali::Property::Index arg3 ;
10853   Dali::Property::Type arg4 ;
10854   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
10855   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
10856   bool result;
10857
10858   if (!jarg1) {
10859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10860     return 0;
10861   }
10862   std::string arg1_str(jarg1);
10863   arg1 = &arg1_str;
10864   if (!jarg2) {
10865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10866     return 0;
10867   }
10868   std::string arg2_str(jarg2);
10869   arg2 = &arg2_str;
10870   arg3 = (Dali::Property::Index)jarg3;
10871   arg4 = (Dali::Property::Type)jarg4;
10872   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
10873   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
10874   {
10875     try {
10876       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
10877     } CALL_CATCH_EXCEPTION(0);
10878   }
10879
10880   jresult = result;
10881
10882   //argout typemap for const std::string&
10883
10884
10885   //argout typemap for const std::string&
10886
10887   return jresult;
10888 }
10889
10890
10891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
10892   int jresult ;
10893   Dali::ResizePolicy::Type result;
10894
10895   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
10896   jresult = (int)result;
10897   return jresult;
10898 }
10899
10900
10901 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
10902   unsigned long jresult ;
10903   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
10904   Dali::VectorBase::SizeType result;
10905
10906   arg1 = (Dali::VectorBase *)jarg1;
10907   {
10908     try {
10909       result = ((Dali::VectorBase const *)arg1)->Count();
10910     } CALL_CATCH_EXCEPTION(0);
10911   }
10912
10913   jresult = (unsigned long)result;
10914   return jresult;
10915 }
10916
10917
10918 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
10919   unsigned long jresult ;
10920   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
10921   Dali::VectorBase::SizeType result;
10922
10923   arg1 = (Dali::VectorBase *)jarg1;
10924   {
10925     try {
10926       result = ((Dali::VectorBase const *)arg1)->Size();
10927     } CALL_CATCH_EXCEPTION(0);
10928   }
10929
10930   jresult = (unsigned long)result;
10931   return jresult;
10932 }
10933
10934
10935 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
10936   bool jresult ;
10937   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
10938   bool result;
10939
10940   arg1 = (Dali::VectorBase *)jarg1;
10941   {
10942     try {
10943       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
10944     } CALL_CATCH_EXCEPTION(0);
10945   }
10946
10947   jresult = result;
10948   return jresult;
10949 }
10950
10951
10952 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
10953   unsigned long jresult ;
10954   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
10955   Dali::VectorBase::SizeType result;
10956
10957   arg1 = (Dali::VectorBase *)jarg1;
10958   {
10959     try {
10960       result = ((Dali::VectorBase const *)arg1)->Capacity();
10961     } CALL_CATCH_EXCEPTION(0);
10962   }
10963
10964   jresult = (unsigned long)result;
10965   return jresult;
10966 }
10967
10968
10969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
10970   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
10971
10972   arg1 = (Dali::VectorBase *)jarg1;
10973   {
10974     try {
10975       (arg1)->Release();
10976     } CALL_CATCH_EXCEPTION();
10977   }
10978
10979 }
10980
10981
10982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
10983   int jresult ;
10984   Dali::Pixel::Format result;
10985
10986   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
10987   jresult = (int)result;
10988   return jresult;
10989 }
10990
10991
10992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
10993   int jresult ;
10994   Dali::Pixel::Format result;
10995
10996   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
10997   jresult = (int)result;
10998   return jresult;
10999 }
11000
11001
11002 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
11003   bool jresult ;
11004   Dali::Pixel::Format arg1 ;
11005   bool result;
11006
11007   arg1 = (Dali::Pixel::Format)jarg1;
11008   {
11009     try {
11010       result = (bool)Dali::Pixel::HasAlpha(arg1);
11011     } CALL_CATCH_EXCEPTION(0);
11012   }
11013
11014   jresult = result;
11015   return jresult;
11016 }
11017
11018
11019 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
11020   unsigned int jresult ;
11021   Dali::Pixel::Format arg1 ;
11022   unsigned int result;
11023
11024   arg1 = (Dali::Pixel::Format)jarg1;
11025   {
11026     try {
11027       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
11028     } CALL_CATCH_EXCEPTION(0);
11029   }
11030
11031   jresult = result;
11032   return jresult;
11033 }
11034
11035
11036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
11037   Dali::Pixel::Format arg1 ;
11038   int *arg2 = 0 ;
11039   int *arg3 = 0 ;
11040
11041   arg1 = (Dali::Pixel::Format)jarg1;
11042   arg2 = (int *)jarg2;
11043   if (!arg2) {
11044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
11045     return ;
11046   }
11047   arg3 = (int *)jarg3;
11048   if (!arg3) {
11049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
11050     return ;
11051   }
11052   {
11053     try {
11054       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
11055     } CALL_CATCH_EXCEPTION();
11056   }
11057
11058 }
11059
11060
11061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* nuiBuffer, unsigned int nuiBufferSize, unsigned int nuiWidth, unsigned int nuiHeight, int nuiPixelFormat) {
11062   void * jresult ;
11063   Dali::PixelData result;
11064
11065   {
11066     unsigned char* copiedBuffer;
11067     try
11068     {
11069       copiedBuffer = new unsigned char[nuiBufferSize];
11070     } CALL_CATCH_EXCEPTION(0);
11071
11072     try
11073     {
11074       // Note : copiedBuffer created by 'new' method. So ReleaseFunction always be DELETE_ARRAY.
11075       memcpy(copiedBuffer, nuiBuffer, nuiBufferSize);
11076       result = Dali::PixelData::New(copiedBuffer, nuiBufferSize, nuiWidth, nuiHeight, (Dali::Pixel::Format)nuiPixelFormat, Dali::PixelData::ReleaseFunction::DELETE_ARRAY);
11077     } CALL_CATCH_EXCEPTION_WITH_FUNCTION(0, [](unsigned char* buffer){delete[] buffer;}, copiedBuffer);
11078   }
11079
11080   jresult = new Dali::PixelData((const Dali::PixelData &)result);
11081
11082   return jresult;
11083 }
11084
11085
11086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
11087   void * jresult ;
11088   Dali::PixelData *result = 0 ;
11089
11090   {
11091     try {
11092       result = (Dali::PixelData *)new Dali::PixelData();
11093     } CALL_CATCH_EXCEPTION(0);
11094   }
11095
11096   jresult = (void *)result;
11097   return jresult;
11098 }
11099
11100
11101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * nuiHandle) {
11102   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
11103
11104   pixelData = (Dali::PixelData *)nuiHandle;
11105   {
11106     try {
11107       delete pixelData;
11108     } CALL_CATCH_EXCEPTION();
11109   }
11110
11111 }
11112
11113
11114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * nuiHandle) {
11115   void * jresult ;
11116   Dali::PixelData *pixelData = 0 ;
11117   Dali::PixelData *result = 0 ;
11118
11119   pixelData = (Dali::PixelData *)nuiHandle;
11120   if (!pixelData) {
11121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
11122     return 0;
11123   }
11124   {
11125     try {
11126       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*pixelData);
11127     } CALL_CATCH_EXCEPTION(0);
11128   }
11129
11130   jresult = (void *)result;
11131   return jresult;
11132 }
11133
11134
11135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * nuiHandle, void * nuiHandleSource) {
11136   void * jresult ;
11137   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
11138   Dali::PixelData *pixelDataSource = 0 ;
11139   Dali::PixelData *result = 0 ;
11140
11141   pixelData = (Dali::PixelData *)nuiHandle;
11142   pixelDataSource = (Dali::PixelData *)nuiHandleSource;
11143   if (!pixelDataSource) {
11144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
11145     return 0;
11146   }
11147   {
11148     try {
11149       result = (Dali::PixelData *) &(pixelData)->operator =((Dali::PixelData const &)*pixelDataSource);
11150     } CALL_CATCH_EXCEPTION(0);
11151   }
11152
11153   jresult = (void *)result;
11154   return jresult;
11155 }
11156
11157
11158 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * nuiHandle) {
11159   unsigned int jresult ;
11160   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
11161   unsigned int result;
11162
11163   pixelData = (Dali::PixelData *)nuiHandle;
11164   {
11165     try {
11166       result = (unsigned int)((Dali::PixelData const *)pixelData)->GetWidth();
11167     } CALL_CATCH_EXCEPTION(0);
11168   }
11169
11170   jresult = result;
11171   return jresult;
11172 }
11173
11174
11175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * nuiHandle) {
11176   unsigned int jresult ;
11177   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
11178   unsigned int result;
11179
11180   pixelData = (Dali::PixelData *)nuiHandle;
11181   {
11182     try {
11183       result = (unsigned int)((Dali::PixelData const *)pixelData)->GetHeight();
11184     } CALL_CATCH_EXCEPTION(0);
11185   }
11186
11187   jresult = result;
11188   return jresult;
11189 }
11190
11191
11192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * nuiHandle) {
11193   int jresult ;
11194   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
11195   Dali::Pixel::Format result;
11196
11197   pixelData = (Dali::PixelData *)nuiHandle;
11198   {
11199     try {
11200       result = (Dali::Pixel::Format)((Dali::PixelData const *)pixelData)->GetPixelFormat();
11201     } CALL_CATCH_EXCEPTION(0);
11202   }
11203
11204   jresult = (int)result;
11205   return jresult;
11206 }
11207
11208 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_PixelData_GenerateUrl(void* nuiHandle)
11209 {
11210   Dali::PixelData *pixelData = (Dali::PixelData*)nuiHandle;
11211   Dali::Toolkit::ImageUrl result;
11212   void *jresult;
11213
11214   if (!pixelData)
11215   {
11216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0);
11217     return 0;
11218   }
11219   {
11220     try
11221     {
11222       result = Dali::Toolkit::Image::GenerateUrl(*pixelData);
11223     } CALL_CATCH_EXCEPTION(0);
11224   }
11225
11226   jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl&)result);
11227   return jresult;
11228 }
11229
11230
11231 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
11232   unsigned int jresult ;
11233   unsigned int result;
11234
11235   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
11236   jresult = result;
11237   return jresult;
11238 }
11239
11240
11241 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
11242   unsigned int jresult ;
11243   unsigned int result;
11244
11245   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
11246   jresult = result;
11247   return jresult;
11248 }
11249
11250
11251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
11252   unsigned int jresult ;
11253   unsigned int result;
11254
11255   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
11256   jresult = result;
11257   return jresult;
11258 }
11259
11260
11261 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
11262   unsigned int jresult ;
11263   unsigned int result;
11264
11265   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
11266   jresult = result;
11267   return jresult;
11268 }
11269
11270
11271 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
11272   unsigned int jresult ;
11273   unsigned int result;
11274
11275   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
11276   jresult = result;
11277   return jresult;
11278 }
11279
11280
11281 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
11282   unsigned int jresult ;
11283   unsigned int result;
11284
11285   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
11286   jresult = result;
11287   return jresult;
11288 }
11289
11290
11291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
11292   void * jresult ;
11293   Dali::TextureType::Type arg1 ;
11294   Dali::Pixel::Format arg2 ;
11295   unsigned int arg3 ;
11296   unsigned int arg4 ;
11297   Dali::Texture result;
11298
11299   arg1 = (Dali::TextureType::Type)jarg1;
11300   arg2 = (Dali::Pixel::Format)jarg2;
11301   arg3 = (unsigned int)jarg3;
11302   arg4 = (unsigned int)jarg4;
11303   {
11304     try {
11305       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
11306     } CALL_CATCH_EXCEPTION(0);
11307   }
11308
11309   jresult = new Dali::Texture((const Dali::Texture &)result);
11310   return jresult;
11311 }
11312
11313
11314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
11315   void * jresult ;
11316   NativeImageInterface *arg1 = 0 ;
11317   Dali::Texture result;
11318
11319   arg1 = (NativeImageInterface *)jarg1;
11320   if (!arg1) {
11321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
11322     return 0;
11323   }
11324   {
11325     try {
11326       result = Dali::Texture::New(*arg1);
11327     } CALL_CATCH_EXCEPTION(0);
11328   }
11329
11330   jresult = new Dali::Texture((const Dali::Texture &)result);
11331   return jresult;
11332 }
11333
11334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
11335   void * jresult ;
11336   Dali::Texture *result = 0 ;
11337
11338   {
11339     try {
11340       result = (Dali::Texture *)new Dali::Texture();
11341     } CALL_CATCH_EXCEPTION(0);
11342   }
11343
11344   jresult = (void *)result;
11345   return jresult;
11346 }
11347
11348
11349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
11350   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
11351
11352   arg1 = (Dali::Texture *)jarg1;
11353   {
11354     try {
11355       delete arg1;
11356     } CALL_CATCH_EXCEPTION();
11357   }
11358
11359 }
11360
11361
11362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
11363   void * jresult ;
11364   Dali::Texture *arg1 = 0 ;
11365   Dali::Texture *result = 0 ;
11366
11367   arg1 = (Dali::Texture *)jarg1;
11368   if (!arg1) {
11369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
11370     return 0;
11371   }
11372   {
11373     try {
11374       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
11375     } CALL_CATCH_EXCEPTION(0);
11376   }
11377
11378   jresult = (void *)result;
11379   return jresult;
11380 }
11381
11382
11383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
11384   void * jresult ;
11385   Dali::BaseHandle arg1 ;
11386   Dali::BaseHandle *argp1 ;
11387   Dali::Texture result;
11388
11389   argp1 = (Dali::BaseHandle *)jarg1;
11390   if (!argp1) {
11391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
11392     return 0;
11393   }
11394   arg1 = *argp1;
11395   {
11396     try {
11397       result = Dali::Texture::DownCast(arg1);
11398     } CALL_CATCH_EXCEPTION(0);
11399   }
11400
11401   jresult = new Dali::Texture((const Dali::Texture &)result);
11402   return jresult;
11403 }
11404
11405
11406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
11407   void * jresult ;
11408   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
11409   Dali::Texture *arg2 = 0 ;
11410   Dali::Texture *result = 0 ;
11411
11412   arg1 = (Dali::Texture *)jarg1;
11413   arg2 = (Dali::Texture *)jarg2;
11414   if (!arg2) {
11415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
11416     return 0;
11417   }
11418   {
11419     try {
11420       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
11421     } CALL_CATCH_EXCEPTION(0);
11422   }
11423
11424   jresult = (void *)result;
11425   return jresult;
11426 }
11427
11428
11429 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
11430   bool jresult ;
11431   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
11432   Dali::PixelData arg2 ;
11433   Dali::PixelData *argp2 ;
11434   bool result;
11435
11436   arg1 = (Dali::Texture *)jarg1;
11437   argp2 = (Dali::PixelData *)jarg2;
11438   if (!argp2) {
11439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
11440     return 0;
11441   }
11442   arg2 = *argp2;
11443   {
11444     try {
11445       result = (bool)(arg1)->Upload(arg2);
11446     } CALL_CATCH_EXCEPTION(0);
11447   }
11448
11449   jresult = result;
11450   return jresult;
11451 }
11452
11453
11454 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) {
11455   bool jresult ;
11456   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
11457   Dali::PixelData arg2 ;
11458   unsigned int arg3 ;
11459   unsigned int arg4 ;
11460   unsigned int arg5 ;
11461   unsigned int arg6 ;
11462   unsigned int arg7 ;
11463   unsigned int arg8 ;
11464   Dali::PixelData *argp2 ;
11465   bool result;
11466
11467   arg1 = (Dali::Texture *)jarg1;
11468   argp2 = (Dali::PixelData *)jarg2;
11469   if (!argp2) {
11470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
11471     return 0;
11472   }
11473   arg2 = *argp2;
11474   arg3 = (unsigned int)jarg3;
11475   arg4 = (unsigned int)jarg4;
11476   arg5 = (unsigned int)jarg5;
11477   arg6 = (unsigned int)jarg6;
11478   arg7 = (unsigned int)jarg7;
11479   arg8 = (unsigned int)jarg8;
11480   {
11481     try {
11482       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
11483     } CALL_CATCH_EXCEPTION(0);
11484   }
11485
11486   jresult = result;
11487   return jresult;
11488 }
11489
11490
11491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
11492   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
11493
11494   arg1 = (Dali::Texture *)jarg1;
11495   {
11496     try {
11497       (arg1)->GenerateMipmaps();
11498     } CALL_CATCH_EXCEPTION();
11499   }
11500
11501 }
11502
11503
11504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
11505   unsigned int jresult ;
11506   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
11507   unsigned int result;
11508
11509   arg1 = (Dali::Texture *)jarg1;
11510   {
11511     try {
11512       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
11513     } CALL_CATCH_EXCEPTION(0);
11514   }
11515
11516   jresult = result;
11517   return jresult;
11518 }
11519
11520
11521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
11522   unsigned int jresult ;
11523   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
11524   unsigned int result;
11525
11526   arg1 = (Dali::Texture *)jarg1;
11527   {
11528     try {
11529       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
11530     } CALL_CATCH_EXCEPTION(0);
11531   }
11532
11533   jresult = result;
11534   return jresult;
11535 }
11536
11537
11538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
11539   void * jresult ;
11540   Dali::Sampler result;
11541
11542   {
11543     try {
11544       result = Dali::Sampler::New();
11545     } CALL_CATCH_EXCEPTION(0);
11546   }
11547
11548   jresult = new Dali::Sampler((const Dali::Sampler &)result);
11549   return jresult;
11550 }
11551
11552
11553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
11554   void * jresult ;
11555   Dali::Sampler *result = 0 ;
11556
11557   {
11558     try {
11559       result = (Dali::Sampler *)new Dali::Sampler();
11560     } CALL_CATCH_EXCEPTION(0);
11561   }
11562
11563   jresult = (void *)result;
11564   return jresult;
11565 }
11566
11567
11568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
11569   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
11570
11571   arg1 = (Dali::Sampler *)jarg1;
11572   {
11573     try {
11574       delete arg1;
11575     } CALL_CATCH_EXCEPTION();
11576   }
11577
11578 }
11579
11580
11581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
11582   void * jresult ;
11583   Dali::Sampler *arg1 = 0 ;
11584   Dali::Sampler *result = 0 ;
11585
11586   arg1 = (Dali::Sampler *)jarg1;
11587   if (!arg1) {
11588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
11589     return 0;
11590   }
11591   {
11592     try {
11593       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
11594     } CALL_CATCH_EXCEPTION(0);
11595   }
11596
11597   jresult = (void *)result;
11598   return jresult;
11599 }
11600
11601
11602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
11603   void * jresult ;
11604   Dali::BaseHandle arg1 ;
11605   Dali::BaseHandle *argp1 ;
11606   Dali::Sampler result;
11607
11608   argp1 = (Dali::BaseHandle *)jarg1;
11609   if (!argp1) {
11610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
11611     return 0;
11612   }
11613   arg1 = *argp1;
11614   {
11615     try {
11616       result = Dali::Sampler::DownCast(arg1);
11617     } CALL_CATCH_EXCEPTION(0);
11618   }
11619
11620   jresult = new Dali::Sampler((const Dali::Sampler &)result);
11621   return jresult;
11622 }
11623
11624
11625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
11626   void * jresult ;
11627   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
11628   Dali::Sampler *arg2 = 0 ;
11629   Dali::Sampler *result = 0 ;
11630
11631   arg1 = (Dali::Sampler *)jarg1;
11632   arg2 = (Dali::Sampler *)jarg2;
11633   if (!arg2) {
11634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
11635     return 0;
11636   }
11637   {
11638     try {
11639       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
11640     } CALL_CATCH_EXCEPTION(0);
11641   }
11642
11643   jresult = (void *)result;
11644   return jresult;
11645 }
11646
11647
11648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
11649   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
11650   Dali::FilterMode::Type arg2 ;
11651   Dali::FilterMode::Type arg3 ;
11652
11653   arg1 = (Dali::Sampler *)jarg1;
11654   arg2 = (Dali::FilterMode::Type)jarg2;
11655   arg3 = (Dali::FilterMode::Type)jarg3;
11656   {
11657     try {
11658       (arg1)->SetFilterMode(arg2,arg3);
11659     } CALL_CATCH_EXCEPTION();
11660   }
11661
11662 }
11663
11664
11665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
11666   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
11667   Dali::WrapMode::Type arg2 ;
11668   Dali::WrapMode::Type arg3 ;
11669
11670   arg1 = (Dali::Sampler *)jarg1;
11671   arg2 = (Dali::WrapMode::Type)jarg2;
11672   arg3 = (Dali::WrapMode::Type)jarg3;
11673   {
11674     try {
11675       (arg1)->SetWrapMode(arg2,arg3);
11676     } CALL_CATCH_EXCEPTION();
11677   }
11678
11679 }
11680
11681
11682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
11683   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
11684   Dali::WrapMode::Type arg2 ;
11685   Dali::WrapMode::Type arg3 ;
11686   Dali::WrapMode::Type arg4 ;
11687
11688   arg1 = (Dali::Sampler *)jarg1;
11689   arg2 = (Dali::WrapMode::Type)jarg2;
11690   arg3 = (Dali::WrapMode::Type)jarg3;
11691   arg4 = (Dali::WrapMode::Type)jarg4;
11692   {
11693     try {
11694       (arg1)->SetWrapMode(arg2,arg3,arg4);
11695     } CALL_CATCH_EXCEPTION();
11696   }
11697
11698 }
11699
11700
11701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
11702   void * jresult ;
11703   Dali::TextureSet result;
11704
11705   {
11706     try {
11707       result = Dali::TextureSet::New();
11708     } CALL_CATCH_EXCEPTION(0);
11709   }
11710
11711   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
11712   return jresult;
11713 }
11714
11715
11716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
11717   void * jresult ;
11718   Dali::TextureSet *result = 0 ;
11719
11720   {
11721     try {
11722       result = (Dali::TextureSet *)new Dali::TextureSet();
11723     } CALL_CATCH_EXCEPTION(0);
11724   }
11725
11726   jresult = (void *)result;
11727   return jresult;
11728 }
11729
11730
11731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
11732   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
11733
11734   arg1 = (Dali::TextureSet *)jarg1;
11735   {
11736     try {
11737       delete arg1;
11738     } CALL_CATCH_EXCEPTION();
11739   }
11740
11741 }
11742
11743
11744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
11745   void * jresult ;
11746   Dali::TextureSet *arg1 = 0 ;
11747   Dali::TextureSet *result = 0 ;
11748
11749   arg1 = (Dali::TextureSet *)jarg1;
11750   if (!arg1) {
11751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
11752     return 0;
11753   }
11754   {
11755     try {
11756       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
11757     } CALL_CATCH_EXCEPTION(0);
11758   }
11759
11760   jresult = (void *)result;
11761   return jresult;
11762 }
11763
11764
11765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
11766   void * jresult ;
11767   Dali::BaseHandle arg1 ;
11768   Dali::BaseHandle *argp1 ;
11769   Dali::TextureSet result;
11770
11771   argp1 = (Dali::BaseHandle *)jarg1;
11772   if (!argp1) {
11773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
11774     return 0;
11775   }
11776   arg1 = *argp1;
11777   {
11778     try {
11779       result = Dali::TextureSet::DownCast(arg1);
11780     } CALL_CATCH_EXCEPTION(0);
11781   }
11782
11783   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
11784   return jresult;
11785 }
11786
11787
11788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
11789   void * jresult ;
11790   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
11791   Dali::TextureSet *arg2 = 0 ;
11792   Dali::TextureSet *result = 0 ;
11793
11794   arg1 = (Dali::TextureSet *)jarg1;
11795   arg2 = (Dali::TextureSet *)jarg2;
11796   if (!arg2) {
11797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
11798     return 0;
11799   }
11800   {
11801     try {
11802       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
11803     } CALL_CATCH_EXCEPTION(0);
11804   }
11805
11806   jresult = (void *)result;
11807   return jresult;
11808 }
11809
11810
11811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
11812   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
11813   size_t arg2 ;
11814   Dali::Texture arg3 ;
11815   Dali::Texture *argp3 ;
11816
11817   arg1 = (Dali::TextureSet *)jarg1;
11818   arg2 = (size_t)jarg2;
11819   argp3 = (Dali::Texture *)jarg3;
11820   if (!argp3) {
11821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
11822     return ;
11823   }
11824   arg3 = *argp3;
11825   {
11826     try {
11827       (arg1)->SetTexture(arg2,arg3);
11828     } CALL_CATCH_EXCEPTION();
11829   }
11830
11831 }
11832
11833
11834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
11835   void * jresult ;
11836   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
11837   size_t arg2 ;
11838   Dali::Texture result;
11839
11840   arg1 = (Dali::TextureSet *)jarg1;
11841   arg2 = (size_t)jarg2;
11842   {
11843     try {
11844       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
11845     } CALL_CATCH_EXCEPTION(0);
11846   }
11847
11848   jresult = new Dali::Texture((const Dali::Texture &)result);
11849   return jresult;
11850 }
11851
11852
11853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
11854   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
11855   size_t arg2 ;
11856   Dali::Sampler arg3 ;
11857   Dali::Sampler *argp3 ;
11858
11859   arg1 = (Dali::TextureSet *)jarg1;
11860   arg2 = (size_t)jarg2;
11861   argp3 = (Dali::Sampler *)jarg3;
11862   if (!argp3) {
11863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
11864     return ;
11865   }
11866   arg3 = *argp3;
11867   {
11868     try {
11869       (arg1)->SetSampler(arg2,arg3);
11870     } CALL_CATCH_EXCEPTION();
11871   }
11872
11873 }
11874
11875
11876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
11877   void * jresult ;
11878   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
11879   size_t arg2 ;
11880   Dali::Sampler result;
11881
11882   arg1 = (Dali::TextureSet *)jarg1;
11883   arg2 = (size_t)jarg2;
11884   {
11885     try {
11886       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
11887     } CALL_CATCH_EXCEPTION(0);
11888   }
11889
11890   jresult = new Dali::Sampler((const Dali::Sampler &)result);
11891   return jresult;
11892 }
11893
11894
11895 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
11896   unsigned long jresult ;
11897   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
11898   size_t result;
11899
11900   arg1 = (Dali::TextureSet *)jarg1;
11901   {
11902     try {
11903       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
11904     } CALL_CATCH_EXCEPTION(0);
11905   }
11906
11907   jresult = (unsigned long)result;
11908   return jresult;
11909 }
11910
11911
11912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_New(void * jarg1) {
11913   void * jresult ;
11914   Dali::Property::Map *arg1 = 0 ;
11915   Dali::VertexBuffer result;
11916
11917   arg1 = (Dali::Property::Map *)jarg1;
11918   if (!arg1) {
11919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
11920     return 0;
11921   }
11922   {
11923     try {
11924       result = Dali::VertexBuffer::New(*arg1);
11925     } CALL_CATCH_EXCEPTION(0);
11926   }
11927
11928   jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result);
11929   return jresult;
11930 }
11931
11932
11933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_0() {
11934   void * jresult ;
11935   Dali::VertexBuffer *result = 0 ;
11936
11937   {
11938     try {
11939       result = (Dali::VertexBuffer *)new Dali::VertexBuffer();
11940     } CALL_CATCH_EXCEPTION(0);
11941   }
11942
11943   jresult = (void *)result;
11944   return jresult;
11945 }
11946
11947
11948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VertexBuffer(void * jarg1) {
11949   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
11950
11951   arg1 = (Dali::VertexBuffer *)jarg1;
11952   {
11953     try {
11954       delete arg1;
11955     } CALL_CATCH_EXCEPTION();
11956   }
11957
11958 }
11959
11960
11961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_1(void * jarg1) {
11962   void * jresult ;
11963   Dali::VertexBuffer *arg1 = 0 ;
11964   Dali::VertexBuffer *result = 0 ;
11965
11966   arg1 = (Dali::VertexBuffer *)jarg1;
11967   if (!arg1) {
11968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0);
11969     return 0;
11970   }
11971   {
11972     try {
11973       result = (Dali::VertexBuffer *)new Dali::VertexBuffer((Dali::VertexBuffer const &)*arg1);
11974     } CALL_CATCH_EXCEPTION(0);
11975   }
11976
11977   jresult = (void *)result;
11978   return jresult;
11979 }
11980
11981
11982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_DownCast(void * jarg1) {
11983   void * jresult ;
11984   Dali::BaseHandle arg1 ;
11985   Dali::BaseHandle *argp1 ;
11986   Dali::VertexBuffer result;
11987
11988   argp1 = (Dali::BaseHandle *)jarg1;
11989   if (!argp1) {
11990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
11991     return 0;
11992   }
11993   arg1 = *argp1;
11994   {
11995     try {
11996       result = Dali::VertexBuffer::DownCast(arg1);
11997     } CALL_CATCH_EXCEPTION(0);
11998   }
11999
12000   jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result);
12001   return jresult;
12002 }
12003
12004
12005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_Assign(void * jarg1, void * jarg2) {
12006   void * jresult ;
12007   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
12008   Dali::VertexBuffer *arg2 = 0 ;
12009   Dali::VertexBuffer *result = 0 ;
12010
12011   arg1 = (Dali::VertexBuffer *)jarg1;
12012   arg2 = (Dali::VertexBuffer *)jarg2;
12013   if (!arg2) {
12014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0);
12015     return 0;
12016   }
12017   {
12018     try {
12019       result = (Dali::VertexBuffer *) &(arg1)->operator =((Dali::VertexBuffer const &)*arg2);
12020     } CALL_CATCH_EXCEPTION(0);
12021   }
12022
12023   jresult = (void *)result;
12024   return jresult;
12025 }
12026
12027
12028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VertexBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
12029   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
12030   void *arg2 = (void *) 0 ;
12031   std::size_t arg3 ;
12032
12033   arg1 = (Dali::VertexBuffer *)jarg1;
12034   arg2 = jarg2;
12035   arg3 = (std::size_t)jarg3;
12036   {
12037     try {
12038       (arg1)->SetData((void const *)arg2,arg3);
12039     } CALL_CATCH_EXCEPTION();
12040   }
12041
12042 }
12043
12044
12045 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VertexBuffer_GetSize(void * jarg1) {
12046   unsigned long jresult ;
12047   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
12048   std::size_t result;
12049
12050   arg1 = (Dali::VertexBuffer *)jarg1;
12051   {
12052     try {
12053       result = ((Dali::VertexBuffer const *)arg1)->GetSize();
12054     } CALL_CATCH_EXCEPTION(0);
12055   }
12056
12057   jresult = (unsigned long)result;
12058   return jresult;
12059 }
12060
12061
12062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
12063   void * jresult ;
12064   Dali::Geometry result;
12065
12066   {
12067     try {
12068       result = Dali::Geometry::New();
12069     } CALL_CATCH_EXCEPTION(0);
12070   }
12071
12072   jresult = new Dali::Geometry((const Dali::Geometry &)result);
12073   return jresult;
12074 }
12075
12076
12077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
12078   void * jresult ;
12079   Dali::Geometry *result = 0 ;
12080
12081   {
12082     try {
12083       result = (Dali::Geometry *)new Dali::Geometry();
12084     } CALL_CATCH_EXCEPTION(0);
12085   }
12086
12087   jresult = (void *)result;
12088   return jresult;
12089 }
12090
12091
12092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
12093   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
12094
12095   arg1 = (Dali::Geometry *)jarg1;
12096   {
12097     try {
12098       delete arg1;
12099     } CALL_CATCH_EXCEPTION();
12100   }
12101
12102 }
12103
12104
12105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
12106   void * jresult ;
12107   Dali::Geometry *arg1 = 0 ;
12108   Dali::Geometry *result = 0 ;
12109
12110   arg1 = (Dali::Geometry *)jarg1;
12111   if (!arg1) {
12112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
12113     return 0;
12114   }
12115   {
12116     try {
12117       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
12118     } CALL_CATCH_EXCEPTION(0);
12119   }
12120
12121   jresult = (void *)result;
12122   return jresult;
12123 }
12124
12125
12126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
12127   void * jresult ;
12128   Dali::BaseHandle arg1 ;
12129   Dali::BaseHandle *argp1 ;
12130   Dali::Geometry result;
12131
12132   argp1 = (Dali::BaseHandle *)jarg1;
12133   if (!argp1) {
12134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
12135     return 0;
12136   }
12137   arg1 = *argp1;
12138   {
12139     try {
12140       result = Dali::Geometry::DownCast(arg1);
12141     } CALL_CATCH_EXCEPTION(0);
12142   }
12143
12144   jresult = new Dali::Geometry((const Dali::Geometry &)result);
12145   return jresult;
12146 }
12147
12148
12149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
12150   void * jresult ;
12151   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
12152   Dali::Geometry *arg2 = 0 ;
12153   Dali::Geometry *result = 0 ;
12154
12155   arg1 = (Dali::Geometry *)jarg1;
12156   arg2 = (Dali::Geometry *)jarg2;
12157   if (!arg2) {
12158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
12159     return 0;
12160   }
12161   {
12162     try {
12163       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
12164     } CALL_CATCH_EXCEPTION(0);
12165   }
12166
12167   jresult = (void *)result;
12168   return jresult;
12169 }
12170
12171
12172 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
12173   unsigned long jresult ;
12174   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
12175   Dali::VertexBuffer *arg2 = 0 ;
12176   std::size_t result;
12177
12178   arg1 = (Dali::Geometry *)jarg1;
12179   arg2 = (Dali::VertexBuffer *)jarg2;
12180   if (!arg2) {
12181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer & type is null", 0);
12182     return 0;
12183   }
12184   {
12185     try {
12186       result = (arg1)->AddVertexBuffer(*arg2);
12187     } CALL_CATCH_EXCEPTION(0);
12188   }
12189
12190   jresult = (unsigned long)result;
12191   return jresult;
12192 }
12193
12194
12195 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
12196   unsigned long jresult ;
12197   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
12198   std::size_t result;
12199
12200   arg1 = (Dali::Geometry *)jarg1;
12201   {
12202     try {
12203       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
12204     } CALL_CATCH_EXCEPTION(0);
12205   }
12206
12207   jresult = (unsigned long)result;
12208   return jresult;
12209 }
12210
12211
12212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
12213   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
12214   std::size_t arg2 ;
12215
12216   arg1 = (Dali::Geometry *)jarg1;
12217   arg2 = (std::size_t)jarg2;
12218   {
12219     try {
12220       (arg1)->RemoveVertexBuffer(arg2);
12221     } CALL_CATCH_EXCEPTION();
12222   }
12223
12224 }
12225
12226
12227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
12228   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
12229   unsigned short *arg2 = (unsigned short *) 0 ;
12230   size_t arg3 ;
12231
12232   arg1 = (Dali::Geometry *)jarg1;
12233   arg2 = jarg2;
12234   arg3 = (size_t)jarg3;
12235   {
12236     try {
12237       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
12238     } CALL_CATCH_EXCEPTION();
12239   }
12240
12241
12242
12243 }
12244
12245
12246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
12247   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
12248   Dali::Geometry::Type arg2 ;
12249
12250   arg1 = (Dali::Geometry *)jarg1;
12251   arg2 = (Dali::Geometry::Type)jarg2;
12252   {
12253     try {
12254       (arg1)->SetType(arg2);
12255     } CALL_CATCH_EXCEPTION();
12256   }
12257
12258 }
12259
12260
12261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
12262   int jresult ;
12263   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
12264   Dali::Geometry::Type result;
12265
12266   arg1 = (Dali::Geometry *)jarg1;
12267   {
12268     try {
12269       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
12270     } CALL_CATCH_EXCEPTION(0);
12271   }
12272
12273   jresult = (int)result;
12274   return jresult;
12275 }
12276
12277
12278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
12279   void * jresult ;
12280   Dali::Shader::Hint *result = 0 ;
12281
12282   {
12283     try {
12284       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
12285     } CALL_CATCH_EXCEPTION(0);
12286   }
12287
12288   jresult = (void *)result;
12289   return jresult;
12290 }
12291
12292
12293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
12294   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
12295
12296   arg1 = (Dali::Shader::Hint *)jarg1;
12297   {
12298     try {
12299       delete arg1;
12300     } CALL_CATCH_EXCEPTION();
12301   }
12302
12303 }
12304
12305
12306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
12307   int jresult ;
12308   int result;
12309
12310   result = (int)Dali::Shader::Property::PROGRAM;
12311   jresult = (int)result;
12312   return jresult;
12313 }
12314
12315
12316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
12317   void * jresult ;
12318   Dali::Shader::Property *result = 0 ;
12319
12320   {
12321     try {
12322       result = (Dali::Shader::Property *)new Dali::Shader::Property();
12323     } CALL_CATCH_EXCEPTION(0);
12324   }
12325
12326   jresult = (void *)result;
12327   return jresult;
12328 }
12329
12330
12331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
12332   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
12333
12334   arg1 = (Dali::Shader::Property *)jarg1;
12335   {
12336     try {
12337       delete arg1;
12338     } CALL_CATCH_EXCEPTION();
12339   }
12340
12341 }
12342
12343
12344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
12345   void * jresult ;
12346   std::string *arg1 = 0 ;
12347   std::string *arg2 = 0 ;
12348   Dali::Shader::Hint::Value arg3 ;
12349   Dali::Shader result;
12350
12351   if (!jarg1) {
12352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
12353     return 0;
12354   }
12355   std::string arg1_str(jarg1);
12356   arg1 = &arg1_str;
12357   if (!jarg2) {
12358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
12359     return 0;
12360   }
12361   std::string arg2_str(jarg2);
12362   arg2 = &arg2_str;
12363   arg3 = (Dali::Shader::Hint::Value)jarg3;
12364   {
12365     try {
12366       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
12367     } CALL_CATCH_EXCEPTION(0);
12368   }
12369
12370   jresult = new Dali::Shader((const Dali::Shader &)result);
12371
12372   //argout typemap for const std::string&
12373
12374
12375   //argout typemap for const std::string&
12376
12377   return jresult;
12378 }
12379
12380
12381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
12382   void * jresult ;
12383   std::string *arg1 = 0 ;
12384   std::string *arg2 = 0 ;
12385   Dali::Shader result;
12386
12387   if (!jarg1) {
12388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
12389     return 0;
12390   }
12391   std::string arg1_str(jarg1);
12392   arg1 = &arg1_str;
12393   if (!jarg2) {
12394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
12395     return 0;
12396   }
12397   std::string arg2_str(jarg2);
12398   arg2 = &arg2_str;
12399   {
12400     try {
12401       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
12402     } CALL_CATCH_EXCEPTION(0);
12403   }
12404
12405   jresult = new Dali::Shader((const Dali::Shader &)result);
12406
12407   //argout typemap for const std::string&
12408
12409
12410   //argout typemap for const std::string&
12411
12412   return jresult;
12413 }
12414
12415
12416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
12417   void * jresult ;
12418   Dali::Shader *result = 0 ;
12419
12420   {
12421     try {
12422       result = (Dali::Shader *)new Dali::Shader();
12423     } CALL_CATCH_EXCEPTION(0);
12424   }
12425
12426   jresult = (void *)result;
12427   return jresult;
12428 }
12429
12430
12431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
12432   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
12433
12434   arg1 = (Dali::Shader *)jarg1;
12435   {
12436     try {
12437       delete arg1;
12438     } CALL_CATCH_EXCEPTION();
12439   }
12440
12441 }
12442
12443
12444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
12445   void * jresult ;
12446   Dali::Shader *arg1 = 0 ;
12447   Dali::Shader *result = 0 ;
12448
12449   arg1 = (Dali::Shader *)jarg1;
12450   if (!arg1) {
12451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
12452     return 0;
12453   }
12454   {
12455     try {
12456       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
12457     } CALL_CATCH_EXCEPTION(0);
12458   }
12459
12460   jresult = (void *)result;
12461   return jresult;
12462 }
12463
12464
12465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
12466   void * jresult ;
12467   Dali::BaseHandle arg1 ;
12468   Dali::BaseHandle *argp1 ;
12469   Dali::Shader result;
12470
12471   argp1 = (Dali::BaseHandle *)jarg1;
12472   if (!argp1) {
12473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
12474     return 0;
12475   }
12476   arg1 = *argp1;
12477   {
12478     try {
12479       result = Dali::Shader::DownCast(arg1);
12480     } CALL_CATCH_EXCEPTION(0);
12481   }
12482
12483   jresult = new Dali::Shader((const Dali::Shader &)result);
12484   return jresult;
12485 }
12486
12487
12488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
12489   void * jresult ;
12490   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
12491   Dali::Shader *arg2 = 0 ;
12492   Dali::Shader *result = 0 ;
12493
12494   arg1 = (Dali::Shader *)jarg1;
12495   arg2 = (Dali::Shader *)jarg2;
12496   if (!arg2) {
12497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
12498     return 0;
12499   }
12500   {
12501     try {
12502       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
12503     } CALL_CATCH_EXCEPTION(0);
12504   }
12505
12506   jresult = (void *)result;
12507   return jresult;
12508 }
12509
12510
12511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
12512   int jresult ;
12513   int result;
12514
12515   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
12516   jresult = (int)result;
12517   return jresult;
12518 }
12519
12520
12521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
12522   int jresult ;
12523   int result;
12524
12525   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
12526   jresult = (int)result;
12527   return jresult;
12528 }
12529
12530
12531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
12532   int jresult ;
12533   int result;
12534
12535   result = (int)Dali::Renderer::Property::BLEND_MODE;
12536   jresult = (int)result;
12537   return jresult;
12538 }
12539
12540
12541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
12542   int jresult ;
12543   int result;
12544
12545   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
12546   jresult = (int)result;
12547   return jresult;
12548 }
12549
12550
12551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
12552   int jresult ;
12553   int result;
12554
12555   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
12556   jresult = (int)result;
12557   return jresult;
12558 }
12559
12560
12561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
12562   int jresult ;
12563   int result;
12564
12565   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
12566   jresult = (int)result;
12567   return jresult;
12568 }
12569
12570
12571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
12572   int jresult ;
12573   int result;
12574
12575   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
12576   jresult = (int)result;
12577   return jresult;
12578 }
12579
12580
12581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
12582   int jresult ;
12583   int result;
12584
12585   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
12586   jresult = (int)result;
12587   return jresult;
12588 }
12589
12590
12591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
12592   int jresult ;
12593   int result;
12594
12595   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
12596   jresult = (int)result;
12597   return jresult;
12598 }
12599
12600
12601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
12602   int jresult ;
12603   int result;
12604
12605   result = (int)Dali::Renderer::Property::BLEND_COLOR;
12606   jresult = (int)result;
12607   return jresult;
12608 }
12609
12610
12611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
12612   int jresult ;
12613   int result;
12614
12615   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
12616   jresult = (int)result;
12617   return jresult;
12618 }
12619
12620
12621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
12622   int jresult ;
12623   int result;
12624
12625   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
12626   jresult = (int)result;
12627   return jresult;
12628 }
12629
12630
12631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
12632   int jresult ;
12633   int result;
12634
12635   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
12636   jresult = (int)result;
12637   return jresult;
12638 }
12639
12640
12641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
12642   int jresult ;
12643   int result;
12644
12645   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
12646   jresult = (int)result;
12647   return jresult;
12648 }
12649
12650
12651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
12652   int jresult ;
12653   int result;
12654
12655   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
12656   jresult = (int)result;
12657   return jresult;
12658 }
12659
12660
12661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
12662   int jresult ;
12663   int result;
12664
12665   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
12666   jresult = (int)result;
12667   return jresult;
12668 }
12669
12670
12671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
12672   int jresult ;
12673   int result;
12674
12675   result = (int)Dali::Renderer::Property::RENDER_MODE;
12676   jresult = (int)result;
12677   return jresult;
12678 }
12679
12680
12681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
12682   int jresult ;
12683   int result;
12684
12685   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
12686   jresult = (int)result;
12687   return jresult;
12688 }
12689
12690
12691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
12692   int jresult ;
12693   int result;
12694
12695   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
12696   jresult = (int)result;
12697   return jresult;
12698 }
12699
12700
12701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
12702   int jresult ;
12703   int result;
12704
12705   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
12706   jresult = (int)result;
12707   return jresult;
12708 }
12709
12710
12711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
12712   int jresult ;
12713   int result;
12714
12715   result = (int)Dali::Renderer::Property::STENCIL_MASK;
12716   jresult = (int)result;
12717   return jresult;
12718 }
12719
12720
12721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
12722   int jresult ;
12723   int result;
12724
12725   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
12726   jresult = (int)result;
12727   return jresult;
12728 }
12729
12730
12731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
12732   int jresult ;
12733   int result;
12734
12735   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
12736   jresult = (int)result;
12737   return jresult;
12738 }
12739
12740
12741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
12742   int jresult ;
12743   int result;
12744
12745   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
12746   jresult = (int)result;
12747   return jresult;
12748 }
12749
12750
12751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
12752   void * jresult ;
12753   Dali::Renderer::Property *result = 0 ;
12754
12755   {
12756     try {
12757       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
12758     } CALL_CATCH_EXCEPTION(0);
12759   }
12760
12761   jresult = (void *)result;
12762   return jresult;
12763 }
12764
12765
12766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
12767   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
12768
12769   arg1 = (Dali::Renderer::Property *)jarg1;
12770   {
12771     try {
12772       delete arg1;
12773     } CALL_CATCH_EXCEPTION();
12774   }
12775
12776 }
12777
12778
12779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
12780   void * jresult ;
12781   Dali::Geometry *arg1 = 0 ;
12782   Dali::Shader *arg2 = 0 ;
12783   Dali::Renderer result;
12784
12785   arg1 = (Dali::Geometry *)jarg1;
12786   if (!arg1) {
12787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
12788     return 0;
12789   }
12790   arg2 = (Dali::Shader *)jarg2;
12791   if (!arg2) {
12792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
12793     return 0;
12794   }
12795   {
12796     try {
12797       result = Dali::Renderer::New(*arg1,*arg2);
12798     } CALL_CATCH_EXCEPTION(0);
12799   }
12800
12801   jresult = new Dali::Renderer((const Dali::Renderer &)result);
12802   return jresult;
12803 }
12804
12805
12806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
12807   void * jresult ;
12808   Dali::Renderer *result = 0 ;
12809
12810   {
12811     try {
12812       result = (Dali::Renderer *)new Dali::Renderer();
12813     } CALL_CATCH_EXCEPTION(0);
12814   }
12815
12816   jresult = (void *)result;
12817   return jresult;
12818 }
12819
12820
12821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
12822   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
12823
12824   arg1 = (Dali::Renderer *)jarg1;
12825   {
12826     try {
12827       delete arg1;
12828     } CALL_CATCH_EXCEPTION();
12829   }
12830
12831 }
12832
12833
12834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
12835   void * jresult ;
12836   Dali::Renderer *arg1 = 0 ;
12837   Dali::Renderer *result = 0 ;
12838
12839   arg1 = (Dali::Renderer *)jarg1;
12840   if (!arg1) {
12841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
12842     return 0;
12843   }
12844   {
12845     try {
12846       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
12847     } CALL_CATCH_EXCEPTION(0);
12848   }
12849
12850   jresult = (void *)result;
12851   return jresult;
12852 }
12853
12854
12855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
12856   void * jresult ;
12857   Dali::BaseHandle arg1 ;
12858   Dali::BaseHandle *argp1 ;
12859   Dali::Renderer result;
12860
12861   argp1 = (Dali::BaseHandle *)jarg1;
12862   if (!argp1) {
12863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
12864     return 0;
12865   }
12866   arg1 = *argp1;
12867   {
12868     try {
12869       result = Dali::Renderer::DownCast(arg1);
12870     } CALL_CATCH_EXCEPTION(0);
12871   }
12872
12873   jresult = new Dali::Renderer((const Dali::Renderer &)result);
12874   return jresult;
12875 }
12876
12877
12878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
12879   void * jresult ;
12880   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
12881   Dali::Renderer *arg2 = 0 ;
12882   Dali::Renderer *result = 0 ;
12883
12884   arg1 = (Dali::Renderer *)jarg1;
12885   arg2 = (Dali::Renderer *)jarg2;
12886   if (!arg2) {
12887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
12888     return 0;
12889   }
12890   {
12891     try {
12892       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
12893     } CALL_CATCH_EXCEPTION(0);
12894   }
12895
12896   jresult = (void *)result;
12897   return jresult;
12898 }
12899
12900
12901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
12902   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
12903   Dali::Geometry *arg2 = 0 ;
12904
12905   arg1 = (Dali::Renderer *)jarg1;
12906   arg2 = (Dali::Geometry *)jarg2;
12907   if (!arg2) {
12908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
12909     return ;
12910   }
12911   {
12912     try {
12913       (arg1)->SetGeometry(*arg2);
12914     } CALL_CATCH_EXCEPTION();
12915   }
12916
12917 }
12918
12919
12920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
12921   void * jresult ;
12922   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
12923   Dali::Geometry result;
12924
12925   arg1 = (Dali::Renderer *)jarg1;
12926   {
12927     try {
12928       result = ((Dali::Renderer const *)arg1)->GetGeometry();
12929     } CALL_CATCH_EXCEPTION(0);
12930   }
12931
12932   jresult = new Dali::Geometry((const Dali::Geometry &)result);
12933   return jresult;
12934 }
12935
12936
12937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
12938   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
12939   int arg2 ;
12940   int arg3 ;
12941
12942   arg1 = (Dali::Renderer *)jarg1;
12943   arg2 = (int)jarg2;
12944   arg3 = (int)jarg3;
12945   {
12946     try {
12947       (arg1)->SetIndexRange(arg2,arg3);
12948     } CALL_CATCH_EXCEPTION();
12949   }
12950
12951 }
12952
12953
12954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
12955   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
12956   Dali::TextureSet *arg2 = 0 ;
12957
12958   arg1 = (Dali::Renderer *)jarg1;
12959   arg2 = (Dali::TextureSet *)jarg2;
12960   if (!arg2) {
12961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
12962     return ;
12963   }
12964   {
12965     try {
12966       (arg1)->SetTextures(*arg2);
12967     } CALL_CATCH_EXCEPTION();
12968   }
12969
12970 }
12971
12972
12973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
12974   void * jresult ;
12975   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
12976   Dali::TextureSet result;
12977
12978   arg1 = (Dali::Renderer *)jarg1;
12979   {
12980     try {
12981       result = ((Dali::Renderer const *)arg1)->GetTextures();
12982     } CALL_CATCH_EXCEPTION(0);
12983   }
12984
12985   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
12986   return jresult;
12987 }
12988
12989
12990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
12991   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
12992   Dali::Shader *arg2 = 0 ;
12993
12994   arg1 = (Dali::Renderer *)jarg1;
12995   arg2 = (Dali::Shader *)jarg2;
12996   if (!arg2) {
12997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
12998     return ;
12999   }
13000   {
13001     try {
13002       (arg1)->SetShader(*arg2);
13003     } CALL_CATCH_EXCEPTION();
13004   }
13005
13006 }
13007
13008
13009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
13010   void * jresult ;
13011   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
13012   Dali::Shader result;
13013
13014   arg1 = (Dali::Renderer *)jarg1;
13015   {
13016     try {
13017       result = ((Dali::Renderer const *)arg1)->GetShader();
13018     } CALL_CATCH_EXCEPTION(0);
13019   }
13020
13021   jresult = new Dali::Shader((const Dali::Shader &)result);
13022   return jresult;
13023 }
13024
13025
13026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
13027   void * jresult ;
13028   Dali::FrameBuffer::Attachment *result = 0 ;
13029
13030   {
13031     try {
13032       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
13033     } CALL_CATCH_EXCEPTION(0);
13034   }
13035
13036   jresult = (void *)result;
13037   return jresult;
13038 }
13039
13040
13041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
13042   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
13043
13044   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
13045   {
13046     try {
13047       delete arg1;
13048     } CALL_CATCH_EXCEPTION();
13049   }
13050
13051 }
13052
13053
13054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
13055   void * jresult ;
13056   unsigned int arg1 ;
13057   unsigned int arg2 ;
13058   unsigned int arg3 ;
13059   Dali::FrameBuffer result;
13060
13061   arg1 = (unsigned int)jarg1;
13062   arg2 = (unsigned int)jarg2;
13063   arg3 = (unsigned int)jarg3;
13064   {
13065     try {
13066       result = Dali::FrameBuffer::New(arg1,arg2,static_cast<Dali::FrameBuffer::Attachment::Mask>(arg3));
13067     } CALL_CATCH_EXCEPTION(0);
13068   }
13069
13070   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
13071   return jresult;
13072 }
13073
13074
13075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
13076   void * jresult ;
13077   Dali::FrameBuffer *result = 0 ;
13078
13079   {
13080     try {
13081       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
13082     } CALL_CATCH_EXCEPTION(0);
13083   }
13084
13085   jresult = (void *)result;
13086   return jresult;
13087 }
13088
13089
13090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
13091   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
13092
13093   arg1 = (Dali::FrameBuffer *)jarg1;
13094   {
13095     try {
13096       delete arg1;
13097     } CALL_CATCH_EXCEPTION();
13098   }
13099
13100 }
13101
13102
13103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
13104   void * jresult ;
13105   Dali::FrameBuffer *arg1 = 0 ;
13106   Dali::FrameBuffer *result = 0 ;
13107
13108   arg1 = (Dali::FrameBuffer *)jarg1;
13109   if (!arg1) {
13110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
13111     return 0;
13112   }
13113   {
13114     try {
13115       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
13116     } CALL_CATCH_EXCEPTION(0);
13117   }
13118
13119   jresult = (void *)result;
13120   return jresult;
13121 }
13122
13123
13124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
13125   void * jresult ;
13126   Dali::BaseHandle arg1 ;
13127   Dali::BaseHandle *argp1 ;
13128   Dali::FrameBuffer result;
13129
13130   argp1 = (Dali::BaseHandle *)jarg1;
13131   if (!argp1) {
13132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
13133     return 0;
13134   }
13135   arg1 = *argp1;
13136   {
13137     try {
13138       result = Dali::FrameBuffer::DownCast(arg1);
13139     } CALL_CATCH_EXCEPTION(0);
13140   }
13141
13142   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
13143   return jresult;
13144 }
13145
13146
13147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
13148   void * jresult ;
13149   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
13150   Dali::FrameBuffer *arg2 = 0 ;
13151   Dali::FrameBuffer *result = 0 ;
13152
13153   arg1 = (Dali::FrameBuffer *)jarg1;
13154   arg2 = (Dali::FrameBuffer *)jarg2;
13155   if (!arg2) {
13156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
13157     return 0;
13158   }
13159   {
13160     try {
13161       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
13162     } CALL_CATCH_EXCEPTION(0);
13163   }
13164
13165   jresult = (void *)result;
13166   return jresult;
13167 }
13168
13169
13170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
13171   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
13172   Dali::Texture *arg2 = 0 ;
13173
13174   arg1 = (Dali::FrameBuffer *)jarg1;
13175   arg2 = (Dali::Texture *)jarg2;
13176   if (!arg2) {
13177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
13178     return ;
13179   }
13180   {
13181     try {
13182       (arg1)->AttachColorTexture(*arg2);
13183     } CALL_CATCH_EXCEPTION();
13184   }
13185
13186 }
13187
13188
13189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
13190   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
13191   Dali::Texture *arg2 = 0 ;
13192   unsigned int arg3 ;
13193   unsigned int arg4 ;
13194
13195   arg1 = (Dali::FrameBuffer *)jarg1;
13196   arg2 = (Dali::Texture *)jarg2;
13197   if (!arg2) {
13198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
13199     return ;
13200   }
13201   arg3 = (unsigned int)jarg3;
13202   arg4 = (unsigned int)jarg4;
13203   {
13204     try {
13205       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
13206     } CALL_CATCH_EXCEPTION();
13207   }
13208
13209 }
13210
13211
13212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
13213   void * jresult ;
13214   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
13215   Dali::Texture result;
13216
13217   arg1 = (Dali::FrameBuffer *)jarg1;
13218   {
13219     try {
13220       result = (arg1)->GetColorTexture();
13221     } CALL_CATCH_EXCEPTION(0);
13222   }
13223
13224   jresult = new Dali::Texture((const Dali::Texture &)result);
13225   return jresult;
13226 }
13227
13228 SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_FrameBuffer_GenerateUrl(void *jFrameBuffer, int pixelFormat, int width, int height)
13229 {
13230   void *jresult;
13231   Dali::Toolkit::ImageUrl result;
13232   Dali::FrameBuffer *frameBuffer = (Dali::FrameBuffer*)jFrameBuffer;;
13233
13234   if (!frameBuffer)
13235   {
13236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer is null", 0);
13237     return 0;
13238   }
13239   {
13240     try
13241     {
13242       result = Dali::Toolkit::Image::GenerateUrl((const Dali::FrameBuffer&)*frameBuffer, (Pixel::Format)pixelFormat, (uint32_t)width, (uint32_t)height);
13243     }
13244     CALL_CATCH_EXCEPTION(0);
13245   }
13246
13247   jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl &)result);
13248   return jresult;
13249 }
13250
13251
13252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
13253   void * jresult ;
13254   Dali::RenderTaskList *result = 0 ;
13255
13256   {
13257     try {
13258       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
13259     } CALL_CATCH_EXCEPTION(0);
13260   }
13261
13262   jresult = (void *)result;
13263   return jresult;
13264 }
13265
13266
13267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
13268   void * jresult ;
13269   Dali::BaseHandle arg1 ;
13270   Dali::BaseHandle *argp1 ;
13271   Dali::RenderTaskList result;
13272
13273   argp1 = (Dali::BaseHandle *)jarg1;
13274   if (!argp1) {
13275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
13276     return 0;
13277   }
13278   arg1 = *argp1;
13279   {
13280     try {
13281       result = Dali::RenderTaskList::DownCast(arg1);
13282     } CALL_CATCH_EXCEPTION(0);
13283   }
13284
13285   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
13286   return jresult;
13287 }
13288
13289
13290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
13291   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
13292
13293   arg1 = (Dali::RenderTaskList *)jarg1;
13294   {
13295     try {
13296       delete arg1;
13297     } CALL_CATCH_EXCEPTION();
13298   }
13299
13300 }
13301
13302
13303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
13304   void * jresult ;
13305   Dali::RenderTaskList *arg1 = 0 ;
13306   Dali::RenderTaskList *result = 0 ;
13307
13308   arg1 = (Dali::RenderTaskList *)jarg1;
13309   if (!arg1) {
13310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
13311     return 0;
13312   }
13313   {
13314     try {
13315       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
13316     } CALL_CATCH_EXCEPTION(0);
13317   }
13318
13319   jresult = (void *)result;
13320   return jresult;
13321 }
13322
13323
13324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
13325   void * jresult ;
13326   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
13327   Dali::RenderTaskList *arg2 = 0 ;
13328   Dali::RenderTaskList *result = 0 ;
13329
13330   arg1 = (Dali::RenderTaskList *)jarg1;
13331   arg2 = (Dali::RenderTaskList *)jarg2;
13332   if (!arg2) {
13333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
13334     return 0;
13335   }
13336   {
13337     try {
13338       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
13339     } CALL_CATCH_EXCEPTION(0);
13340   }
13341
13342   jresult = (void *)result;
13343   return jresult;
13344 }
13345
13346
13347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
13348   void * jresult ;
13349   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
13350   Dali::RenderTask result;
13351
13352   arg1 = (Dali::RenderTaskList *)jarg1;
13353   {
13354     try {
13355       result = (arg1)->CreateTask();
13356     } CALL_CATCH_EXCEPTION(0);
13357   }
13358
13359   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
13360   return jresult;
13361 }
13362
13363
13364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
13365   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
13366   Dali::RenderTask arg2 ;
13367   Dali::RenderTask *argp2 ;
13368
13369   arg1 = (Dali::RenderTaskList *)jarg1;
13370   argp2 = (Dali::RenderTask *)jarg2;
13371   if (!argp2) {
13372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
13373     return ;
13374   }
13375   arg2 = *argp2;
13376   {
13377     try {
13378       (arg1)->RemoveTask(arg2);
13379     } CALL_CATCH_EXCEPTION();
13380   }
13381
13382 }
13383
13384
13385 //// ===============================================end part 1 =================
13386
13387 //// ========================= part 2 ===============================
13388
13389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
13390   unsigned int jresult ;
13391   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
13392   unsigned int result;
13393
13394   arg1 = (Dali::RenderTaskList *)jarg1;
13395   {
13396     try {
13397       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
13398     } CALL_CATCH_EXCEPTION(0);
13399   }
13400
13401   jresult = result;
13402   return jresult;
13403 }
13404
13405
13406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
13407   void * jresult ;
13408   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
13409   unsigned int arg2 ;
13410   Dali::RenderTask result;
13411
13412   arg1 = (Dali::RenderTaskList *)jarg1;
13413   arg2 = (unsigned int)jarg2;
13414   {
13415     try {
13416       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
13417     } CALL_CATCH_EXCEPTION(0);
13418   }
13419
13420   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
13421   return jresult;
13422 }
13423
13424
13425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
13426   int jresult ;
13427   int result;
13428
13429   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
13430   jresult = (int)result;
13431   return jresult;
13432 }
13433
13434
13435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
13436   int jresult ;
13437   int result;
13438
13439   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
13440   jresult = (int)result;
13441   return jresult;
13442 }
13443
13444
13445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
13446   int jresult ;
13447   int result;
13448
13449   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
13450   jresult = (int)result;
13451   return jresult;
13452 }
13453
13454
13455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
13456   int jresult ;
13457   int result;
13458
13459   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
13460   jresult = (int)result;
13461   return jresult;
13462 }
13463
13464
13465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
13466   void * jresult ;
13467   Dali::RenderTask::Property *result = 0 ;
13468
13469   {
13470     try {
13471       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
13472     } CALL_CATCH_EXCEPTION(0);
13473   }
13474
13475   jresult = (void *)result;
13476   return jresult;
13477 }
13478
13479
13480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
13481   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
13482
13483   arg1 = (Dali::RenderTask::Property *)jarg1;
13484   {
13485     try {
13486       delete arg1;
13487     } CALL_CATCH_EXCEPTION();
13488   }
13489
13490 }
13491
13492
13493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
13494   void * jresult ;
13495   bool (*result)(Dali::Vector2 &) = 0 ;
13496
13497   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
13498   jresult = (void *)result;
13499   return jresult;
13500 }
13501
13502
13503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
13504   void * jresult ;
13505   bool (*result)(Dali::Vector2 &) = 0 ;
13506
13507   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
13508   jresult = (void *)result;
13509   return jresult;
13510 }
13511
13512
13513 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
13514   bool jresult ;
13515   bool result;
13516
13517   result = (bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
13518   jresult = result;
13519   return jresult;
13520 }
13521
13522
13523 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
13524   bool jresult ;
13525   bool result;
13526
13527   result = (bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
13528   jresult = result;
13529   return jresult;
13530 }
13531
13532
13533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
13534   void * jresult ;
13535   Dali::Vector4 *result = 0 ;
13536
13537   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
13538   jresult = (void *)result;
13539   return jresult;
13540 }
13541
13542
13543 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
13544   bool jresult ;
13545   bool result;
13546
13547   result = (bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
13548   jresult = result;
13549   return jresult;
13550 }
13551
13552
13553 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
13554   bool jresult ;
13555   bool result;
13556
13557   result = (bool)Dali::RenderTask::DEFAULT_CULL_MODE;
13558   jresult = result;
13559   return jresult;
13560 }
13561
13562
13563 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
13564   unsigned int jresult ;
13565   unsigned int result;
13566
13567   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
13568   jresult = result;
13569   return jresult;
13570 }
13571
13572
13573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
13574   void * jresult ;
13575   Dali::RenderTask *result = 0 ;
13576
13577   {
13578     try {
13579       result = (Dali::RenderTask *)new Dali::RenderTask();
13580     } CALL_CATCH_EXCEPTION(0);
13581   }
13582
13583   jresult = (void *)result;
13584   return jresult;
13585 }
13586
13587
13588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
13589   void * jresult ;
13590   Dali::BaseHandle arg1 ;
13591   Dali::BaseHandle *argp1 ;
13592   Dali::RenderTask result;
13593
13594   argp1 = (Dali::BaseHandle *)jarg1;
13595   if (!argp1) {
13596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
13597     return 0;
13598   }
13599   arg1 = *argp1;
13600   {
13601     try {
13602       result = Dali::RenderTask::DownCast(arg1);
13603     } CALL_CATCH_EXCEPTION(0);
13604   }
13605
13606   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
13607   return jresult;
13608 }
13609
13610
13611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
13612   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13613
13614   arg1 = (Dali::RenderTask *)jarg1;
13615   {
13616     try {
13617       delete arg1;
13618     } CALL_CATCH_EXCEPTION();
13619   }
13620
13621 }
13622
13623
13624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
13625   void * jresult ;
13626   Dali::RenderTask *arg1 = 0 ;
13627   Dali::RenderTask *result = 0 ;
13628
13629   arg1 = (Dali::RenderTask *)jarg1;
13630   if (!arg1) {
13631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
13632     return 0;
13633   }
13634   {
13635     try {
13636       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
13637     } CALL_CATCH_EXCEPTION(0);
13638   }
13639
13640   jresult = (void *)result;
13641   return jresult;
13642 }
13643
13644
13645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
13646   void * jresult ;
13647   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13648   Dali::RenderTask *arg2 = 0 ;
13649   Dali::RenderTask *result = 0 ;
13650
13651   arg1 = (Dali::RenderTask *)jarg1;
13652   arg2 = (Dali::RenderTask *)jarg2;
13653   if (!arg2) {
13654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
13655     return 0;
13656   }
13657   {
13658     try {
13659       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
13660     } CALL_CATCH_EXCEPTION(0);
13661   }
13662
13663   jresult = (void *)result;
13664   return jresult;
13665 }
13666
13667
13668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
13669   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13670   Dali::Actor arg2 ;
13671   Dali::Actor *argp2 ;
13672
13673   arg1 = (Dali::RenderTask *)jarg1;
13674   argp2 = (Dali::Actor *)jarg2;
13675   if (!argp2) {
13676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
13677     return ;
13678   }
13679   arg2 = *argp2;
13680   {
13681     try {
13682       (arg1)->SetSourceActor(arg2);
13683     } CALL_CATCH_EXCEPTION();
13684   }
13685
13686 }
13687
13688
13689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
13690   void * jresult ;
13691   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13692   Dali::Actor result;
13693
13694   arg1 = (Dali::RenderTask *)jarg1;
13695   {
13696     try {
13697       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
13698     } CALL_CATCH_EXCEPTION(0);
13699   }
13700
13701   jresult = new Dali::Actor((const Dali::Actor &)result);
13702   return jresult;
13703 }
13704
13705
13706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, bool jarg2) {
13707   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13708   bool arg2 ;
13709
13710   arg1 = (Dali::RenderTask *)jarg1;
13711   arg2 = jarg2 ? true : false;
13712   {
13713     try {
13714       (arg1)->SetExclusive(arg2);
13715     } CALL_CATCH_EXCEPTION();
13716   }
13717
13718 }
13719
13720
13721 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
13722   bool jresult ;
13723   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13724   bool result;
13725
13726   arg1 = (Dali::RenderTask *)jarg1;
13727   {
13728     try {
13729       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
13730     } CALL_CATCH_EXCEPTION(0);
13731   }
13732
13733   jresult = result;
13734   return jresult;
13735 }
13736
13737
13738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, bool jarg2) {
13739   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13740   bool arg2 ;
13741
13742   arg1 = (Dali::RenderTask *)jarg1;
13743   arg2 = jarg2 ? true : false;
13744   {
13745     try {
13746       (arg1)->SetInputEnabled(arg2);
13747     } CALL_CATCH_EXCEPTION();
13748   }
13749
13750 }
13751
13752
13753 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
13754   bool jresult ;
13755   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13756   bool result;
13757
13758   arg1 = (Dali::RenderTask *)jarg1;
13759   {
13760     try {
13761       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
13762     } CALL_CATCH_EXCEPTION(0);
13763   }
13764
13765   jresult = result;
13766   return jresult;
13767 }
13768
13769
13770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
13771   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13772   Dali::CameraActor arg2 ;
13773   Dali::CameraActor *argp2 ;
13774
13775   arg1 = (Dali::RenderTask *)jarg1;
13776   argp2 = (Dali::CameraActor *)jarg2;
13777   if (!argp2) {
13778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
13779     return ;
13780   }
13781   arg2 = *argp2;
13782   {
13783     try {
13784       (arg1)->SetCameraActor(arg2);
13785     } CALL_CATCH_EXCEPTION();
13786   }
13787
13788 }
13789
13790
13791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
13792   void * jresult ;
13793   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13794   Dali::CameraActor result;
13795
13796   arg1 = (Dali::RenderTask *)jarg1;
13797   {
13798     try {
13799       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
13800     } CALL_CATCH_EXCEPTION(0);
13801   }
13802
13803   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
13804   return jresult;
13805 }
13806
13807
13808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
13809   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13810   Dali::FrameBuffer arg2 ;
13811   Dali::FrameBuffer *argp2 ;
13812
13813   arg1 = (Dali::RenderTask *)jarg1;
13814   argp2 = (Dali::FrameBuffer *)jarg2;
13815   if (!argp2) {
13816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
13817     return ;
13818   }
13819   arg2 = *argp2;
13820   {
13821     try {
13822       (arg1)->SetFrameBuffer(arg2);
13823     } CALL_CATCH_EXCEPTION();
13824   }
13825
13826 }
13827
13828
13829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
13830   void * jresult ;
13831   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13832   Dali::FrameBuffer result;
13833
13834   arg1 = (Dali::RenderTask *)jarg1;
13835   {
13836     try {
13837       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
13838     } CALL_CATCH_EXCEPTION(0);
13839   }
13840
13841   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
13842   return jresult;
13843 }
13844
13845
13846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
13847   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13848   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
13849
13850   arg1 = (Dali::RenderTask *)jarg1;
13851   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
13852   {
13853     try {
13854       (arg1)->SetScreenToFrameBufferFunction(arg2);
13855     } CALL_CATCH_EXCEPTION();
13856   }
13857
13858 }
13859
13860
13861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
13862   void * jresult ;
13863   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13864   Dali::RenderTask::ScreenToFrameBufferFunction result;
13865
13866   arg1 = (Dali::RenderTask *)jarg1;
13867   {
13868     try {
13869       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
13870     } CALL_CATCH_EXCEPTION(0);
13871   }
13872
13873   jresult = (void *)result;
13874   return jresult;
13875 }
13876
13877
13878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
13879   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13880   Dali::Actor arg2 ;
13881   Dali::Actor *argp2 ;
13882
13883   arg1 = (Dali::RenderTask *)jarg1;
13884   argp2 = (Dali::Actor *)jarg2;
13885   if (!argp2) {
13886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
13887     return ;
13888   }
13889   arg2 = *argp2;
13890   {
13891     try {
13892       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
13893     } CALL_CATCH_EXCEPTION();
13894   }
13895
13896 }
13897
13898
13899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
13900   void * jresult ;
13901   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13902   Dali::Actor result;
13903
13904   arg1 = (Dali::RenderTask *)jarg1;
13905   {
13906     try {
13907       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
13908     } CALL_CATCH_EXCEPTION(0);
13909   }
13910
13911   jresult = new Dali::Actor((const Dali::Actor &)result);
13912   return jresult;
13913 }
13914
13915
13916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
13917   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13918   Dali::Vector2 arg2 ;
13919   Dali::Vector2 *argp2 ;
13920
13921   arg1 = (Dali::RenderTask *)jarg1;
13922   argp2 = (Dali::Vector2 *)jarg2;
13923   if (!argp2) {
13924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
13925     return ;
13926   }
13927   arg2 = *argp2;
13928   {
13929     try {
13930       (arg1)->SetViewportPosition(arg2);
13931     } CALL_CATCH_EXCEPTION();
13932   }
13933
13934 }
13935
13936
13937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
13938   void * jresult ;
13939   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13940   Dali::Vector2 result;
13941
13942   arg1 = (Dali::RenderTask *)jarg1;
13943   {
13944     try {
13945       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
13946     } CALL_CATCH_EXCEPTION(0);
13947   }
13948
13949   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
13950   return jresult;
13951 }
13952
13953
13954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
13955   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13956   Dali::Vector2 arg2 ;
13957   Dali::Vector2 *argp2 ;
13958
13959   arg1 = (Dali::RenderTask *)jarg1;
13960   argp2 = (Dali::Vector2 *)jarg2;
13961   if (!argp2) {
13962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
13963     return ;
13964   }
13965   arg2 = *argp2;
13966   {
13967     try {
13968       (arg1)->SetViewportSize(arg2);
13969     } CALL_CATCH_EXCEPTION();
13970   }
13971
13972 }
13973
13974
13975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
13976   void * jresult ;
13977   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13978   Dali::Vector2 result;
13979
13980   arg1 = (Dali::RenderTask *)jarg1;
13981   {
13982     try {
13983       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
13984     } CALL_CATCH_EXCEPTION(0);
13985   }
13986
13987   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
13988   return jresult;
13989 }
13990
13991
13992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
13993   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13994   Dali::Viewport arg2 ;
13995   Dali::Viewport *argp2 ;
13996
13997   arg1 = (Dali::RenderTask *)jarg1;
13998   argp2 = (Dali::Viewport *)jarg2;
13999   if (!argp2) {
14000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
14001     return ;
14002   }
14003   arg2 = *argp2;
14004   {
14005     try {
14006       (arg1)->SetViewport(arg2);
14007     } CALL_CATCH_EXCEPTION();
14008   }
14009
14010 }
14011
14012
14013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
14014   void * jresult ;
14015   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
14016   Dali::Viewport result;
14017
14018   arg1 = (Dali::RenderTask *)jarg1;
14019   {
14020     try {
14021       result = ((Dali::RenderTask const *)arg1)->GetViewport();
14022     } CALL_CATCH_EXCEPTION(0);
14023   }
14024
14025   jresult = new Dali::Viewport((const Dali::Viewport &)result);
14026   return jresult;
14027 }
14028
14029
14030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
14031   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
14032   Dali::Vector4 *arg2 = 0 ;
14033
14034   arg1 = (Dali::RenderTask *)jarg1;
14035   arg2 = (Dali::Vector4 *)jarg2;
14036   if (!arg2) {
14037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
14038     return ;
14039   }
14040   {
14041     try {
14042       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
14043     } CALL_CATCH_EXCEPTION();
14044   }
14045
14046 }
14047
14048
14049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
14050   void * jresult ;
14051   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
14052   Dali::Vector4 result;
14053
14054   arg1 = (Dali::RenderTask *)jarg1;
14055   {
14056     try {
14057       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
14058     } CALL_CATCH_EXCEPTION(0);
14059   }
14060
14061   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14062   return jresult;
14063 }
14064
14065
14066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, bool jarg2) {
14067   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
14068   bool arg2 ;
14069
14070   arg1 = (Dali::RenderTask *)jarg1;
14071   arg2 = jarg2 ? true : false;
14072   {
14073     try {
14074       (arg1)->SetClearEnabled(arg2);
14075     } CALL_CATCH_EXCEPTION();
14076   }
14077
14078 }
14079
14080
14081 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
14082   bool jresult ;
14083   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
14084   bool result;
14085
14086   arg1 = (Dali::RenderTask *)jarg1;
14087   {
14088     try {
14089       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
14090     } CALL_CATCH_EXCEPTION(0);
14091   }
14092
14093   jresult = result;
14094   return jresult;
14095 }
14096
14097
14098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, bool jarg2) {
14099   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
14100   bool arg2 ;
14101
14102   arg1 = (Dali::RenderTask *)jarg1;
14103   arg2 = jarg2 ? true : false;
14104   {
14105     try {
14106       (arg1)->SetCullMode(arg2);
14107     } CALL_CATCH_EXCEPTION();
14108   }
14109
14110 }
14111
14112
14113 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
14114   bool jresult ;
14115   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
14116   bool result;
14117
14118   arg1 = (Dali::RenderTask *)jarg1;
14119   {
14120     try {
14121       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
14122     } CALL_CATCH_EXCEPTION(0);
14123   }
14124
14125   jresult = result;
14126   return jresult;
14127 }
14128
14129
14130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
14131   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
14132   unsigned int arg2 ;
14133
14134   arg1 = (Dali::RenderTask *)jarg1;
14135   arg2 = (unsigned int)jarg2;
14136   {
14137     try {
14138       (arg1)->SetRefreshRate(arg2);
14139     } CALL_CATCH_EXCEPTION();
14140   }
14141
14142 }
14143
14144
14145 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
14146   unsigned int jresult ;
14147   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
14148   unsigned int result;
14149
14150   arg1 = (Dali::RenderTask *)jarg1;
14151   {
14152     try {
14153       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
14154     } CALL_CATCH_EXCEPTION(0);
14155   }
14156
14157   jresult = result;
14158   return jresult;
14159 }
14160
14161
14162 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
14163   bool jresult ;
14164   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
14165   Dali::Vector3 *arg2 = 0 ;
14166   float *arg3 = 0 ;
14167   float *arg4 = 0 ;
14168   bool result;
14169
14170   arg1 = (Dali::RenderTask *)jarg1;
14171   arg2 = (Dali::Vector3 *)jarg2;
14172   if (!arg2) {
14173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14174     return 0;
14175   }
14176   arg3 = (float *)jarg3;
14177   arg4 = (float *)jarg4;
14178   {
14179     try {
14180       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
14181     } CALL_CATCH_EXCEPTION(0);
14182   }
14183
14184   jresult = result;
14185   return jresult;
14186 }
14187
14188
14189 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
14190   bool jresult ;
14191   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
14192   Dali::Actor arg2 ;
14193   float arg3 ;
14194   float arg4 ;
14195   float *arg5 = 0 ;
14196   float *arg6 = 0 ;
14197   Dali::Actor *argp2 ;
14198   bool result;
14199
14200   arg1 = (Dali::RenderTask *)jarg1;
14201   argp2 = (Dali::Actor *)jarg2;
14202   if (!argp2) {
14203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
14204     return 0;
14205   }
14206   arg2 = *argp2;
14207   arg3 = (float)jarg3;
14208   arg4 = (float)jarg4;
14209   arg5 = (float *)jarg5;
14210   arg6 = (float *)jarg6;
14211   {
14212     try {
14213       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
14214     } CALL_CATCH_EXCEPTION(0);
14215   }
14216
14217   jresult = result;
14218   return jresult;
14219 }
14220
14221
14222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
14223   void * jresult ;
14224   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
14225   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
14226
14227   arg1 = (Dali::RenderTask *)jarg1;
14228   {
14229     try {
14230       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
14231     } CALL_CATCH_EXCEPTION(0);
14232   }
14233
14234   jresult = (void *)result;
14235   return jresult;
14236 }
14237
14238
14239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
14240   void * jresult ;
14241   int arg1 ;
14242   Dali::PointState::Type arg2 ;
14243   float arg3 ;
14244   float arg4 ;
14245   Dali::TouchPoint *result = 0 ;
14246
14247   arg1 = (int)jarg1;
14248   arg2 = (Dali::PointState::Type)jarg2;
14249   arg3 = (float)jarg3;
14250   arg4 = (float)jarg4;
14251   {
14252     try {
14253       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
14254     } CALL_CATCH_EXCEPTION(0);
14255   }
14256
14257   jresult = (void *)result;
14258   return jresult;
14259 }
14260
14261
14262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
14263   void * jresult ;
14264   int arg1 ;
14265   Dali::PointState::Type arg2 ;
14266   float arg3 ;
14267   float arg4 ;
14268   float arg5 ;
14269   float arg6 ;
14270   Dali::TouchPoint *result = 0 ;
14271
14272   arg1 = (int)jarg1;
14273   arg2 = (Dali::PointState::Type)jarg2;
14274   arg3 = (float)jarg3;
14275   arg4 = (float)jarg4;
14276   arg5 = (float)jarg5;
14277   arg6 = (float)jarg6;
14278   {
14279     try {
14280       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
14281     } CALL_CATCH_EXCEPTION(0);
14282   }
14283
14284   jresult = (void *)result;
14285   return jresult;
14286 }
14287
14288
14289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
14290   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
14291
14292   arg1 = (Dali::TouchPoint *)jarg1;
14293   {
14294     try {
14295       delete arg1;
14296     } CALL_CATCH_EXCEPTION();
14297   }
14298
14299 }
14300
14301
14302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
14303   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
14304   int arg2 ;
14305
14306   arg1 = (Dali::TouchPoint *)jarg1;
14307   arg2 = (int)jarg2;
14308   if (arg1) (arg1)->deviceId = arg2;
14309 }
14310
14311
14312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
14313   int jresult ;
14314   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
14315   int result;
14316
14317   arg1 = (Dali::TouchPoint *)jarg1;
14318   result = (int) ((arg1)->deviceId);
14319   jresult = result;
14320   return jresult;
14321 }
14322
14323
14324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
14325   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
14326   Dali::PointState::Type arg2 ;
14327
14328   arg1 = (Dali::TouchPoint *)jarg1;
14329   arg2 = (Dali::PointState::Type)jarg2;
14330   if (arg1) (arg1)->state = arg2;
14331 }
14332
14333
14334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
14335   int jresult ;
14336   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
14337   Dali::PointState::Type result;
14338
14339   arg1 = (Dali::TouchPoint *)jarg1;
14340   result = (Dali::PointState::Type) ((arg1)->state);
14341   jresult = (int)result;
14342   return jresult;
14343 }
14344
14345
14346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
14347   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
14348   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
14349
14350   arg1 = (Dali::TouchPoint *)jarg1;
14351   arg2 = (Dali::Actor *)jarg2;
14352   if (arg1) (arg1)->hitActor = *arg2;
14353 }
14354
14355
14356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
14357   void * jresult ;
14358   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
14359   Dali::Actor *result = 0 ;
14360
14361   arg1 = (Dali::TouchPoint *)jarg1;
14362   result = (Dali::Actor *)& ((arg1)->hitActor);
14363   jresult = (void *)result;
14364   return jresult;
14365 }
14366
14367
14368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
14369   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
14370   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
14371
14372   arg1 = (Dali::TouchPoint *)jarg1;
14373   arg2 = (Dali::Vector2 *)jarg2;
14374   if (arg1) (arg1)->local = *arg2;
14375 }
14376
14377
14378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
14379   void * jresult ;
14380   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
14381   Dali::Vector2 *result = 0 ;
14382
14383   arg1 = (Dali::TouchPoint *)jarg1;
14384   result = (Dali::Vector2 *)& ((arg1)->local);
14385   jresult = (void *)result;
14386   return jresult;
14387 }
14388
14389
14390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
14391   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
14392   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
14393
14394   arg1 = (Dali::TouchPoint *)jarg1;
14395   arg2 = (Dali::Vector2 *)jarg2;
14396   if (arg1) (arg1)->screen = *arg2;
14397 }
14398
14399
14400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
14401   void * jresult ;
14402   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
14403   Dali::Vector2 *result = 0 ;
14404
14405   arg1 = (Dali::TouchPoint *)jarg1;
14406   result = (Dali::Vector2 *)& ((arg1)->screen);
14407   jresult = (void *)result;
14408   return jresult;
14409 }
14410
14411
14412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
14413   void * jresult ;
14414   Dali::TouchEvent *result = 0 ;
14415
14416   {
14417     try {
14418       result = (Dali::TouchEvent *)new Dali::TouchEvent();
14419     } CALL_CATCH_EXCEPTION(0);
14420   }
14421
14422   jresult = (void *)result;
14423   return jresult;
14424 }
14425
14426
14427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
14428   void * jresult ;
14429   Dali::TouchEvent *arg1 = 0 ;
14430   Dali::TouchEvent *result = 0 ;
14431
14432   arg1 = (Dali::TouchEvent *)jarg1;
14433   if (!arg1) {
14434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
14435     return 0;
14436   }
14437   {
14438     try {
14439       result = (Dali::TouchEvent *)new Dali::TouchEvent((Dali::TouchEvent const &)*arg1);
14440     } CALL_CATCH_EXCEPTION(0);
14441   }
14442
14443   jresult = (void *)result;
14444   return jresult;
14445 }
14446
14447
14448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
14449   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14450
14451   arg1 = (Dali::TouchEvent *)jarg1;
14452   {
14453     try {
14454       delete arg1;
14455     } CALL_CATCH_EXCEPTION();
14456   }
14457
14458 }
14459
14460
14461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
14462   void * jresult ;
14463   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14464   Dali::TouchEvent *arg2 = 0 ;
14465   Dali::TouchEvent *result = 0 ;
14466
14467   arg1 = (Dali::TouchEvent *)jarg1;
14468   arg2 = (Dali::TouchEvent *)jarg2;
14469   if (!arg2) {
14470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
14471     return 0;
14472   }
14473   {
14474     try {
14475       result = (Dali::TouchEvent *) &(arg1)->operator =((Dali::TouchEvent const &)*arg2);
14476     } CALL_CATCH_EXCEPTION(0);
14477   }
14478
14479   jresult = (void *)result;
14480   return jresult;
14481 }
14482
14483
14484 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
14485   unsigned long jresult ;
14486   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14487   unsigned long result;
14488
14489   arg1 = (Dali::TouchEvent *)jarg1;
14490   {
14491     try {
14492       result = (unsigned long)((Dali::TouchEvent const *)arg1)->GetTime();
14493     } CALL_CATCH_EXCEPTION(0);
14494   }
14495
14496   jresult = (unsigned long)result;
14497   return jresult;
14498 }
14499
14500
14501 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
14502   unsigned long jresult ;
14503   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14504   std::size_t result;
14505
14506   arg1 = (Dali::TouchEvent *)jarg1;
14507   {
14508     try {
14509       result = ((Dali::TouchEvent const *)arg1)->GetPointCount();
14510     } CALL_CATCH_EXCEPTION(0);
14511   }
14512
14513   jresult = (unsigned long)result;
14514   return jresult;
14515 }
14516
14517
14518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
14519   int jresult ;
14520   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14521   std::size_t arg2 ;
14522   int32_t result;
14523
14524   arg1 = (Dali::TouchEvent *)jarg1;
14525   arg2 = (std::size_t)jarg2;
14526   {
14527     try {
14528       result = ((Dali::TouchEvent const *)arg1)->GetDeviceId(arg2);
14529     } CALL_CATCH_EXCEPTION(0);
14530   }
14531
14532   jresult = result;
14533   return jresult;
14534 }
14535
14536
14537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
14538   int jresult ;
14539   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14540   std::size_t arg2 ;
14541   Dali::PointState::Type result;
14542
14543   arg1 = (Dali::TouchEvent *)jarg1;
14544   arg2 = (std::size_t)jarg2;
14545   {
14546     try {
14547       result = (Dali::PointState::Type)((Dali::TouchEvent const *)arg1)->GetState(arg2);
14548     } CALL_CATCH_EXCEPTION(0);
14549   }
14550
14551   jresult = (int)result;
14552   return jresult;
14553 }
14554
14555
14556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
14557   void * jresult ;
14558   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14559   std::size_t arg2 ;
14560   Dali::Actor result;
14561
14562   arg1 = (Dali::TouchEvent *)jarg1;
14563   arg2 = (std::size_t)jarg2;
14564   {
14565     try {
14566       result = ((Dali::TouchEvent const *)arg1)->GetHitActor(arg2);
14567     } CALL_CATCH_EXCEPTION(0);
14568   }
14569
14570   jresult = new Dali::Actor((const Dali::Actor &)result);
14571   return jresult;
14572 }
14573
14574
14575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
14576   void * jresult ;
14577   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14578   std::size_t arg2 ;
14579   Dali::Vector2 *result = 0 ;
14580
14581   arg1 = (Dali::TouchEvent *)jarg1;
14582   arg2 = (std::size_t)jarg2;
14583   {
14584     try {
14585       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetLocalPosition(arg2);
14586     } CALL_CATCH_EXCEPTION(0);
14587   }
14588
14589   jresult = (void *)result;
14590   return jresult;
14591 }
14592
14593
14594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
14595   void * jresult ;
14596   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14597   std::size_t arg2 ;
14598   Dali::Vector2 *result = 0 ;
14599
14600   arg1 = (Dali::TouchEvent *)jarg1;
14601   arg2 = (std::size_t)jarg2;
14602   {
14603     try {
14604       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetScreenPosition(arg2);
14605     } CALL_CATCH_EXCEPTION(0);
14606   }
14607
14608   jresult = (void *)result;
14609   return jresult;
14610 }
14611
14612
14613 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
14614   float jresult ;
14615   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14616   std::size_t arg2 ;
14617   float result;
14618
14619   arg1 = (Dali::TouchEvent *)jarg1;
14620   arg2 = (std::size_t)jarg2;
14621   {
14622     try {
14623       result = (float)((Dali::TouchEvent const *)arg1)->GetRadius(arg2);
14624     } CALL_CATCH_EXCEPTION(0);
14625   }
14626
14627   jresult = result;
14628   return jresult;
14629 }
14630
14631
14632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
14633   void * jresult ;
14634   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14635   std::size_t arg2 ;
14636   Dali::Vector2 *result = 0 ;
14637
14638   arg1 = (Dali::TouchEvent *)jarg1;
14639   arg2 = (std::size_t)jarg2;
14640   {
14641     try {
14642       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetEllipseRadius(arg2);
14643     } CALL_CATCH_EXCEPTION(0);
14644   }
14645
14646   jresult = (void *)result;
14647   return jresult;
14648 }
14649
14650
14651 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
14652   float jresult ;
14653   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14654   std::size_t arg2 ;
14655   float result;
14656
14657   arg1 = (Dali::TouchEvent *)jarg1;
14658   arg2 = (std::size_t)jarg2;
14659   {
14660     try {
14661       result = (float)((Dali::TouchEvent const *)arg1)->GetPressure(arg2);
14662     } CALL_CATCH_EXCEPTION(0);
14663   }
14664
14665   jresult = result;
14666   return jresult;
14667 }
14668
14669
14670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
14671   void * jresult ;
14672   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14673   std::size_t arg2 ;
14674   Dali::Degree result;
14675
14676   arg1 = (Dali::TouchEvent *)jarg1;
14677   arg2 = (std::size_t)jarg2;
14678   {
14679     try {
14680       result = ((Dali::TouchEvent const *)arg1)->GetAngle(arg2);
14681     } CALL_CATCH_EXCEPTION(0);
14682   }
14683
14684   jresult = new Dali::Degree((const Dali::Degree &)result);
14685   return jresult;
14686 }
14687
14688
14689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceClass(void * jarg1, unsigned long jarg2) {
14690   int jresult ;
14691   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14692   std::size_t arg2 ;
14693   Dali::Device::Class::Type result;
14694
14695   arg1 = (Dali::TouchEvent *)jarg1;
14696   arg2 = (std::size_t)jarg2;
14697   {
14698     try {
14699       result = ((Dali::TouchEvent const *)arg1)->GetDeviceClass(arg2);
14700     } CALL_CATCH_EXCEPTION(0);
14701   }
14702
14703   jresult = (int)result;
14704   return jresult;
14705 }
14706
14707
14708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceSubclass(void * jarg1, unsigned long jarg2) {
14709   int jresult ;
14710   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14711   std::size_t arg2 ;
14712   Dali::Device::Subclass::Type result;
14713
14714   arg1 = (Dali::TouchEvent *)jarg1;
14715   arg2 = (std::size_t)jarg2;
14716   {
14717     try {
14718       result = ((Dali::TouchEvent const *)arg1)->GetDeviceSubclass(arg2);
14719     } CALL_CATCH_EXCEPTION(0);
14720   }
14721
14722   jresult = (int)result;
14723   return jresult;
14724 }
14725
14726
14727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
14728   int jresult ;
14729   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14730   std::size_t arg2 ;
14731   Dali::MouseButton::Type result;
14732
14733   arg1 = (Dali::TouchEvent *)jarg1;
14734   arg2 = (std::size_t)jarg2;
14735   {
14736     try {
14737       result = ((Dali::TouchEvent const *)arg1)->GetMouseButton(arg2);
14738     } CALL_CATCH_EXCEPTION(0);
14739   }
14740
14741   jresult = static_cast< int >(result);
14742   return jresult;
14743 }
14744
14745
14746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
14747   void * jresult ;
14748   Dali::GestureDetector *result = 0 ;
14749
14750   {
14751     try {
14752       result = (Dali::GestureDetector *)new Dali::GestureDetector();
14753     } CALL_CATCH_EXCEPTION(0);
14754   }
14755
14756   jresult = (void *)result;
14757   return jresult;
14758 }
14759
14760
14761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
14762   void * jresult ;
14763   Dali::BaseHandle arg1 ;
14764   Dali::BaseHandle *argp1 ;
14765   Dali::GestureDetector result;
14766
14767   argp1 = (Dali::BaseHandle *)jarg1;
14768   if (!argp1) {
14769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
14770     return 0;
14771   }
14772   arg1 = *argp1;
14773   {
14774     try {
14775       result = Dali::GestureDetector::DownCast(arg1);
14776     } CALL_CATCH_EXCEPTION(0);
14777   }
14778
14779   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
14780   return jresult;
14781 }
14782
14783
14784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
14785   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
14786
14787   arg1 = (Dali::GestureDetector *)jarg1;
14788   {
14789     try {
14790       delete arg1;
14791     } CALL_CATCH_EXCEPTION();
14792   }
14793
14794 }
14795
14796
14797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
14798   void * jresult ;
14799   Dali::GestureDetector *arg1 = 0 ;
14800   Dali::GestureDetector *result = 0 ;
14801
14802   arg1 = (Dali::GestureDetector *)jarg1;
14803   if (!arg1) {
14804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
14805     return 0;
14806   }
14807   {
14808     try {
14809       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
14810     } CALL_CATCH_EXCEPTION(0);
14811   }
14812
14813   jresult = (void *)result;
14814   return jresult;
14815 }
14816
14817
14818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
14819   void * jresult ;
14820   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
14821   Dali::GestureDetector *arg2 = 0 ;
14822   Dali::GestureDetector *result = 0 ;
14823
14824   arg1 = (Dali::GestureDetector *)jarg1;
14825   arg2 = (Dali::GestureDetector *)jarg2;
14826   if (!arg2) {
14827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
14828     return 0;
14829   }
14830   {
14831     try {
14832       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
14833     } CALL_CATCH_EXCEPTION(0);
14834   }
14835
14836   jresult = (void *)result;
14837   return jresult;
14838 }
14839
14840
14841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
14842   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
14843   Dali::Actor arg2 ;
14844   Dali::Actor *argp2 ;
14845
14846   arg1 = (Dali::GestureDetector *)jarg1;
14847   argp2 = (Dali::Actor *)jarg2;
14848   if (!argp2) {
14849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
14850     return ;
14851   }
14852   arg2 = *argp2;
14853   {
14854     try {
14855       (arg1)->Attach(arg2);
14856     } CALL_CATCH_EXCEPTION();
14857   }
14858
14859 }
14860
14861
14862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
14863   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
14864   Dali::Actor arg2 ;
14865   Dali::Actor *argp2 ;
14866
14867   arg1 = (Dali::GestureDetector *)jarg1;
14868   argp2 = (Dali::Actor *)jarg2;
14869   if (!argp2) {
14870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
14871     return ;
14872   }
14873   arg2 = *argp2;
14874   {
14875     try {
14876       (arg1)->Detach(arg2);
14877     } CALL_CATCH_EXCEPTION();
14878   }
14879
14880 }
14881
14882
14883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
14884   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
14885
14886   arg1 = (Dali::GestureDetector *)jarg1;
14887   {
14888     try {
14889       (arg1)->DetachAll();
14890     } CALL_CATCH_EXCEPTION();
14891   }
14892
14893 }
14894
14895
14896 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
14897   unsigned long jresult ;
14898   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
14899   size_t result;
14900
14901   arg1 = (Dali::GestureDetector *)jarg1;
14902   {
14903     try {
14904       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
14905     } CALL_CATCH_EXCEPTION(0);
14906   }
14907
14908   jresult = (unsigned long)result;
14909   return jresult;
14910 }
14911
14912
14913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
14914   void * jresult ;
14915   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
14916   size_t arg2 ;
14917   Dali::Actor result;
14918
14919   arg1 = (Dali::GestureDetector *)jarg1;
14920   arg2 = (size_t)jarg2;
14921   {
14922     try {
14923       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
14924     } CALL_CATCH_EXCEPTION(0);
14925   }
14926
14927   jresult = new Dali::Actor((const Dali::Actor &)result);
14928   return jresult;
14929 }
14930
14931 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GestureDetector_FeedTouch(void * jdetector, void * jactor, void * jtouch) {
14932   bool result = false;
14933   Dali::GestureDetector *detector = (Dali::GestureDetector *)jdetector;
14934   Dali::Actor *actor = (Dali::Actor *)jactor;
14935   Dali::TouchEvent *touchEvent = (Dali::TouchEvent *)jtouch;
14936
14937   {
14938     try {
14939       result = ((Dali::GestureDetector *)detector)->FeedTouch(*actor, *touchEvent);
14940     } CALL_CATCH_EXCEPTION(0);
14941   }
14942
14943   return result;
14944 }
14945
14946
14947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
14948   void * jresult ;
14949   Dali::Gesture *arg1 = 0 ;
14950   Dali::Gesture *result = 0 ;
14951
14952   arg1 = (Dali::Gesture *)jarg1;
14953   if (!arg1) {
14954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
14955     return 0;
14956   }
14957   {
14958     try {
14959       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
14960     } CALL_CATCH_EXCEPTION(0);
14961   }
14962
14963   jresult = (void *)result;
14964   return jresult;
14965 }
14966
14967
14968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
14969   void * jresult ;
14970   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
14971   Dali::Gesture *arg2 = 0 ;
14972   Dali::Gesture *result = 0 ;
14973
14974   arg1 = (Dali::Gesture *)jarg1;
14975   arg2 = (Dali::Gesture *)jarg2;
14976   if (!arg2) {
14977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
14978     return 0;
14979   }
14980   {
14981     try {
14982       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
14983     } CALL_CATCH_EXCEPTION(0);
14984   }
14985
14986   jresult = (void *)result;
14987   return jresult;
14988 }
14989
14990
14991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
14992   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
14993
14994   arg1 = (Dali::Gesture *)jarg1;
14995   {
14996     try {
14997       delete arg1;
14998     } CALL_CATCH_EXCEPTION();
14999   }
15000
15001 }
15002
15003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
15004   int jresult ;
15005   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
15006   Dali::GestureType::Value result;
15007
15008   arg1 = (Dali::Gesture *)jarg1;
15009   result = (Dali::GestureType::Value) ((arg1)->GetType());
15010   jresult = (int)result;
15011   return jresult;
15012 }
15013
15014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
15015   int jresult ;
15016   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
15017   Dali::GestureState result;
15018
15019   arg1 = (Dali::Gesture *)jarg1;
15020   result = (Dali::GestureState) ((arg1)->GetState());
15021   jresult = (int)result;
15022   return jresult;
15023 }
15024
15025 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
15026   unsigned int jresult ;
15027   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
15028   unsigned int result;
15029
15030   arg1 = (Dali::Gesture *)jarg1;
15031   result = (unsigned int) ((arg1)->GetTime());
15032   jresult = result;
15033   return jresult;
15034 }
15035
15036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_sourceType_get(void * gesture) {
15037   int jresult ;
15038   Dali::Gesture *jGesture = (Dali::Gesture *) gesture;
15039   Dali::GestureSourceType result;
15040
15041   if (!jGesture) {
15042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
15043     return 0;
15044   }
15045   {
15046     try {
15047       result = (Dali::GestureSourceType)jGesture->GetSourceType();
15048     } CALL_CATCH_EXCEPTION(0);
15049   }
15050
15051   jresult = (int)result;
15052   return jresult;
15053 }
15054
15055
15056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_sourceData_get(void * gesture) {
15057   int jresult ;
15058   Dali::Gesture *jGesture = (Dali::Gesture *) gesture;
15059   Dali::GestureSourceData result;
15060
15061   if (!jGesture) {
15062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::gesture const & type is null", 0);
15063     return 0;
15064   }
15065   {
15066     try {
15067       result = (Dali::GestureSourceData)jGesture->GetSourceData();
15068     } CALL_CATCH_EXCEPTION(0);
15069   }
15070
15071   jresult = (int)result;
15072   return jresult;
15073 }
15074
15075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
15076   void * jresult ;
15077   Dali::HoverEvent *result = 0 ;
15078
15079   {
15080     try {
15081       result = (Dali::HoverEvent *)new Dali::HoverEvent();
15082     } CALL_CATCH_EXCEPTION(0);
15083   }
15084
15085   jresult = (void *)result;
15086   return jresult;
15087 }
15088
15089
15090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(void * jarg1) {
15091   void * jresult ;
15092   Dali::HoverEvent *arg1 = 0 ;
15093   Dali::HoverEvent *result = 0 ;
15094
15095   arg1 = (Dali::HoverEvent *)jarg1;
15096   if (!arg1) {
15097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
15098     return 0;
15099   }
15100   {
15101     try {
15102       result = (Dali::HoverEvent *)new Dali::HoverEvent((Dali::HoverEvent const &)*arg1);
15103     } CALL_CATCH_EXCEPTION(0);
15104   }
15105
15106   jresult = (void *)result;
15107   return jresult;
15108 }
15109
15110
15111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
15112   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
15113
15114   arg1 = (Dali::HoverEvent *)jarg1;
15115   {
15116     try {
15117       delete arg1;
15118     } CALL_CATCH_EXCEPTION();
15119   }
15120
15121 }
15122
15123
15124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_Assign(void * jarg1, void * jarg2) {
15125   void * jresult ;
15126   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
15127   Dali::HoverEvent *arg2 = 0 ;
15128   Dali::HoverEvent *result = 0 ;
15129
15130   arg1 = (Dali::HoverEvent *)jarg1;
15131   arg2 = (Dali::HoverEvent *)jarg2;
15132   if (!arg2) {
15133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
15134     return 0;
15135   }
15136   {
15137     try {
15138       result = (Dali::HoverEvent *) &(arg1)->operator =((Dali::HoverEvent const &)*arg2);
15139     } catch (std::out_of_range& e) {
15140       {
15141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15142       };
15143     } catch (std::exception& e) {
15144       {
15145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15146       };
15147     } catch (Dali::DaliException e) {
15148       {
15149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15150       };
15151     } catch (...) {
15152       {
15153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15154       };
15155     }
15156   }
15157
15158   jresult = (void *)result;
15159   return jresult;
15160 }
15161
15162
15163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_New(unsigned int jarg1) {
15164   void * jresult ;
15165   unsigned int arg1 ;
15166   Dali::HoverEvent result;
15167
15168   arg1 = (unsigned int)jarg1;
15169   {
15170     try {
15171       result = DevelHoverEvent::New(arg1);
15172     } CALL_CATCH_EXCEPTION(0);
15173   }
15174
15175   jresult = new Dali::HoverEvent((const Dali::HoverEvent &)result);
15176   return jresult;
15177 }
15178
15179
15180 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetTime(void * jarg1) {
15181   unsigned long jresult ;
15182   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
15183   unsigned long result;
15184
15185   arg1 = (Dali::HoverEvent *)jarg1;
15186   {
15187     try {
15188       result = (unsigned long)((Dali::HoverEvent const *)arg1)->GetTime();
15189     } catch (std::out_of_range& e) {
15190       {
15191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15192       };
15193     } catch (std::exception& e) {
15194       {
15195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15196       };
15197     } catch (Dali::DaliException e) {
15198       {
15199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15200       };
15201     } catch (...) {
15202       {
15203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15204       };
15205     }
15206   }
15207
15208   jresult = (unsigned long)result;
15209   return jresult;
15210 }
15211
15212
15213 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
15214   unsigned long jresult ;
15215   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
15216   std::size_t result;
15217
15218   arg1 = (Dali::HoverEvent *)jarg1;
15219   {
15220     try {
15221       result = ((Dali::HoverEvent const *)arg1)->GetPointCount();
15222     } catch (std::out_of_range& e) {
15223       {
15224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15225       };
15226     } catch (std::exception& e) {
15227       {
15228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15229       };
15230     } catch (Dali::DaliException e) {
15231       {
15232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15233       };
15234     } catch (...) {
15235       {
15236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15237       };
15238     }
15239   }
15240
15241   jresult = (unsigned long)result;
15242   return jresult;
15243 }
15244
15245
15246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetDeviceId(void * jarg1, unsigned long jarg2) {
15247   int jresult ;
15248   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
15249   std::size_t arg2 ;
15250   int32_t result;
15251
15252   arg1 = (Dali::HoverEvent *)jarg1;
15253   arg2 = (std::size_t)jarg2;
15254   {
15255     try {
15256       result = ((Dali::HoverEvent const *)arg1)->GetDeviceId(arg2);
15257     } catch (std::out_of_range& e) {
15258       {
15259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15260       };
15261     } catch (std::exception& e) {
15262       {
15263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15264       };
15265     } catch (Dali::DaliException e) {
15266       {
15267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15268       };
15269     } catch (...) {
15270       {
15271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15272       };
15273     }
15274   }
15275
15276   jresult = result;
15277   return jresult;
15278 }
15279
15280
15281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetState(void * jarg1, unsigned long jarg2) {
15282   int jresult ;
15283   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
15284   std::size_t arg2 ;
15285   Dali::PointState::Type result;
15286
15287   arg1 = (Dali::HoverEvent *)jarg1;
15288   arg2 = (std::size_t)jarg2;
15289   {
15290     try {
15291       result = (Dali::PointState::Type)((Dali::HoverEvent const *)arg1)->GetState(arg2);
15292     } CALL_CATCH_EXCEPTION(0);
15293   }
15294
15295   jresult = (int)result;
15296   return jresult;
15297 }
15298
15299
15300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetHitActor(void * jarg1, unsigned long jarg2) {
15301   void * jresult ;
15302   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
15303   std::size_t arg2 ;
15304   Dali::Actor result;
15305
15306   arg1 = (Dali::HoverEvent *)jarg1;
15307   arg2 = (std::size_t)jarg2;
15308   {
15309     try {
15310       result = ((Dali::HoverEvent const *)arg1)->GetHitActor(arg2);
15311     } catch (std::out_of_range& e) {
15312       {
15313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15314       };
15315     } catch (std::exception& e) {
15316       {
15317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15318       };
15319     } catch (Dali::DaliException e) {
15320       {
15321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15322       };
15323     } catch (...) {
15324       {
15325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15326       };
15327     }
15328   }
15329
15330   jresult = new Dali::Actor((const Dali::Actor &)result);
15331   return jresult;
15332 }
15333
15334
15335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetLocalPosition(void * jarg1, unsigned long jarg2) {
15336   void * jresult ;
15337   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
15338   std::size_t arg2 ;
15339   Dali::Vector2 *result = 0 ;
15340
15341   arg1 = (Dali::HoverEvent *)jarg1;
15342   arg2 = (std::size_t)jarg2;
15343   {
15344     try {
15345       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetLocalPosition(arg2);
15346     } catch (std::out_of_range& e) {
15347       {
15348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15349       };
15350     } catch (std::exception& e) {
15351       {
15352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15353       };
15354     } catch (Dali::DaliException e) {
15355       {
15356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15357       };
15358     } catch (...) {
15359       {
15360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15361       };
15362     }
15363   }
15364
15365   jresult = (void *)result;
15366   return jresult;
15367 }
15368
15369
15370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetScreenPosition(void * jarg1, unsigned long jarg2) {
15371   void * jresult ;
15372   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
15373   std::size_t arg2 ;
15374   Dali::Vector2 *result = 0 ;
15375
15376   arg1 = (Dali::HoverEvent *)jarg1;
15377   arg2 = (std::size_t)jarg2;
15378   {
15379     try {
15380       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetScreenPosition(arg2);
15381     } CALL_CATCH_EXCEPTION(0);
15382   }
15383
15384   jresult = (void *)result;
15385   return jresult;
15386 }
15387
15388
15389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
15390   void * jresult ;
15391   Dali::KeyEvent *result = 0 ;
15392
15393   {
15394     try {
15395       result = (Dali::KeyEvent *)new Dali::KeyEvent();
15396     } CALL_CATCH_EXCEPTION(0);
15397   }
15398
15399   jresult = (void *)result;
15400   return jresult;
15401 }
15402
15403
15404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(void * jarg1) {
15405   void * jresult ;
15406   Dali::KeyEvent *arg1 = 0 ;
15407   Dali::KeyEvent *result = 0 ;
15408
15409   arg1 = (Dali::KeyEvent *)jarg1;
15410   if (!arg1) {
15411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
15412     return 0;
15413   }
15414   {
15415     try {
15416       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
15417     } CALL_CATCH_EXCEPTION(0);
15418   }
15419
15420   jresult = (void *)result;
15421   return jresult;
15422 }
15423
15424
15425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
15426   void * jresult ;
15427   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
15428   Dali::KeyEvent *arg2 = 0 ;
15429   Dali::KeyEvent *result = 0 ;
15430
15431   arg1 = (Dali::KeyEvent *)jarg1;
15432   arg2 = (Dali::KeyEvent *)jarg2;
15433   if (!arg2) {
15434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
15435     return 0;
15436   }
15437   {
15438     try {
15439       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
15440     } CALL_CATCH_EXCEPTION(0);
15441   }
15442
15443   jresult = (void *)result;
15444   return jresult;
15445 }
15446
15447
15448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_New(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
15449   void * jresult ;
15450   std::string *arg1 = 0 ;
15451   std::string *arg2 = 0 ;
15452   int arg3 ;
15453   int arg4 ;
15454   unsigned long arg5 ;
15455   Dali::KeyEvent::State *arg6 = 0 ;
15456   Dali::KeyEvent::State temp6 ;
15457   Dali::KeyEvent result;
15458
15459   if (!jarg1) {
15460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15461     return 0;
15462   }
15463   std::string arg1_str(jarg1);
15464   arg1 = &arg1_str;
15465   if (!jarg2) {
15466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15467     return 0;
15468   }
15469   std::string arg2_str(jarg2);
15470   arg2 = &arg2_str;
15471   arg3 = (int)jarg3;
15472   arg4 = (int)jarg4;
15473   arg5 = (unsigned long)jarg5;
15474   temp6 = (Dali::KeyEvent::State)jarg6;
15475   arg6 = &temp6;
15476   {
15477     try {
15478       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);
15479     } CALL_CATCH_EXCEPTION(0);
15480   }
15481
15482   jresult = new Dali::KeyEvent((const Dali::KeyEvent &)result);
15483
15484   //argout typemap for const std::string&
15485
15486
15487   //argout typemap for const std::string&
15488
15489   return jresult;
15490 }
15491
15492 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Key_New__SWIG_1()
15493 {
15494   void* jresult;
15495   Dali::KeyEvent result;
15496
15497   {
15498     try
15499     {
15500       result = DevelKeyEvent::New();
15501     } CALL_CATCH_EXCEPTION(0);
15502   }
15503
15504   jresult = new Dali::KeyEvent((const Dali::KeyEvent &)result);
15505
15506   return jresult;
15507 }
15508
15509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
15510   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
15511
15512   arg1 = (Dali::KeyEvent *)jarg1;
15513   {
15514     try {
15515       delete arg1;
15516     } CALL_CATCH_EXCEPTION();
15517   }
15518
15519 }
15520
15521
15522 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
15523   bool jresult ;
15524   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
15525   bool result;
15526
15527   arg1 = (Dali::KeyEvent *)jarg1;
15528   {
15529     try {
15530       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
15531     } CALL_CATCH_EXCEPTION(0);
15532   }
15533
15534   jresult = result;
15535   return jresult;
15536 }
15537
15538
15539 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
15540   bool jresult ;
15541   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
15542   bool result;
15543
15544   arg1 = (Dali::KeyEvent *)jarg1;
15545   {
15546     try {
15547       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
15548     } CALL_CATCH_EXCEPTION(0);
15549   }
15550
15551   jresult = result;
15552   return jresult;
15553 }
15554
15555
15556 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
15557   bool jresult ;
15558   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
15559   bool result;
15560
15561   arg1 = (Dali::KeyEvent *)jarg1;
15562   {
15563     try {
15564       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
15565     } CALL_CATCH_EXCEPTION(0);
15566   }
15567
15568   jresult = result;
15569   return jresult;
15570 }
15571
15572
15573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
15574   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
15575   std::string *arg2 = 0 ;
15576
15577   argp1 = (Dali::KeyEvent *) jarg1;
15578   if (!argp1) {
15579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
15580     return ;
15581   }
15582
15583   Dali::KeyEvent arg1 = *argp1;
15584   if (!jarg2) {
15585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15586     return ;
15587   }
15588   std::string arg2_str(jarg2);
15589   arg2 = &arg2_str;
15590
15591   {
15592     try {
15593       Dali::DevelKeyEvent::SetKeyName(arg1, (std::string const &)*arg2);
15594     } catch (std::out_of_range& e) {
15595       {
15596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15597       };
15598     } catch (std::exception& e) {
15599       {
15600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15601       };
15602     } catch (Dali::DaliException e) {
15603       {
15604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15605       };
15606     } catch (...) {
15607       {
15608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15609       };
15610     }
15611   }
15612 }
15613
15614
15615 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
15616   char * jresult ;
15617
15618   if( jarg1 == NULL )
15619   {
15620     jresult = SWIG_csharp_string_callback( "" );
15621   }
15622   else
15623   {
15624     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
15625     std::string *result = 0;
15626     std::string str = "";
15627
15628     arg1 = ( Dali::KeyEvent * )jarg1;
15629     {
15630       try {
15631         str = ((Dali::KeyEvent const *)arg1)->GetKeyName();
15632         result = (std::string *) &str;
15633         jresult = SWIG_csharp_string_callback(result->c_str());
15634       } catch (std::out_of_range& e) {
15635         {
15636           SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15637         };
15638       } catch (std::exception& e) {
15639         {
15640           SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15641         };
15642       } catch (Dali::DaliException e) {
15643         {
15644           SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15645         };
15646       } catch (...) {
15647         {
15648           SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15649         };
15650       }
15651     }
15652
15653   }
15654
15655   return jresult;
15656 }
15657
15658
15659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
15660   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
15661   std::string *arg2 = 0 ;
15662
15663   argp1 = (Dali::KeyEvent *) jarg1;
15664   if (!argp1) {
15665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
15666     return ;
15667   }
15668
15669   Dali::KeyEvent arg1 = *argp1;
15670   if (!jarg2) {
15671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15672     return ;
15673   }
15674   std::string arg2_str(jarg2);
15675   arg2 = &arg2_str;
15676
15677   {
15678     try {
15679       Dali::DevelKeyEvent::SetKeyString(arg1, (std::string const &)*arg2);
15680     } catch (std::out_of_range& e) {
15681       {
15682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15683       };
15684     } catch (std::exception& e) {
15685       {
15686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15687       };
15688     } catch (Dali::DaliException e) {
15689       {
15690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15691       };
15692     } catch (...) {
15693       {
15694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15695       };
15696     }
15697   }
15698 }
15699
15700
15701 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
15702   char * jresult ;
15703
15704   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
15705   std::string *result = 0;
15706   std::string str = "";
15707   arg1 = ( Dali::KeyEvent * )jarg1;
15708   {
15709     try {
15710       str = ((Dali::KeyEvent const *)arg1)->GetKeyString();
15711       result = (std::string *) &str;
15712       jresult = SWIG_csharp_string_callback(result->c_str());
15713     } catch (std::out_of_range& e) {
15714       {
15715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15716       };
15717     } catch (std::exception& e) {
15718       {
15719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15720       };
15721     } catch (Dali::DaliException e) {
15722       {
15723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15724       };
15725     } catch (...) {
15726       {
15727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15728       };
15729     }
15730   }
15731
15732   return jresult;
15733 }
15734
15735
15736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
15737   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
15738   int arg2 ;
15739
15740   argp1 = (Dali::KeyEvent *) jarg1;
15741   if (!argp1) {
15742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
15743     return ;
15744   }
15745
15746   Dali::KeyEvent arg1 = *argp1;
15747   arg2 = (int)jarg2;
15748   {
15749     try {
15750       Dali::DevelKeyEvent::SetKeyCode(arg1, arg2);
15751     } catch (std::out_of_range& e) {
15752       {
15753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15754       };
15755     } catch (std::exception& e) {
15756       {
15757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15758       };
15759     } catch (Dali::DaliException e) {
15760       {
15761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15762       };
15763     } catch (...) {
15764       {
15765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15766       };
15767     }
15768   }
15769 }
15770
15771
15772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
15773   int jresult ;
15774   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
15775   int result;
15776
15777   arg1 = (Dali::KeyEvent *)jarg1;
15778   {
15779     try {
15780       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyCode();
15781     } catch (std::out_of_range& e) {
15782       {
15783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15784       };
15785     } catch (std::exception& e) {
15786       {
15787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15788       };
15789     } catch (Dali::DaliException e) {
15790       {
15791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15792       };
15793     } catch (...) {
15794       {
15795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15796       };
15797     }
15798   }
15799
15800   jresult = result;
15801   return jresult;
15802 }
15803
15804
15805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
15806   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
15807   int arg2 ;
15808
15809   argp1 = (Dali::KeyEvent *) jarg1;
15810   if (!argp1) {
15811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
15812     return ;
15813   }
15814
15815   Dali::KeyEvent arg1 = *argp1;
15816   arg2 = (int)jarg2;
15817   {
15818     try {
15819       Dali::DevelKeyEvent::SetKeyModifier(arg1, arg2);
15820     } catch (std::out_of_range& e) {
15821       {
15822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15823       };
15824     } catch (std::exception& e) {
15825       {
15826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15827       };
15828     } catch (Dali::DaliException e) {
15829       {
15830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15831       };
15832     } catch (...) {
15833       {
15834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15835       };
15836     }
15837   }
15838 }
15839
15840
15841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
15842   int jresult ;
15843   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
15844   int result;
15845
15846   arg1 = (Dali::KeyEvent *)jarg1;
15847   {
15848     try {
15849       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyModifier();
15850     } catch (std::out_of_range& e) {
15851       {
15852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15853       };
15854     } catch (std::exception& e) {
15855       {
15856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15857       };
15858     } catch (Dali::DaliException e) {
15859       {
15860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15861       };
15862     } catch (...) {
15863       {
15864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15865       };
15866     }
15867   }
15868
15869   jresult = result;
15870   return jresult;
15871 }
15872
15873
15874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
15875   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
15876   unsigned long arg2 ;
15877
15878   argp1 = (Dali::KeyEvent *) jarg1;
15879   if (!argp1) {
15880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
15881     return ;
15882   }
15883
15884   Dali::KeyEvent arg1 = *argp1;
15885   arg2 = (int)jarg2;
15886   {
15887     try {
15888       Dali::DevelKeyEvent::SetTime(arg1, arg2);
15889     } catch (std::out_of_range& e) {
15890       {
15891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15892       };
15893     } catch (std::exception& e) {
15894       {
15895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15896       };
15897     } catch (Dali::DaliException e) {
15898       {
15899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15900       };
15901     } catch (...) {
15902       {
15903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15904       };
15905     }
15906   }
15907 }
15908
15909
15910 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
15911   unsigned long jresult ;
15912   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
15913   unsigned long result;
15914
15915   arg1 = (Dali::KeyEvent *)jarg1;
15916   {
15917     try {
15918       result = (int)((Dali::KeyEvent const *)arg1)->GetTime();
15919     } catch (std::out_of_range& e) {
15920       {
15921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15922       };
15923     } catch (std::exception& e) {
15924       {
15925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15926       };
15927     } catch (Dali::DaliException e) {
15928       {
15929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15930       };
15931     } catch (...) {
15932       {
15933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15934       };
15935     }
15936   }
15937
15938   jresult = result;
15939   return jresult;
15940 }
15941
15942
15943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
15944   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0;
15945   Dali::KeyEvent::State arg2;
15946
15947   argp1 = (Dali::KeyEvent *) jarg1;
15948   if (!argp1) {
15949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
15950     return ;
15951   }
15952
15953   Dali::KeyEvent arg1 = *argp1;
15954   arg2 = (Dali::KeyEvent::State)jarg2;
15955   {
15956     try {
15957       Dali::DevelKeyEvent::SetState(arg1, arg2);
15958     } catch (std::out_of_range& e) {
15959       {
15960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15961       };
15962     } catch (std::exception& e) {
15963       {
15964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15965       };
15966     } catch (Dali::DaliException e) {
15967       {
15968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15969       };
15970     } catch (...) {
15971       {
15972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15973       };
15974     }
15975   }
15976 }
15977
15978
15979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
15980   int jresult ;
15981   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
15982   Dali::KeyEvent::State result;
15983
15984   arg1 = (Dali::KeyEvent *)jarg1;
15985   {
15986     try {
15987       result = (Dali::KeyEvent::State)((Dali::KeyEvent const *)arg1)->GetState();
15988     } catch (std::out_of_range& e) {
15989       {
15990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15991       };
15992     } catch (std::exception& e) {
15993       {
15994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15995       };
15996     } catch (Dali::DaliException e) {
15997       {
15998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15999       };
16000     } catch (...) {
16001       {
16002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16003       };
16004     }
16005   }
16006
16007   jresult = (int)result;
16008   return jresult;
16009
16010 }
16011
16012 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
16013   char * jresult ;
16014
16015   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
16016   std::string *result = 0;
16017   std::string str = "";
16018
16019   arg1 = ( Dali::KeyEvent * )jarg1;
16020   {
16021     try {
16022       str = ((Dali::KeyEvent const *)arg1)->GetLogicalKey();
16023       result = (std::string *) &str;
16024       jresult = SWIG_csharp_string_callback(result->c_str());
16025     } CALL_CATCH_EXCEPTION(0);
16026   }
16027
16028   return jresult;
16029 }
16030
16031
16032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
16033   void * jresult ;
16034   Dali::LongPressGestureDetector *result = 0 ;
16035
16036   {
16037     try {
16038       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
16039     } CALL_CATCH_EXCEPTION(0);
16040   }
16041
16042   jresult = (void *)result;
16043   return jresult;
16044 }
16045
16046
16047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
16048   void * jresult ;
16049   Dali::LongPressGestureDetector result;
16050
16051   {
16052     try {
16053       result = Dali::LongPressGestureDetector::New();
16054     } CALL_CATCH_EXCEPTION(0);
16055   }
16056
16057   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
16058   return jresult;
16059 }
16060
16061
16062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
16063   void * jresult ;
16064   unsigned int arg1 ;
16065   Dali::LongPressGestureDetector result;
16066
16067   arg1 = (unsigned int)jarg1;
16068   {
16069     try {
16070       result = Dali::LongPressGestureDetector::New(arg1);
16071     } CALL_CATCH_EXCEPTION(0);
16072   }
16073
16074   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
16075   return jresult;
16076 }
16077
16078
16079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
16080   void * jresult ;
16081   unsigned int arg1 ;
16082   unsigned int arg2 ;
16083   Dali::LongPressGestureDetector result;
16084
16085   arg1 = (unsigned int)jarg1;
16086   arg2 = (unsigned int)jarg2;
16087   {
16088     try {
16089       result = Dali::LongPressGestureDetector::New(arg1,arg2);
16090     } CALL_CATCH_EXCEPTION(0);
16091   }
16092
16093   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
16094   return jresult;
16095 }
16096
16097
16098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
16099   void * jresult ;
16100   Dali::BaseHandle arg1 ;
16101   Dali::BaseHandle *argp1 ;
16102   Dali::LongPressGestureDetector result;
16103
16104   argp1 = (Dali::BaseHandle *)jarg1;
16105   if (!argp1) {
16106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16107     return 0;
16108   }
16109   arg1 = *argp1;
16110   {
16111     try {
16112       result = Dali::LongPressGestureDetector::DownCast(arg1);
16113     } CALL_CATCH_EXCEPTION(0);
16114   }
16115
16116   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
16117   return jresult;
16118 }
16119
16120
16121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
16122   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
16123
16124   arg1 = (Dali::LongPressGestureDetector *)jarg1;
16125   {
16126     try {
16127       delete arg1;
16128     } CALL_CATCH_EXCEPTION();
16129   }
16130
16131 }
16132
16133
16134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
16135   void * jresult ;
16136   Dali::LongPressGestureDetector *arg1 = 0 ;
16137   Dali::LongPressGestureDetector *result = 0 ;
16138
16139   arg1 = (Dali::LongPressGestureDetector *)jarg1;
16140   if (!arg1) {
16141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
16142     return 0;
16143   }
16144   {
16145     try {
16146       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
16147     } CALL_CATCH_EXCEPTION(0);
16148   }
16149
16150   jresult = (void *)result;
16151   return jresult;
16152 }
16153
16154
16155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
16156   void * jresult ;
16157   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
16158   Dali::LongPressGestureDetector *arg2 = 0 ;
16159   Dali::LongPressGestureDetector *result = 0 ;
16160
16161   arg1 = (Dali::LongPressGestureDetector *)jarg1;
16162   arg2 = (Dali::LongPressGestureDetector *)jarg2;
16163   if (!arg2) {
16164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
16165     return 0;
16166   }
16167   {
16168     try {
16169       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
16170     } CALL_CATCH_EXCEPTION(0);
16171   }
16172
16173   jresult = (void *)result;
16174   return jresult;
16175 }
16176
16177
16178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
16179   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
16180   unsigned int arg2 ;
16181
16182   arg1 = (Dali::LongPressGestureDetector *)jarg1;
16183   arg2 = (unsigned int)jarg2;
16184   {
16185     try {
16186       (arg1)->SetTouchesRequired(arg2);
16187     } CALL_CATCH_EXCEPTION();
16188   }
16189
16190 }
16191
16192
16193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
16194   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
16195   unsigned int arg2 ;
16196   unsigned int arg3 ;
16197
16198   arg1 = (Dali::LongPressGestureDetector *)jarg1;
16199   arg2 = (unsigned int)jarg2;
16200   arg3 = (unsigned int)jarg3;
16201   {
16202     try {
16203       (arg1)->SetTouchesRequired(arg2,arg3);
16204     } CALL_CATCH_EXCEPTION();
16205   }
16206
16207 }
16208
16209
16210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
16211   unsigned int jresult ;
16212   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
16213   unsigned int result;
16214
16215   arg1 = (Dali::LongPressGestureDetector *)jarg1;
16216   {
16217     try {
16218       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
16219     } CALL_CATCH_EXCEPTION(0);
16220   }
16221
16222   jresult = result;
16223   return jresult;
16224 }
16225
16226
16227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
16228   unsigned int jresult ;
16229   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
16230   unsigned int result;
16231
16232   arg1 = (Dali::LongPressGestureDetector *)jarg1;
16233   {
16234     try {
16235       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
16236     } CALL_CATCH_EXCEPTION(0);
16237   }
16238
16239   jresult = result;
16240   return jresult;
16241 }
16242
16243
16244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
16245   void * jresult ;
16246   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
16247   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
16248
16249   arg1 = (Dali::LongPressGestureDetector *)jarg1;
16250   {
16251     try {
16252       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
16253     } CALL_CATCH_EXCEPTION(0);
16254   }
16255
16256   jresult = (void *)result;
16257   return jresult;
16258 }
16259
16260
16261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0() {
16262   void * jresult ;
16263   Dali::LongPressGesture *result = 0 ;
16264
16265   {
16266     try {
16267       result = (Dali::LongPressGesture *)new Dali::LongPressGesture();
16268     } CALL_CATCH_EXCEPTION(0);
16269   }
16270
16271   jresult = (void *)result;
16272   return jresult;
16273 }
16274
16275
16276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_New(int jarg1) {
16277   void * jresult ;
16278   Dali::GestureState arg1 ;
16279   Dali::LongPressGesture result;
16280
16281   arg1 = (Dali::GestureState)jarg1;
16282   {
16283     try {
16284       result = DevelLongPressGesture::New(arg1);
16285     } CALL_CATCH_EXCEPTION(0);
16286   }
16287
16288   jresult = new Dali::LongPressGesture((const Dali::LongPressGesture &)result);
16289   return jresult;
16290 }
16291
16292
16293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
16294   void * jresult ;
16295   Dali::LongPressGesture *arg1 = 0 ;
16296   Dali::LongPressGesture *result = 0 ;
16297
16298   arg1 = (Dali::LongPressGesture *)jarg1;
16299   if (!arg1) {
16300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
16301     return 0;
16302   }
16303   {
16304     try {
16305       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
16306     } CALL_CATCH_EXCEPTION(0);
16307   }
16308
16309   jresult = (void *)result;
16310   return jresult;
16311 }
16312
16313
16314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
16315   void * jresult ;
16316   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
16317   Dali::LongPressGesture *arg2 = 0 ;
16318   Dali::LongPressGesture *result = 0 ;
16319
16320   arg1 = (Dali::LongPressGesture *)jarg1;
16321   arg2 = (Dali::LongPressGesture *)jarg2;
16322   if (!arg2) {
16323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
16324     return 0;
16325   }
16326   {
16327     try {
16328       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
16329     } CALL_CATCH_EXCEPTION(0);
16330   }
16331
16332   jresult = (void *)result;
16333   return jresult;
16334 }
16335
16336
16337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
16338   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
16339
16340   arg1 = (Dali::LongPressGesture *)jarg1;
16341   {
16342     try {
16343       delete arg1;
16344     } CALL_CATCH_EXCEPTION();
16345   }
16346
16347 }
16348
16349
16350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
16351   unsigned int jresult ;
16352   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
16353   unsigned int result;
16354
16355   arg1 = (Dali::LongPressGesture *)jarg1;
16356   result = (unsigned int) ((arg1)->GetNumberOfTouches());
16357   jresult = result;
16358   return jresult;
16359 }
16360
16361
16362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
16363   void * jresult ;
16364   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
16365   Dali::Vector2 result;
16366
16367   arg1 = (Dali::LongPressGesture *)jarg1;
16368   {
16369     try {
16370       result = ((Dali::LongPressGesture const *)arg1)->GetScreenPoint();
16371     } catch (std::out_of_range& e) {
16372       {
16373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16374       };
16375     } catch (std::exception& e) {
16376       {
16377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16378       };
16379     } catch (Dali::DaliException e) {
16380       {
16381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16382       };
16383     } catch (...) {
16384       {
16385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16386       };
16387     }
16388   }
16389   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
16390   return jresult;
16391 }
16392
16393
16394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
16395   void * jresult ;
16396   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
16397   Dali::Vector2 result;
16398
16399   arg1 = (Dali::LongPressGesture *)jarg1;
16400   {
16401     try {
16402       result = ((Dali::LongPressGesture const *)arg1)->GetLocalPoint();
16403     } catch (std::out_of_range& e) {
16404       {
16405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16406       };
16407     } catch (std::exception& e) {
16408       {
16409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16410       };
16411     } catch (Dali::DaliException e) {
16412       {
16413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16414       };
16415     } catch (...) {
16416       {
16417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16418       };
16419     }
16420   }
16421   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
16422   return jresult;
16423 }
16424
16425
16426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
16427   void * jresult ;
16428   Dali::WheelEvent *result = 0 ;
16429
16430   {
16431     try {
16432       result = (Dali::WheelEvent *)new Dali::WheelEvent();
16433     } CALL_CATCH_EXCEPTION(0);
16434   }
16435
16436   jresult = (void *)result;
16437   return jresult;
16438 }
16439
16440
16441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(void * jarg1) {
16442   void * jresult ;
16443   Dali::WheelEvent *arg1 = 0 ;
16444   Dali::WheelEvent *result = 0 ;
16445
16446   arg1 = (Dali::WheelEvent *)jarg1;
16447   if (!arg1) {
16448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
16449     return 0;
16450   }
16451   {
16452     try {
16453       result = (Dali::WheelEvent *)new Dali::WheelEvent((Dali::WheelEvent const &)*arg1);
16454     } catch (std::out_of_range& e) {
16455       {
16456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16457       };
16458     } catch (std::exception& e) {
16459       {
16460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16461       };
16462     } catch (Dali::DaliException e) {
16463       {
16464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16465       };
16466     } catch (...) {
16467       {
16468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16469       };
16470     }
16471   }
16472
16473   jresult = (void *)result;
16474   return jresult;
16475 }
16476
16477
16478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_Assign(void * jarg1, void * jarg2) {
16479   void * jresult ;
16480   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16481   Dali::WheelEvent *arg2 = 0 ;
16482   Dali::WheelEvent *result = 0 ;
16483
16484   arg1 = (Dali::WheelEvent *)jarg1;
16485   arg2 = (Dali::WheelEvent *)jarg2;
16486   if (!arg2) {
16487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
16488     return 0;
16489   }
16490   {
16491     try {
16492       result = (Dali::WheelEvent *) &(arg1)->operator =((Dali::WheelEvent const &)*arg2);
16493     } catch (std::out_of_range& e) {
16494       {
16495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16496       };
16497     } catch (std::exception& e) {
16498       {
16499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16500       };
16501     } catch (Dali::DaliException e) {
16502       {
16503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16504       };
16505     } catch (...) {
16506       {
16507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16508       };
16509     }
16510   }
16511
16512   jresult = (void *)result;
16513   return jresult;
16514 }
16515
16516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_New(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
16517   void * jresult ;
16518   Dali::WheelEvent::Type arg1 ;
16519   int arg2 ;
16520   unsigned int arg3 ;
16521   Dali::Vector2 arg4 ;
16522   int arg5 ;
16523   unsigned int arg6 ;
16524   Dali::Vector2 *argp4 ;
16525   Dali::WheelEvent result;
16526
16527   arg1 = (Dali::WheelEvent::Type)jarg1;
16528   arg2 = (int)jarg2;
16529   arg3 = (unsigned int)jarg3;
16530   argp4 = (Dali::Vector2 *)jarg4;
16531   if (!argp4) {
16532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
16533     return 0;
16534   }
16535   arg4 = *argp4;
16536   arg5 = (int)jarg5;
16537   arg6 = (unsigned int)jarg6;
16538   {
16539     try {
16540       result = DevelWheelEvent::New(arg1,arg2,arg3,arg4,arg5,arg6);
16541     } CALL_CATCH_EXCEPTION(0);
16542   }
16543
16544   jresult = new Dali::WheelEvent((const Dali::WheelEvent &)result);
16545   return jresult;
16546 }
16547
16548
16549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
16550   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16551
16552   arg1 = (Dali::WheelEvent *)jarg1;
16553   {
16554     try {
16555       delete arg1;
16556     } CALL_CATCH_EXCEPTION();
16557   }
16558
16559 }
16560
16561
16562 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
16563   bool jresult ;
16564   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16565   bool result;
16566
16567   arg1 = (Dali::WheelEvent *)jarg1;
16568   {
16569     try {
16570       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
16571     } CALL_CATCH_EXCEPTION(0);
16572   }
16573
16574   jresult = result;
16575   return jresult;
16576 }
16577
16578
16579 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
16580   bool jresult ;
16581   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16582   bool result;
16583
16584   arg1 = (Dali::WheelEvent *)jarg1;
16585   {
16586     try {
16587       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
16588     } catch (std::out_of_range& e) {
16589       {
16590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16591       };
16592     } catch (std::exception& e) {
16593       {
16594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16595       };
16596     } catch (Dali::DaliException e) {
16597       {
16598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16599       };
16600     } catch (...) {
16601       {
16602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16603       };
16604     }
16605   }
16606
16607   jresult = result;
16608   return jresult;
16609 }
16610
16611
16612 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
16613   bool jresult ;
16614   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16615   bool result;
16616
16617   arg1 = (Dali::WheelEvent *)jarg1;
16618   {
16619     try {
16620       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
16621     } catch (std::out_of_range& e) {
16622       {
16623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16624       };
16625     } catch (std::exception& e) {
16626       {
16627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16628       };
16629     } catch (Dali::DaliException e) {
16630       {
16631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16632       };
16633     } catch (...) {
16634       {
16635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16636       };
16637     }
16638   }
16639
16640   jresult = result;
16641   return jresult;
16642 }
16643
16644
16645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
16646   int jresult ;
16647   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16648   Dali::WheelEvent::Type result;
16649
16650   arg1 = (Dali::WheelEvent *)jarg1;
16651   {
16652     try {
16653       result = ((Dali::WheelEvent const *)arg1)->GetType();
16654     } catch (std::out_of_range& e) {
16655       {
16656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16657       };
16658     } catch (std::exception& e) {
16659       {
16660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16661       };
16662     } catch (Dali::DaliException e) {
16663       {
16664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16665       };
16666     } catch (...) {
16667       {
16668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16669       };
16670     }
16671   }
16672
16673   jresult = (int)result;
16674   return jresult;
16675 }
16676
16677
16678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
16679   int jresult ;
16680   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16681   int result;
16682
16683   arg1 = (Dali::WheelEvent *)jarg1;
16684   {
16685     try {
16686       result = ((Dali::WheelEvent const *)arg1)->GetDirection();
16687     } catch (std::out_of_range& e) {
16688       {
16689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16690       };
16691     } catch (std::exception& e) {
16692       {
16693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16694       };
16695     } catch (Dali::DaliException e) {
16696       {
16697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16698       };
16699     } catch (...) {
16700       {
16701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16702       };
16703     }
16704   }
16705
16706   jresult = result;
16707   return jresult;
16708 }
16709
16710
16711 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
16712   unsigned int jresult ;
16713   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16714   unsigned int result;
16715
16716   arg1 = (Dali::WheelEvent *)jarg1;
16717   {
16718     try {
16719       result = ((Dali::WheelEvent const *)arg1)->GetModifiers();
16720     } CALL_CATCH_EXCEPTION(0);
16721   }
16722
16723   jresult = result;
16724   return jresult;
16725 }
16726
16727
16728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
16729   void * jresult ;
16730   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16731   Dali::Vector2 *result = 0 ;
16732
16733   arg1 = (Dali::WheelEvent *)jarg1;
16734   {
16735     try {
16736       result = (Dali::Vector2 *) &((Dali::WheelEvent const *)arg1)->GetPoint();
16737     } CALL_CATCH_EXCEPTION(0);
16738   }
16739
16740   jresult = (void *)result;
16741   return jresult;
16742 }
16743
16744
16745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_delta_get(void * jarg1) {
16746   int jresult ;
16747   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16748   int result;
16749
16750   arg1 = (Dali::WheelEvent *)jarg1;
16751   {
16752     try {
16753       result = ((Dali::WheelEvent const *)arg1)->GetDelta();
16754     } catch (std::out_of_range& e) {
16755       {
16756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16757       };
16758     } catch (std::exception& e) {
16759       {
16760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16761       };
16762     } catch (Dali::DaliException e) {
16763       {
16764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16765       };
16766     } catch (...) {
16767       {
16768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16769       };
16770     }
16771   }
16772
16773   jresult = result;
16774   return jresult;
16775 }
16776
16777
16778 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
16779   unsigned int jresult ;
16780   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16781   unsigned int result;
16782
16783   arg1 = (Dali::WheelEvent *)jarg1;
16784   {
16785     try {
16786       result = ((Dali::WheelEvent const *)arg1)->GetTime();
16787     } catch (std::out_of_range& e) {
16788       {
16789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16790       };
16791     } catch (std::exception& e) {
16792       {
16793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16794       };
16795     } catch (Dali::DaliException e) {
16796       {
16797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16798       };
16799     } catch (...) {
16800       {
16801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16802       };
16803     }
16804   }
16805
16806   jresult = result;
16807   return jresult;
16808 }
16809
16810 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
16811   char * jresult ;
16812   Dali::KeyEvent *arg1 = 0 ;
16813   std::string result;
16814
16815   arg1 = (Dali::KeyEvent *)jarg1;
16816   if (!arg1) {
16817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
16818     return 0;
16819   }
16820   {
16821     try {
16822       result = arg1->GetDeviceName();
16823     } CALL_CATCH_EXCEPTION(0);
16824   }
16825
16826   jresult = SWIG_csharp_string_callback((&result)->c_str());
16827   return jresult;
16828 }
16829
16830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
16831   int jresult ;
16832   Dali::KeyEvent *arg1 = 0 ;
16833   Dali::Device::Class::Type result;
16834
16835   arg1 = (Dali::KeyEvent *)jarg1;
16836   if (!arg1) {
16837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
16838     return 0;
16839   }
16840   {
16841     try {
16842       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
16843     } CALL_CATCH_EXCEPTION(0);
16844   }
16845
16846   jresult = (int)result;
16847   return jresult;
16848 }
16849
16850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
16851   int jresult ;
16852   Dali::KeyEvent *arg1 = 0 ;
16853   Dali::Device::Subclass::Type result;
16854
16855   arg1 = (Dali::KeyEvent *)jarg1;
16856   if (!arg1) {
16857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
16858     return 0;
16859   }
16860   {
16861     try {
16862       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
16863     } CALL_CATCH_EXCEPTION(0);
16864   }
16865
16866   jresult = (int)result;
16867   return jresult;
16868 }
16869
16870
16871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
16872   void * jresult ;
16873   Dali::Stage result;
16874
16875   {
16876     try {
16877       result = Dali::Stage::GetCurrent();
16878     } CALL_CATCH_EXCEPTION(0);
16879   }
16880
16881   jresult = new Dali::Stage((const Dali::Stage &)result);
16882   return jresult;
16883 }
16884
16885
16886 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
16887   bool jresult ;
16888   bool result;
16889
16890   {
16891     try {
16892       result = (bool)Dali::Stage::IsInstalled();
16893     } CALL_CATCH_EXCEPTION(0);
16894   }
16895
16896   jresult = result;
16897   return jresult;
16898 }
16899
16900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
16901   void * jresult ;
16902   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
16903   Dali::RenderTaskList result;
16904
16905   arg1 = (Dali::Stage *)jarg1;
16906   {
16907     try {
16908       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
16909     } CALL_CATCH_EXCEPTION(0);
16910   }
16911
16912   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
16913   return jresult;
16914 }
16915
16916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
16917   void * jresult ;
16918   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
16919   Dali::Vector2 result;
16920
16921   arg1 = (Dali::Stage *)jarg1;
16922   {
16923     try {
16924       result = ((Dali::Stage const *)arg1)->GetDpi();
16925     } CALL_CATCH_EXCEPTION(0);
16926   }
16927
16928   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
16929   return jresult;
16930 }
16931
16932
16933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
16934   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
16935   float arg2 ;
16936
16937   arg1 = (Dali::Stage *)jarg1;
16938   arg2 = (float)jarg2;
16939   {
16940     try {
16941       (arg1)->KeepRendering(arg2);
16942     } CALL_CATCH_EXCEPTION();
16943   }
16944
16945 }
16946
16947
16948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
16949   void * jresult ;
16950   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
16951   Dali::Stage::KeyEventSignalType *result = 0 ;
16952
16953   arg1 = (Dali::Stage *)jarg1;
16954   {
16955     try {
16956       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
16957     } CALL_CATCH_EXCEPTION(0);
16958   }
16959
16960   jresult = (void *)result;
16961   return jresult;
16962 }
16963
16964
16965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
16966   void * jresult ;
16967   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
16968   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
16969
16970   arg1 = (Dali::Stage *)jarg1;
16971   {
16972     try {
16973       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
16974     } CALL_CATCH_EXCEPTION(0);
16975   }
16976
16977   jresult = (void *)result;
16978   return jresult;
16979 }
16980
16981
16982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
16983   void * jresult ;
16984   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
16985   Dali::Stage::TouchEventSignalType *result = 0 ;
16986
16987   arg1 = (Dali::Stage *)jarg1;
16988   {
16989     try {
16990       result = (Dali::Stage::TouchEventSignalType *) &(arg1)->TouchedSignal();
16991     } CALL_CATCH_EXCEPTION(0);
16992   }
16993
16994   jresult = (void *)result;
16995   return jresult;
16996 }
16997
16998
16999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
17000   void * jresult ;
17001   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
17002   Dali::Stage::WheelEventSignalType *result = 0 ;
17003
17004   arg1 = (Dali::Stage *)jarg1;
17005   {
17006     try {
17007       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
17008     } CALL_CATCH_EXCEPTION(0);
17009   }
17010
17011   jresult = (void *)result;
17012   return jresult;
17013 }
17014
17015
17016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
17017   void * jresult ;
17018   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
17019   Dali::Stage::ContextStatusSignal *result = 0 ;
17020
17021   arg1 = (Dali::Stage *)jarg1;
17022   {
17023     try {
17024       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
17025     } CALL_CATCH_EXCEPTION(0);
17026   }
17027
17028   jresult = (void *)result;
17029   return jresult;
17030 }
17031
17032
17033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
17034   void * jresult ;
17035   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
17036   Dali::Stage::ContextStatusSignal *result = 0 ;
17037
17038   arg1 = (Dali::Stage *)jarg1;
17039   {
17040     try {
17041       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
17042     } CALL_CATCH_EXCEPTION(0);
17043   }
17044
17045   jresult = (void *)result;
17046   return jresult;
17047 }
17048
17049
17050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
17051   void * jresult ;
17052   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
17053   Dali::Stage::SceneCreatedSignalType *result = 0 ;
17054
17055   arg1 = (Dali::Stage *)jarg1;
17056   {
17057     try {
17058       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
17059     } CALL_CATCH_EXCEPTION(0);
17060   }
17061
17062   jresult = (void *)result;
17063   return jresult;
17064 }
17065
17066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
17067   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
17068   Dali::DevelStage::Rendering arg2 ;
17069
17070   arg1 = (Dali::Stage *)jarg1;
17071   arg2 = (Dali::DevelStage::Rendering)jarg2;
17072   {
17073     try {
17074       DevelStage::SetRenderingBehavior(*arg1,arg2);
17075     } CALL_CATCH_EXCEPTION();
17076   }
17077
17078 }
17079
17080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
17081
17082   int jresult ;
17083   int result ;
17084   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
17085
17086   arg1 = (Dali::Stage *)jarg1;
17087   {
17088     try {
17089       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
17090     } CALL_CATCH_EXCEPTION(0);
17091   }
17092
17093   jresult = result;
17094   return jresult;
17095 }
17096
17097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
17098   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
17099
17100   arg1 = (Dali::RelayoutContainer *)jarg1;
17101   {
17102     try {
17103       delete arg1;
17104     } CALL_CATCH_EXCEPTION();
17105   }
17106
17107 }
17108
17109
17110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
17111   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
17112   Dali::Actor *arg2 = 0 ;
17113   Dali::Vector2 *arg3 = 0 ;
17114
17115   arg1 = (Dali::RelayoutContainer *)jarg1;
17116   arg2 = (Dali::Actor *)jarg2;
17117   if (!arg2) {
17118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
17119     return ;
17120   }
17121   arg3 = (Dali::Vector2 *)jarg3;
17122   if (!arg3) {
17123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
17124     return ;
17125   }
17126   {
17127     try {
17128       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
17129     } CALL_CATCH_EXCEPTION();
17130   }
17131
17132 }
17133
17134
17135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
17136   void * jresult ;
17137   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17138   Dali::CustomActor result;
17139
17140   arg1 = (Dali::CustomActorImpl *)jarg1;
17141   {
17142     try {
17143       result = ((Dali::CustomActorImpl const *)arg1)->Self();
17144     } CALL_CATCH_EXCEPTION(0);
17145   }
17146
17147   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
17148   return jresult;
17149 }
17150
17151
17152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneConnection(void * jarg1, int jarg2) {
17153   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17154   int arg2 ;
17155
17156   arg1 = (Dali::CustomActorImpl *)jarg1;
17157   arg2 = (int)jarg2;
17158   {
17159     try {
17160       (arg1)->OnSceneConnection(arg2);
17161     } CALL_CATCH_EXCEPTION();
17162   }
17163
17164 }
17165
17166
17167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneDisconnection(void * jarg1) {
17168   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17169
17170   arg1 = (Dali::CustomActorImpl *)jarg1;
17171   {
17172     try {
17173       (arg1)->OnSceneDisconnection();
17174     } CALL_CATCH_EXCEPTION();
17175   }
17176
17177 }
17178
17179
17180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
17181   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17182   Dali::Actor *arg2 = 0 ;
17183
17184   arg1 = (Dali::CustomActorImpl *)jarg1;
17185   arg2 = (Dali::Actor *)jarg2;
17186   if (!arg2) {
17187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
17188     return ;
17189   }
17190   {
17191     try {
17192       (arg1)->OnChildAdd(*arg2);
17193     } CALL_CATCH_EXCEPTION();
17194   }
17195
17196 }
17197
17198
17199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
17200   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17201   Dali::Actor *arg2 = 0 ;
17202
17203   arg1 = (Dali::CustomActorImpl *)jarg1;
17204   arg2 = (Dali::Actor *)jarg2;
17205   if (!arg2) {
17206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
17207     return ;
17208   }
17209   {
17210     try {
17211       (arg1)->OnChildRemove(*arg2);
17212     } CALL_CATCH_EXCEPTION();
17213   }
17214
17215 }
17216
17217
17218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
17219   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17220   Dali::Property::Index arg2 ;
17221   Dali::Property::Value arg3 ;
17222   Dali::Property::Value *argp3 ;
17223
17224   arg1 = (Dali::CustomActorImpl *)jarg1;
17225   arg2 = (Dali::Property::Index)jarg2;
17226   argp3 = (Dali::Property::Value *)jarg3;
17227   if (!argp3) {
17228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
17229     return ;
17230   }
17231   arg3 = *argp3;
17232   {
17233     try {
17234       (arg1)->OnPropertySet(arg2,arg3);
17235     } CALL_CATCH_EXCEPTION();
17236   }
17237
17238 }
17239
17240
17241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
17242   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17243   Dali::Vector3 *arg2 = 0 ;
17244
17245   arg1 = (Dali::CustomActorImpl *)jarg1;
17246   arg2 = (Dali::Vector3 *)jarg2;
17247   if (!arg2) {
17248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
17249     return ;
17250   }
17251   {
17252     try {
17253       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
17254     } CALL_CATCH_EXCEPTION();
17255   }
17256
17257 }
17258
17259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
17260   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17261   Dali::Animation *arg2 = 0 ;
17262   Dali::Vector3 *arg3 = 0 ;
17263
17264   arg1 = (Dali::CustomActorImpl *)jarg1;
17265   arg2 = (Dali::Animation *)jarg2;
17266   if (!arg2) {
17267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
17268     return ;
17269   }
17270   arg3 = (Dali::Vector3 *)jarg3;
17271   if (!arg3) {
17272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
17273     return ;
17274   }
17275   {
17276     try {
17277       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
17278     } CALL_CATCH_EXCEPTION();
17279   }
17280 }
17281
17282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
17283   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17284   Dali::Vector2 *arg2 = 0 ;
17285   Dali::RelayoutContainer *arg3 = 0 ;
17286
17287   arg1 = (Dali::CustomActorImpl *)jarg1;
17288   arg2 = (Dali::Vector2 *)jarg2;
17289   if (!arg2) {
17290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
17291     return ;
17292   }
17293   arg3 = (Dali::RelayoutContainer *)jarg3;
17294   if (!arg3) {
17295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
17296     return ;
17297   }
17298   {
17299     try {
17300       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
17301     } CALL_CATCH_EXCEPTION();
17302   }
17303
17304 }
17305
17306
17307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
17308   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17309   Dali::ResizePolicy::Type arg2 ;
17310   Dali::Dimension::Type arg3 ;
17311
17312   arg1 = (Dali::CustomActorImpl *)jarg1;
17313   arg2 = (Dali::ResizePolicy::Type)jarg2;
17314   arg3 = (Dali::Dimension::Type)jarg3;
17315   {
17316     try {
17317       (arg1)->OnSetResizePolicy(arg2,arg3);
17318     } CALL_CATCH_EXCEPTION();
17319   }
17320
17321 }
17322
17323
17324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
17325   void * jresult ;
17326   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17327   Dali::Vector3 result;
17328
17329   arg1 = (Dali::CustomActorImpl *)jarg1;
17330   {
17331     try {
17332       result = (arg1)->GetNaturalSize();
17333     } CALL_CATCH_EXCEPTION(0);
17334   }
17335
17336   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
17337   return jresult;
17338 }
17339
17340
17341 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
17342   float jresult ;
17343   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17344   Dali::Actor *arg2 = 0 ;
17345   Dali::Dimension::Type arg3 ;
17346   float result;
17347
17348   arg1 = (Dali::CustomActorImpl *)jarg1;
17349   arg2 = (Dali::Actor *)jarg2;
17350   if (!arg2) {
17351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
17352     return 0;
17353   }
17354   arg3 = (Dali::Dimension::Type)jarg3;
17355   {
17356     try {
17357       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
17358     } CALL_CATCH_EXCEPTION(0);
17359   }
17360
17361   jresult = result;
17362   return jresult;
17363 }
17364
17365
17366 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
17367   float jresult ;
17368   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17369   float arg2 ;
17370   float result;
17371
17372   arg1 = (Dali::CustomActorImpl *)jarg1;
17373   arg2 = (float)jarg2;
17374   {
17375     try {
17376       result = (float)(arg1)->GetHeightForWidth(arg2);
17377     } CALL_CATCH_EXCEPTION(0);
17378   }
17379
17380   jresult = result;
17381   return jresult;
17382 }
17383
17384
17385 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
17386   float jresult ;
17387   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17388   float arg2 ;
17389   float result;
17390
17391   arg1 = (Dali::CustomActorImpl *)jarg1;
17392   arg2 = (float)jarg2;
17393   {
17394     try {
17395       result = (float)(arg1)->GetWidthForHeight(arg2);
17396     } CALL_CATCH_EXCEPTION(0);
17397   }
17398
17399   jresult = result;
17400   return jresult;
17401 }
17402
17403
17404 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
17405   bool jresult ;
17406   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17407   Dali::Dimension::Type arg2 ;
17408   bool result;
17409
17410   arg1 = (Dali::CustomActorImpl *)jarg1;
17411   arg2 = (Dali::Dimension::Type)jarg2;
17412   {
17413     try {
17414       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
17415     } CALL_CATCH_EXCEPTION(0);
17416   }
17417
17418   jresult = result;
17419   return jresult;
17420 }
17421
17422
17423 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
17424   bool jresult ;
17425   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17426   bool result;
17427
17428   arg1 = (Dali::CustomActorImpl *)jarg1;
17429   {
17430     try {
17431       result = (bool)(arg1)->RelayoutDependentOnChildren();
17432     } CALL_CATCH_EXCEPTION(0);
17433   }
17434
17435   jresult = result;
17436   return jresult;
17437 }
17438
17439
17440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
17441   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17442   Dali::Dimension::Type arg2 ;
17443
17444   arg1 = (Dali::CustomActorImpl *)jarg1;
17445   arg2 = (Dali::Dimension::Type)jarg2;
17446   {
17447     try {
17448       (arg1)->OnCalculateRelayoutSize(arg2);
17449     } CALL_CATCH_EXCEPTION();
17450   }
17451
17452 }
17453
17454
17455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
17456   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17457   float arg2 ;
17458   Dali::Dimension::Type arg3 ;
17459
17460   arg1 = (Dali::CustomActorImpl *)jarg1;
17461   arg2 = (float)jarg2;
17462   arg3 = (Dali::Dimension::Type)jarg3;
17463   {
17464     try {
17465       (arg1)->OnLayoutNegotiated(arg2,arg3);
17466     } CALL_CATCH_EXCEPTION();
17467   }
17468
17469 }
17470
17471 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
17472   bool jresult ;
17473   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17474   bool result;
17475
17476   arg1 = (Dali::CustomActorImpl *)jarg1;
17477   {
17478     try {
17479       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
17480     } CALL_CATCH_EXCEPTION(0);
17481   }
17482
17483   jresult = result;
17484   return jresult;
17485 }
17486
17487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
17488   void * jresult ;
17489   Dali::CustomActor *result = 0 ;
17490
17491   {
17492     try {
17493       result = (Dali::CustomActor *)new Dali::CustomActor();
17494     } CALL_CATCH_EXCEPTION(0);
17495   }
17496
17497   jresult = (void *)result;
17498   return jresult;
17499 }
17500
17501
17502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
17503   void * jresult ;
17504   Dali::BaseHandle arg1 ;
17505   Dali::BaseHandle *argp1 ;
17506   Dali::CustomActor result;
17507
17508   argp1 = (Dali::BaseHandle *)jarg1;
17509   if (!argp1) {
17510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17511     return 0;
17512   }
17513   arg1 = *argp1;
17514   {
17515     try {
17516       result = Dali::CustomActor::DownCast(arg1);
17517     } CALL_CATCH_EXCEPTION(0);
17518   }
17519
17520   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
17521   return jresult;
17522 }
17523
17524
17525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
17526   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
17527
17528   arg1 = (Dali::CustomActor *)jarg1;
17529   {
17530     try {
17531       delete arg1;
17532     } CALL_CATCH_EXCEPTION();
17533   }
17534
17535 }
17536
17537
17538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
17539   void * jresult ;
17540   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
17541   Dali::CustomActorImpl *result = 0 ;
17542
17543   arg1 = (Dali::CustomActor *)jarg1;
17544   {
17545     try {
17546       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
17547     } CALL_CATCH_EXCEPTION(0);
17548   }
17549
17550   jresult = (void *)result;
17551   return jresult;
17552 }
17553
17554
17555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
17556   void * jresult ;
17557   Dali::CustomActorImpl *arg1 = 0 ;
17558   Dali::CustomActor *result = 0 ;
17559
17560   arg1 = (Dali::CustomActorImpl *)jarg1;
17561   if (!arg1) {
17562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
17563     return 0;
17564   }
17565   {
17566     try {
17567       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
17568     } CALL_CATCH_EXCEPTION(0);
17569   }
17570
17571   jresult = (void *)result;
17572   return jresult;
17573 }
17574
17575
17576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
17577   void * jresult ;
17578   Dali::CustomActor *arg1 = 0 ;
17579   Dali::CustomActor *result = 0 ;
17580
17581   arg1 = (Dali::CustomActor *)jarg1;
17582   if (!arg1) {
17583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
17584     return 0;
17585   }
17586   {
17587     try {
17588       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
17589     } CALL_CATCH_EXCEPTION(0);
17590   }
17591
17592   jresult = (void *)result;
17593   return jresult;
17594 }
17595
17596
17597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
17598   void * jresult ;
17599   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
17600   Dali::CustomActor *arg2 = 0 ;
17601   Dali::CustomActor *result = 0 ;
17602
17603   arg1 = (Dali::CustomActor *)jarg1;
17604   arg2 = (Dali::CustomActor *)jarg2;
17605   if (!arg2) {
17606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
17607     return 0;
17608   }
17609   {
17610     try {
17611       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
17612     } CALL_CATCH_EXCEPTION(0);
17613   }
17614
17615   jresult = (void *)result;
17616   return jresult;
17617 }
17618
17619
17620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
17621   int jresult ;
17622   int result;
17623
17624   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
17625   jresult = (int)result;
17626   return jresult;
17627 }
17628
17629
17630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
17631   int jresult ;
17632   int result;
17633
17634   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
17635   jresult = (int)result;
17636   return jresult;
17637 }
17638
17639
17640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
17641   int jresult ;
17642   int result;
17643
17644   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
17645   jresult = (int)result;
17646   return jresult;
17647 }
17648
17649
17650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
17651   int jresult ;
17652   int result;
17653
17654   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
17655   jresult = (int)result;
17656   return jresult;
17657 }
17658
17659
17660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
17661   int jresult ;
17662   int result;
17663
17664   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
17665   jresult = (int)result;
17666   return jresult;
17667 }
17668
17669
17670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
17671   int jresult ;
17672   int result;
17673
17674   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
17675   jresult = (int)result;
17676   return jresult;
17677 }
17678
17679
17680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
17681   int jresult ;
17682   int result;
17683
17684   result = (int)Dali::PanGestureDetector::Property::PANNING;
17685   jresult = (int)result;
17686   return jresult;
17687 }
17688
17689
17690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
17691   void * jresult ;
17692   Dali::PanGestureDetector::Property *result = 0 ;
17693
17694   {
17695     try {
17696       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
17697     } CALL_CATCH_EXCEPTION(0);
17698   }
17699
17700   jresult = (void *)result;
17701   return jresult;
17702 }
17703
17704
17705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
17706   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
17707
17708   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
17709   {
17710     try {
17711       delete arg1;
17712     } CALL_CATCH_EXCEPTION();
17713   }
17714
17715 }
17716
17717
17718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
17719   void * jresult ;
17720   Dali::Radian *result = 0 ;
17721
17722   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
17723   jresult = (void *)result;
17724   return jresult;
17725 }
17726
17727
17728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
17729   void * jresult ;
17730   Dali::Radian *result = 0 ;
17731
17732   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
17733   jresult = (void *)result;
17734   return jresult;
17735 }
17736
17737
17738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
17739   void * jresult ;
17740   Dali::Radian *result = 0 ;
17741
17742   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
17743   jresult = (void *)result;
17744   return jresult;
17745 }
17746
17747
17748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
17749   void * jresult ;
17750   Dali::Radian *result = 0 ;
17751
17752   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
17753   jresult = (void *)result;
17754   return jresult;
17755 }
17756
17757
17758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
17759   void * jresult ;
17760   Dali::Radian *result = 0 ;
17761
17762   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
17763   jresult = (void *)result;
17764   return jresult;
17765 }
17766
17767
17768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
17769   void * jresult ;
17770   Dali::Radian *result = 0 ;
17771
17772   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
17773   jresult = (void *)result;
17774   return jresult;
17775 }
17776
17777
17778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
17779   void * jresult ;
17780   Dali::Radian *result = 0 ;
17781
17782   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
17783   jresult = (void *)result;
17784   return jresult;
17785 }
17786
17787
17788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
17789   void * jresult ;
17790   Dali::PanGestureDetector *result = 0 ;
17791
17792   {
17793     try {
17794       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
17795     } CALL_CATCH_EXCEPTION(0);
17796   }
17797
17798   jresult = (void *)result;
17799   return jresult;
17800 }
17801
17802
17803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
17804   void * jresult ;
17805   Dali::PanGestureDetector result;
17806
17807   {
17808     try {
17809       result = Dali::PanGestureDetector::New();
17810     } CALL_CATCH_EXCEPTION(0);
17811   }
17812
17813   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
17814   return jresult;
17815 }
17816
17817
17818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
17819   void * jresult ;
17820   Dali::BaseHandle arg1 ;
17821   Dali::BaseHandle *argp1 ;
17822   Dali::PanGestureDetector result;
17823
17824   argp1 = (Dali::BaseHandle *)jarg1;
17825   if (!argp1) {
17826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17827     return 0;
17828   }
17829   arg1 = *argp1;
17830   {
17831     try {
17832       result = Dali::PanGestureDetector::DownCast(arg1);
17833     } CALL_CATCH_EXCEPTION(0);
17834   }
17835
17836   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
17837   return jresult;
17838 }
17839
17840
17841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
17842   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17843
17844   arg1 = (Dali::PanGestureDetector *)jarg1;
17845   {
17846     try {
17847       delete arg1;
17848     } CALL_CATCH_EXCEPTION();
17849   }
17850
17851 }
17852
17853
17854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
17855   void * jresult ;
17856   Dali::PanGestureDetector *arg1 = 0 ;
17857   Dali::PanGestureDetector *result = 0 ;
17858
17859   arg1 = (Dali::PanGestureDetector *)jarg1;
17860   if (!arg1) {
17861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
17862     return 0;
17863   }
17864   {
17865     try {
17866       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
17867     } CALL_CATCH_EXCEPTION(0);
17868   }
17869
17870   jresult = (void *)result;
17871   return jresult;
17872 }
17873
17874
17875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
17876   void * jresult ;
17877   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17878   Dali::PanGestureDetector *arg2 = 0 ;
17879   Dali::PanGestureDetector *result = 0 ;
17880
17881   arg1 = (Dali::PanGestureDetector *)jarg1;
17882   arg2 = (Dali::PanGestureDetector *)jarg2;
17883   if (!arg2) {
17884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
17885     return 0;
17886   }
17887   {
17888     try {
17889       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
17890     } CALL_CATCH_EXCEPTION(0);
17891   }
17892
17893   jresult = (void *)result;
17894   return jresult;
17895 }
17896
17897
17898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
17899   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17900   unsigned int arg2 ;
17901
17902   arg1 = (Dali::PanGestureDetector *)jarg1;
17903   arg2 = (unsigned int)jarg2;
17904   {
17905     try {
17906       (arg1)->SetMinimumTouchesRequired(arg2);
17907     } CALL_CATCH_EXCEPTION();
17908   }
17909
17910 }
17911
17912
17913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
17914   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17915   unsigned int arg2 ;
17916
17917   arg1 = (Dali::PanGestureDetector *)jarg1;
17918   arg2 = (unsigned int)jarg2;
17919   {
17920     try {
17921       (arg1)->SetMaximumTouchesRequired(arg2);
17922     } CALL_CATCH_EXCEPTION();
17923   }
17924
17925 }
17926
17927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumMotionEventAge(void * jarg1, unsigned int jarg2) {
17928   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17929   uint32_t arg2 ;
17930
17931   arg1 = (Dali::PanGestureDetector *)jarg1;
17932   arg2 = (uint32_t)jarg2;
17933   {
17934     try {
17935       (arg1)->SetMaximumMotionEventAge(arg2);
17936     } CALL_CATCH_EXCEPTION();
17937   }
17938
17939 }
17940
17941
17942 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
17943   unsigned int jresult ;
17944   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17945   unsigned int result;
17946
17947   arg1 = (Dali::PanGestureDetector *)jarg1;
17948   {
17949     try {
17950       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
17951     } CALL_CATCH_EXCEPTION(0);
17952   }
17953
17954   jresult = result;
17955   return jresult;
17956 }
17957
17958
17959 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
17960   unsigned int jresult ;
17961   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17962   unsigned int result;
17963
17964   arg1 = (Dali::PanGestureDetector *)jarg1;
17965   {
17966     try {
17967       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
17968     } CALL_CATCH_EXCEPTION(0);
17969   }
17970
17971   jresult = result;
17972   return jresult;
17973 }
17974
17975 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumMotionEventAge(void * jarg1) {
17976   unsigned int jresult ;
17977   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17978   uint32_t result;
17979
17980   arg1 = (Dali::PanGestureDetector *)jarg1;
17981   {
17982     try {
17983       result = (uint32_t)((Dali::PanGestureDetector const *)arg1)->GetMaximumMotionEventAge();
17984     } CALL_CATCH_EXCEPTION(0);
17985   }
17986
17987   jresult = result;
17988   return jresult;
17989 }
17990
17991
17992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
17993   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17994   Dali::Radian arg2 ;
17995   Dali::Radian arg3 ;
17996   Dali::Radian *argp2 ;
17997   Dali::Radian *argp3 ;
17998
17999   arg1 = (Dali::PanGestureDetector *)jarg1;
18000   argp2 = (Dali::Radian *)jarg2;
18001   if (!argp2) {
18002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
18003     return ;
18004   }
18005   arg2 = *argp2;
18006   argp3 = (Dali::Radian *)jarg3;
18007   if (!argp3) {
18008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
18009     return ;
18010   }
18011   arg3 = *argp3;
18012   {
18013     try {
18014       (arg1)->AddAngle(arg2,arg3);
18015     } CALL_CATCH_EXCEPTION();
18016   }
18017
18018 }
18019
18020
18021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
18022   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
18023   Dali::Radian arg2 ;
18024   Dali::Radian *argp2 ;
18025
18026   arg1 = (Dali::PanGestureDetector *)jarg1;
18027   argp2 = (Dali::Radian *)jarg2;
18028   if (!argp2) {
18029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
18030     return ;
18031   }
18032   arg2 = *argp2;
18033   {
18034     try {
18035       (arg1)->AddAngle(arg2);
18036     } CALL_CATCH_EXCEPTION();
18037   }
18038
18039 }
18040
18041
18042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
18043   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
18044   Dali::Radian arg2 ;
18045   Dali::Radian arg3 ;
18046   Dali::Radian *argp2 ;
18047   Dali::Radian *argp3 ;
18048
18049   arg1 = (Dali::PanGestureDetector *)jarg1;
18050   argp2 = (Dali::Radian *)jarg2;
18051   if (!argp2) {
18052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
18053     return ;
18054   }
18055   arg2 = *argp2;
18056   argp3 = (Dali::Radian *)jarg3;
18057   if (!argp3) {
18058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
18059     return ;
18060   }
18061   arg3 = *argp3;
18062   {
18063     try {
18064       (arg1)->AddDirection(arg2,arg3);
18065     } CALL_CATCH_EXCEPTION();
18066   }
18067
18068 }
18069
18070
18071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
18072   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
18073   Dali::Radian arg2 ;
18074   Dali::Radian *argp2 ;
18075
18076   arg1 = (Dali::PanGestureDetector *)jarg1;
18077   argp2 = (Dali::Radian *)jarg2;
18078   if (!argp2) {
18079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
18080     return ;
18081   }
18082   arg2 = *argp2;
18083   {
18084     try {
18085       (arg1)->AddDirection(arg2);
18086     } CALL_CATCH_EXCEPTION();
18087   }
18088
18089 }
18090
18091
18092 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
18093   unsigned long jresult ;
18094   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
18095   size_t result;
18096
18097   arg1 = (Dali::PanGestureDetector *)jarg1;
18098   {
18099     try {
18100       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
18101     } CALL_CATCH_EXCEPTION(0);
18102   }
18103
18104   jresult = (unsigned long)result;
18105   return jresult;
18106 }
18107
18108
18109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
18110   void * jresult ;
18111   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
18112   size_t arg2 ;
18113   Dali::PanGestureDetector::AngleThresholdPair result;
18114
18115   arg1 = (Dali::PanGestureDetector *)jarg1;
18116   arg2 = (size_t)jarg2;
18117   {
18118     try {
18119       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
18120     } CALL_CATCH_EXCEPTION(0);
18121   }
18122
18123   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
18124   return jresult;
18125 }
18126
18127
18128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
18129   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
18130
18131   arg1 = (Dali::PanGestureDetector *)jarg1;
18132   {
18133     try {
18134       (arg1)->ClearAngles();
18135     } CALL_CATCH_EXCEPTION();
18136   }
18137
18138 }
18139
18140
18141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
18142   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
18143   Dali::Radian arg2 ;
18144   Dali::Radian *argp2 ;
18145
18146   arg1 = (Dali::PanGestureDetector *)jarg1;
18147   argp2 = (Dali::Radian *)jarg2;
18148   if (!argp2) {
18149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
18150     return ;
18151   }
18152   arg2 = *argp2;
18153   {
18154     try {
18155       (arg1)->RemoveAngle(arg2);
18156     } CALL_CATCH_EXCEPTION();
18157   }
18158
18159 }
18160
18161
18162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
18163   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
18164   Dali::Radian arg2 ;
18165   Dali::Radian *argp2 ;
18166
18167   arg1 = (Dali::PanGestureDetector *)jarg1;
18168   argp2 = (Dali::Radian *)jarg2;
18169   if (!argp2) {
18170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
18171     return ;
18172   }
18173   arg2 = *argp2;
18174   {
18175     try {
18176       (arg1)->RemoveDirection(arg2);
18177     } CALL_CATCH_EXCEPTION();
18178   }
18179
18180 }
18181
18182
18183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
18184   void * jresult ;
18185   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
18186   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
18187
18188   arg1 = (Dali::PanGestureDetector *)jarg1;
18189   {
18190     try {
18191       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
18192     } CALL_CATCH_EXCEPTION(0);
18193   }
18194
18195   jresult = (void *)result;
18196   return jresult;
18197 }
18198
18199
18200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
18201   Dali::PanGesture *arg1 = 0 ;
18202
18203   arg1 = (Dali::PanGesture *)jarg1;
18204   if (!arg1) {
18205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
18206     return ;
18207   }
18208   {
18209     try {
18210       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
18211     } CALL_CATCH_EXCEPTION();
18212   }
18213
18214 }
18215
18216
18217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
18218   void * jresult ;
18219   Dali::PanGesture *result = 0 ;
18220
18221   {
18222     try {
18223       result = (Dali::PanGesture *)new Dali::PanGesture();
18224     } CALL_CATCH_EXCEPTION(0);
18225   }
18226
18227   jresult = (void *)result;
18228   return jresult;
18229 }
18230
18231
18232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_New(int jarg1) {
18233   void * jresult ;
18234   Dali::GestureState arg1 ;
18235   Dali::PanGesture result;
18236
18237   arg1 = (Dali::GestureState)jarg1;
18238   {
18239     try {
18240       result = DevelPanGesture::New(arg1);
18241     } CALL_CATCH_EXCEPTION(0);
18242   }
18243
18244   jresult = new Dali::PanGesture((const Dali::PanGesture &)result);
18245   return jresult;
18246 }
18247
18248
18249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
18250   void * jresult ;
18251   Dali::PanGesture *arg1 = 0 ;
18252   Dali::PanGesture *result = 0 ;
18253
18254   arg1 = (Dali::PanGesture *)jarg1;
18255   if (!arg1) {
18256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
18257     return 0;
18258   }
18259   {
18260     try {
18261       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
18262     } CALL_CATCH_EXCEPTION(0);
18263   }
18264
18265   jresult = (void *)result;
18266   return jresult;
18267 }
18268
18269
18270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
18271   void * jresult ;
18272   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18273   Dali::PanGesture *arg2 = 0 ;
18274   Dali::PanGesture *result = 0 ;
18275
18276   arg1 = (Dali::PanGesture *)jarg1;
18277   arg2 = (Dali::PanGesture *)jarg2;
18278   if (!arg2) {
18279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
18280     return 0;
18281   }
18282   {
18283     try {
18284       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
18285     } CALL_CATCH_EXCEPTION(0);
18286   }
18287
18288   jresult = (void *)result;
18289   return jresult;
18290 }
18291
18292
18293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
18294   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18295
18296   arg1 = (Dali::PanGesture *)jarg1;
18297   {
18298     try {
18299       delete arg1;
18300     } CALL_CATCH_EXCEPTION();
18301   }
18302
18303 }
18304
18305
18306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
18307   void * jresult ;
18308   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18309   Dali::Vector2 result;
18310
18311   arg1 = (Dali::PanGesture *)jarg1;
18312   {
18313     try {
18314       result = ((Dali::PanGesture const *)arg1)->GetVelocity();
18315     } catch (std::out_of_range& e) {
18316       {
18317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18318       };
18319     } catch (std::exception& e) {
18320       {
18321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18322       };
18323     } catch (Dali::DaliException e) {
18324       {
18325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18326       };
18327     } catch (...) {
18328       {
18329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18330       };
18331     }
18332   }
18333   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18334   return jresult;
18335 }
18336
18337
18338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
18339   void * jresult ;
18340   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18341   Dali::Vector2 result;
18342
18343   arg1 = (Dali::PanGesture *)jarg1;
18344   {
18345     try {
18346       result = ((Dali::PanGesture const *)arg1)->GetDisplacement();
18347     } catch (std::out_of_range& e) {
18348       {
18349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18350       };
18351     } catch (std::exception& e) {
18352       {
18353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18354       };
18355     } catch (Dali::DaliException e) {
18356       {
18357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18358       };
18359     } catch (...) {
18360       {
18361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18362       };
18363     }
18364   }
18365   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18366   return jresult;
18367 }
18368
18369
18370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
18371   void * jresult ;
18372   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18373   Dali::Vector2 result;
18374
18375   arg1 = (Dali::PanGesture *)jarg1;
18376   {
18377     try {
18378       result = ((Dali::PanGesture const *)arg1)->GetPosition();
18379     } catch (std::out_of_range& e) {
18380       {
18381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18382       };
18383     } catch (std::exception& e) {
18384       {
18385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18386       };
18387     } catch (Dali::DaliException e) {
18388       {
18389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18390       };
18391     } catch (...) {
18392       {
18393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18394       };
18395     }
18396   }
18397   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18398   return jresult;
18399 }
18400
18401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
18402   void * jresult ;
18403   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18404   Dali::Vector2 result;
18405
18406   arg1 = (Dali::PanGesture *)jarg1;
18407   {
18408     try {
18409       result = ((Dali::PanGesture const *)arg1)->GetScreenVelocity();
18410     } catch (std::out_of_range& e) {
18411       {
18412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18413       };
18414     } catch (std::exception& e) {
18415       {
18416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18417       };
18418     } catch (Dali::DaliException e) {
18419       {
18420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18421       };
18422     } catch (...) {
18423       {
18424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18425       };
18426     }
18427   }
18428   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18429   return jresult;
18430 }
18431
18432
18433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
18434   void * jresult ;
18435   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18436   Dali::Vector2 result;
18437
18438   arg1 = (Dali::PanGesture *)jarg1;
18439   {
18440     try {
18441       result = ((Dali::PanGesture const *)arg1)->GetScreenDisplacement();
18442     } catch (std::out_of_range& e) {
18443       {
18444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18445       };
18446     } catch (std::exception& e) {
18447       {
18448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18449       };
18450     } catch (Dali::DaliException e) {
18451       {
18452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18453       };
18454     } catch (...) {
18455       {
18456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18457       };
18458     }
18459   }
18460   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18461   return jresult;
18462 }
18463
18464
18465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
18466   void * jresult ;
18467   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18468   Dali::Vector2 result;
18469
18470   arg1 = (Dali::PanGesture *)jarg1;
18471   {
18472     try {
18473       result = ((Dali::PanGesture const *)arg1)->GetScreenPosition();
18474     } catch (std::out_of_range& e) {
18475       {
18476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18477       };
18478     } catch (std::exception& e) {
18479       {
18480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18481       };
18482     } catch (Dali::DaliException e) {
18483       {
18484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18485       };
18486     } catch (...) {
18487       {
18488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18489       };
18490     }
18491   }
18492   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18493   return jresult;
18494 }
18495
18496
18497 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
18498   unsigned int jresult ;
18499   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18500   unsigned int result;
18501
18502   arg1 = (Dali::PanGesture *)jarg1;
18503   result = (unsigned int) ((arg1)->GetNumberOfTouches());
18504   jresult = result;
18505   return jresult;
18506 }
18507
18508
18509 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
18510   float jresult ;
18511   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18512   float result;
18513
18514   arg1 = (Dali::PanGesture *)jarg1;
18515   {
18516     try {
18517       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
18518     } CALL_CATCH_EXCEPTION(0);
18519   }
18520
18521   jresult = result;
18522   return jresult;
18523 }
18524
18525
18526 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
18527   float jresult ;
18528   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18529   float result;
18530
18531   arg1 = (Dali::PanGesture *)jarg1;
18532   {
18533     try {
18534       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
18535     } CALL_CATCH_EXCEPTION(0);
18536   }
18537
18538   jresult = result;
18539   return jresult;
18540 }
18541
18542
18543 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
18544   float jresult ;
18545   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18546   float result;
18547
18548   arg1 = (Dali::PanGesture *)jarg1;
18549   {
18550     try {
18551       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
18552     } CALL_CATCH_EXCEPTION(0);
18553   }
18554
18555   jresult = result;
18556   return jresult;
18557 }
18558
18559
18560 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
18561   float jresult ;
18562   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18563   float result;
18564
18565   arg1 = (Dali::PanGesture *)jarg1;
18566   {
18567     try {
18568       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
18569     } CALL_CATCH_EXCEPTION(0);
18570   }
18571
18572   jresult = result;
18573   return jresult;
18574 }
18575
18576
18577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
18578   void * jresult ;
18579   Dali::PinchGestureDetector *result = 0 ;
18580
18581   {
18582     try {
18583       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
18584     } CALL_CATCH_EXCEPTION(0);
18585   }
18586
18587   jresult = (void *)result;
18588   return jresult;
18589 }
18590
18591
18592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
18593   void * jresult ;
18594   Dali::PinchGestureDetector result;
18595
18596   {
18597     try {
18598       result = Dali::PinchGestureDetector::New();
18599     } CALL_CATCH_EXCEPTION(0);
18600   }
18601
18602   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
18603   return jresult;
18604 }
18605
18606
18607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
18608   void * jresult ;
18609   Dali::BaseHandle arg1 ;
18610   Dali::BaseHandle *argp1 ;
18611   Dali::PinchGestureDetector result;
18612
18613   argp1 = (Dali::BaseHandle *)jarg1;
18614   if (!argp1) {
18615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
18616     return 0;
18617   }
18618   arg1 = *argp1;
18619   {
18620     try {
18621       result = Dali::PinchGestureDetector::DownCast(arg1);
18622     } CALL_CATCH_EXCEPTION(0);
18623   }
18624
18625   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
18626   return jresult;
18627 }
18628
18629
18630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
18631   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
18632
18633   arg1 = (Dali::PinchGestureDetector *)jarg1;
18634   {
18635     try {
18636       delete arg1;
18637     } CALL_CATCH_EXCEPTION();
18638   }
18639
18640 }
18641
18642
18643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
18644   void * jresult ;
18645   Dali::PinchGestureDetector *arg1 = 0 ;
18646   Dali::PinchGestureDetector *result = 0 ;
18647
18648   arg1 = (Dali::PinchGestureDetector *)jarg1;
18649   if (!arg1) {
18650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
18651     return 0;
18652   }
18653   {
18654     try {
18655       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
18656     } CALL_CATCH_EXCEPTION(0);
18657   }
18658
18659   jresult = (void *)result;
18660   return jresult;
18661 }
18662
18663
18664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
18665   void * jresult ;
18666   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
18667   Dali::PinchGestureDetector *arg2 = 0 ;
18668   Dali::PinchGestureDetector *result = 0 ;
18669
18670   arg1 = (Dali::PinchGestureDetector *)jarg1;
18671   arg2 = (Dali::PinchGestureDetector *)jarg2;
18672   if (!arg2) {
18673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
18674     return 0;
18675   }
18676   {
18677     try {
18678       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
18679     } CALL_CATCH_EXCEPTION(0);
18680   }
18681
18682   jresult = (void *)result;
18683   return jresult;
18684 }
18685
18686
18687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
18688   void * jresult ;
18689   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
18690   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
18691
18692   arg1 = (Dali::PinchGestureDetector *)jarg1;
18693   {
18694     try {
18695       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
18696     } CALL_CATCH_EXCEPTION(0);
18697   }
18698
18699   jresult = (void *)result;
18700   return jresult;
18701 }
18702
18703
18704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0() {
18705   void * jresult ;
18706   Dali::PinchGesture *result = 0 ;
18707
18708   {
18709     try {
18710       result = (Dali::PinchGesture *)new Dali::PinchGesture();
18711     } CALL_CATCH_EXCEPTION(0);
18712   }
18713
18714   jresult = (void *)result;
18715   return jresult;
18716 }
18717
18718
18719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_New(int jarg1) {
18720   void * jresult ;
18721   Dali::GestureState arg1 ;
18722   Dali::PinchGesture result;
18723
18724   arg1 = (Dali::GestureState)jarg1;
18725   {
18726     try {
18727       result = DevelPinchGesture::New(arg1);
18728     } CALL_CATCH_EXCEPTION(0);
18729   }
18730
18731   jresult = new Dali::PinchGesture((const Dali::PinchGesture &)result);
18732   return jresult;
18733 }
18734
18735
18736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
18737   void * jresult ;
18738   Dali::PinchGesture *arg1 = 0 ;
18739   Dali::PinchGesture *result = 0 ;
18740
18741   arg1 = (Dali::PinchGesture *)jarg1;
18742   if (!arg1) {
18743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
18744     return 0;
18745   }
18746   {
18747     try {
18748       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
18749     } CALL_CATCH_EXCEPTION(0);
18750   }
18751
18752   jresult = (void *)result;
18753   return jresult;
18754 }
18755
18756
18757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
18758   void * jresult ;
18759   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
18760   Dali::PinchGesture *arg2 = 0 ;
18761   Dali::PinchGesture *result = 0 ;
18762
18763   arg1 = (Dali::PinchGesture *)jarg1;
18764   arg2 = (Dali::PinchGesture *)jarg2;
18765   if (!arg2) {
18766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
18767     return 0;
18768   }
18769   {
18770     try {
18771       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
18772     } CALL_CATCH_EXCEPTION(0);
18773   }
18774
18775   jresult = (void *)result;
18776   return jresult;
18777 }
18778
18779
18780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
18781   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
18782
18783   arg1 = (Dali::PinchGesture *)jarg1;
18784   {
18785     try {
18786       delete arg1;
18787     } CALL_CATCH_EXCEPTION();
18788   }
18789
18790 }
18791
18792
18793 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
18794   float jresult ;
18795   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
18796   float result;
18797
18798   arg1 = (Dali::PinchGesture *)jarg1;
18799   result = (float) ((arg1)->GetScale());
18800   jresult = result;
18801   return jresult;
18802 }
18803
18804
18805 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
18806   float jresult ;
18807   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
18808   float result;
18809
18810   arg1 = (Dali::PinchGesture *)jarg1;
18811   result = (float) ((arg1)->GetSpeed());
18812   jresult = result;
18813   return jresult;
18814 }
18815
18816
18817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
18818   void * jresult ;
18819   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
18820   Dali::Vector2 result;
18821
18822   arg1 = (Dali::PinchGesture *)jarg1;
18823   {
18824     try {
18825       result = ((Dali::PinchGesture const *)arg1)->GetScreenCenterPoint();
18826     } catch (std::out_of_range& e) {
18827       {
18828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18829       };
18830     } catch (std::exception& e) {
18831       {
18832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18833       };
18834     } catch (Dali::DaliException e) {
18835       {
18836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18837       };
18838     } catch (...) {
18839       {
18840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18841       };
18842     }
18843   }
18844   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18845   return jresult;
18846 }
18847
18848
18849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
18850   void * jresult ;
18851   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
18852   Dali::Vector2 result;
18853
18854   arg1 = (Dali::PinchGesture *)jarg1;
18855   {
18856     try {
18857       result = ((Dali::PinchGesture const *)arg1)->GetLocalCenterPoint();
18858     } catch (std::out_of_range& e) {
18859       {
18860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18861       };
18862     } catch (std::exception& e) {
18863       {
18864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18865       };
18866     } catch (Dali::DaliException e) {
18867       {
18868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18869       };
18870     } catch (...) {
18871       {
18872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18873       };
18874     }
18875   }
18876   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18877   return jresult;
18878 }
18879
18880
18881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
18882   void * jresult ;
18883   Dali::TapGestureDetector *result = 0 ;
18884
18885   {
18886     try {
18887       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
18888     } CALL_CATCH_EXCEPTION(0);
18889   }
18890
18891   jresult = (void *)result;
18892   return jresult;
18893 }
18894
18895
18896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
18897   void * jresult ;
18898   Dali::TapGestureDetector result;
18899
18900   {
18901     try {
18902       result = Dali::TapGestureDetector::New();
18903     } CALL_CATCH_EXCEPTION(0);
18904   }
18905
18906   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
18907   return jresult;
18908 }
18909
18910
18911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
18912   void * jresult ;
18913   unsigned int arg1 ;
18914   Dali::TapGestureDetector result;
18915
18916   arg1 = (unsigned int)jarg1;
18917   {
18918     try {
18919       result = Dali::TapGestureDetector::New(arg1);
18920     } CALL_CATCH_EXCEPTION(0);
18921   }
18922
18923   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
18924   return jresult;
18925 }
18926
18927
18928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
18929   void * jresult ;
18930   Dali::BaseHandle arg1 ;
18931   Dali::BaseHandle *argp1 ;
18932   Dali::TapGestureDetector result;
18933
18934   argp1 = (Dali::BaseHandle *)jarg1;
18935   if (!argp1) {
18936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
18937     return 0;
18938   }
18939   arg1 = *argp1;
18940   {
18941     try {
18942       result = Dali::TapGestureDetector::DownCast(arg1);
18943     } CALL_CATCH_EXCEPTION(0);
18944   }
18945
18946   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
18947   return jresult;
18948 }
18949
18950
18951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
18952   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
18953
18954   arg1 = (Dali::TapGestureDetector *)jarg1;
18955   {
18956     try {
18957       delete arg1;
18958     } CALL_CATCH_EXCEPTION();
18959   }
18960
18961 }
18962
18963
18964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
18965   void * jresult ;
18966   Dali::TapGestureDetector *arg1 = 0 ;
18967   Dali::TapGestureDetector *result = 0 ;
18968
18969   arg1 = (Dali::TapGestureDetector *)jarg1;
18970   if (!arg1) {
18971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
18972     return 0;
18973   }
18974   {
18975     try {
18976       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
18977     } CALL_CATCH_EXCEPTION(0);
18978   }
18979
18980   jresult = (void *)result;
18981   return jresult;
18982 }
18983
18984
18985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
18986   void * jresult ;
18987   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
18988   Dali::TapGestureDetector *arg2 = 0 ;
18989   Dali::TapGestureDetector *result = 0 ;
18990
18991   arg1 = (Dali::TapGestureDetector *)jarg1;
18992   arg2 = (Dali::TapGestureDetector *)jarg2;
18993   if (!arg2) {
18994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
18995     return 0;
18996   }
18997   {
18998     try {
18999       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
19000     } CALL_CATCH_EXCEPTION(0);
19001   }
19002
19003   jresult = (void *)result;
19004   return jresult;
19005 }
19006
19007
19008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
19009   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
19010   unsigned int arg2 ;
19011
19012   arg1 = (Dali::TapGestureDetector *)jarg1;
19013   arg2 = (unsigned int)jarg2;
19014   {
19015     try {
19016       (arg1)->SetMinimumTapsRequired(arg2);
19017     } CALL_CATCH_EXCEPTION();
19018   }
19019
19020 }
19021
19022
19023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
19024   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
19025   unsigned int arg2 ;
19026
19027   arg1 = (Dali::TapGestureDetector *)jarg1;
19028   arg2 = (unsigned int)jarg2;
19029   {
19030     try {
19031       (arg1)->SetMaximumTapsRequired(arg2);
19032     } CALL_CATCH_EXCEPTION();
19033   }
19034
19035 }
19036
19037
19038 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
19039   unsigned int jresult ;
19040   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
19041   unsigned int result;
19042
19043   arg1 = (Dali::TapGestureDetector *)jarg1;
19044   {
19045     try {
19046       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
19047     } CALL_CATCH_EXCEPTION(0);
19048   }
19049
19050   jresult = result;
19051   return jresult;
19052 }
19053
19054
19055 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
19056   unsigned int jresult ;
19057   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
19058   unsigned int result;
19059
19060   arg1 = (Dali::TapGestureDetector *)jarg1;
19061   {
19062     try {
19063       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
19064     } CALL_CATCH_EXCEPTION(0);
19065   }
19066
19067   jresult = result;
19068   return jresult;
19069 }
19070
19071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_ReceiveAllTapEvents(void * tapGestureDetector, bool isReceive) {
19072   Dali::TapGestureDetector *detector = (Dali::TapGestureDetector *) 0 ;
19073
19074   detector = (Dali::TapGestureDetector *)tapGestureDetector;
19075   if (!detector) {
19076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
19077     return;
19078   }
19079   {
19080     try {
19081       (detector)->ReceiveAllTapEvents(isReceive);
19082     } CALL_CATCH_EXCEPTION();
19083   }
19084
19085 }
19086
19087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
19088   void * jresult ;
19089   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
19090   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
19091
19092   arg1 = (Dali::TapGestureDetector *)jarg1;
19093   {
19094     try {
19095       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
19096     } CALL_CATCH_EXCEPTION(0);
19097   }
19098
19099   jresult = (void *)result;
19100   return jresult;
19101 }
19102
19103
19104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
19105   void * jresult ;
19106   Dali::TapGesture *result = 0 ;
19107
19108   {
19109     try {
19110       result = (Dali::TapGesture *)new Dali::TapGesture();
19111     } CALL_CATCH_EXCEPTION(0);
19112   }
19113
19114   jresult = (void *)result;
19115   return jresult;
19116 }
19117
19118
19119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_New(int jarg1) {
19120   void * jresult ;
19121   Dali::GestureState arg1 ;
19122   Dali::TapGesture result;
19123
19124   arg1 = (Dali::GestureState)jarg1;
19125   {
19126     try {
19127       result = DevelTapGesture::New(arg1);
19128     } CALL_CATCH_EXCEPTION(0);
19129   }
19130
19131   jresult = new Dali::TapGesture((const Dali::TapGesture &)result);
19132   return jresult;
19133 }
19134
19135
19136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
19137   void * jresult ;
19138   Dali::TapGesture *arg1 = 0 ;
19139   Dali::TapGesture *result = 0 ;
19140
19141   arg1 = (Dali::TapGesture *)jarg1;
19142   if (!arg1) {
19143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
19144     return 0;
19145   }
19146   {
19147     try {
19148       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
19149     } CALL_CATCH_EXCEPTION(0);
19150   }
19151
19152   jresult = (void *)result;
19153   return jresult;
19154 }
19155
19156
19157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
19158   void * jresult ;
19159   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
19160   Dali::TapGesture *arg2 = 0 ;
19161   Dali::TapGesture *result = 0 ;
19162
19163   arg1 = (Dali::TapGesture *)jarg1;
19164   arg2 = (Dali::TapGesture *)jarg2;
19165   if (!arg2) {
19166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
19167     return 0;
19168   }
19169   {
19170     try {
19171       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
19172     } CALL_CATCH_EXCEPTION(0);
19173   }
19174
19175   jresult = (void *)result;
19176   return jresult;
19177 }
19178
19179
19180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
19181   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
19182
19183   arg1 = (Dali::TapGesture *)jarg1;
19184   {
19185     try {
19186       delete arg1;
19187     } CALL_CATCH_EXCEPTION();
19188   }
19189
19190 }
19191
19192
19193 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
19194   unsigned int jresult ;
19195   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
19196   unsigned int result;
19197
19198   arg1 = (Dali::TapGesture *)jarg1;
19199   result = (unsigned int) ((arg1)->GetNumberOfTaps());
19200   jresult = result;
19201   return jresult;
19202 }
19203
19204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
19205   unsigned int jresult ;
19206   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
19207   unsigned int result;
19208
19209   arg1 = (Dali::TapGesture *)jarg1;
19210   result = (unsigned int) ((arg1)->GetNumberOfTouches());
19211   jresult = result;
19212   return jresult;
19213 }
19214
19215
19216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
19217   void * jresult ;
19218   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
19219   Dali::Vector2 result;
19220
19221   arg1 = (Dali::TapGesture *)jarg1;
19222   {
19223     try {
19224       result = ((Dali::TapGesture const *)arg1)->GetScreenPoint();
19225     } catch (std::out_of_range& e) {
19226       {
19227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19228       };
19229     } catch (std::exception& e) {
19230       {
19231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19232       };
19233     } catch (Dali::DaliException e) {
19234       {
19235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19236       };
19237     } catch (...) {
19238       {
19239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19240       };
19241     }
19242   }
19243   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
19244   return jresult;
19245 }
19246
19247
19248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
19249   void * jresult ;
19250   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
19251   Dali::Vector2 result;
19252
19253   arg1 = (Dali::TapGesture *)jarg1;
19254   {
19255     try {
19256       result = ((Dali::TapGesture const *)arg1)->GetLocalPoint();
19257     } catch (std::out_of_range& e) {
19258       {
19259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19260       };
19261     } catch (std::exception& e) {
19262       {
19263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19264       };
19265     } catch (Dali::DaliException e) {
19266       {
19267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19268       };
19269     } catch (...) {
19270       {
19271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19272       };
19273     }
19274   }
19275   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
19276   return jresult;
19277 }
19278
19279
19280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
19281   void * jresult ;
19282   Dali::AlphaFunction *result = 0 ;
19283
19284   {
19285     try {
19286       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
19287     } CALL_CATCH_EXCEPTION(0);
19288   }
19289
19290   jresult = (void *)result;
19291   return jresult;
19292 }
19293
19294
19295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
19296   void * jresult ;
19297   Dali::AlphaFunction::BuiltinFunction arg1 ;
19298   Dali::AlphaFunction *result = 0 ;
19299
19300   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
19301   {
19302     try {
19303       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
19304     } CALL_CATCH_EXCEPTION(0);
19305   }
19306
19307   jresult = (void *)result;
19308   return jresult;
19309 }
19310
19311
19312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
19313   void * jresult ;
19314   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
19315   Dali::AlphaFunction *result = 0 ;
19316
19317   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
19318   {
19319     try {
19320       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
19321     } CALL_CATCH_EXCEPTION(0);
19322   }
19323
19324   jresult = (void *)result;
19325   return jresult;
19326 }
19327
19328
19329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
19330   void * jresult ;
19331   Dali::Vector2 *arg1 = 0 ;
19332   Dali::Vector2 *arg2 = 0 ;
19333   Dali::AlphaFunction *result = 0 ;
19334
19335   arg1 = (Dali::Vector2 *)jarg1;
19336   if (!arg1) {
19337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
19338     return 0;
19339   }
19340   arg2 = (Dali::Vector2 *)jarg2;
19341   if (!arg2) {
19342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
19343     return 0;
19344   }
19345   {
19346     try {
19347       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
19348     } CALL_CATCH_EXCEPTION(0);
19349   }
19350
19351   jresult = (void *)result;
19352   return jresult;
19353 }
19354
19355
19356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
19357   void * jresult ;
19358   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
19359   Dali::Vector4 result;
19360
19361   arg1 = (Dali::AlphaFunction *)jarg1;
19362   {
19363     try {
19364       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
19365     } CALL_CATCH_EXCEPTION(0);
19366   }
19367
19368   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
19369   return jresult;
19370 }
19371
19372
19373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
19374   void * jresult ;
19375   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
19376   Dali::AlphaFunctionPrototype result;
19377
19378   arg1 = (Dali::AlphaFunction *)jarg1;
19379   {
19380     try {
19381       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
19382     } CALL_CATCH_EXCEPTION(0);
19383   }
19384
19385   jresult = (void *)result;
19386   return jresult;
19387 }
19388
19389
19390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
19391   int jresult ;
19392   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
19393   Dali::AlphaFunction::BuiltinFunction result;
19394
19395   arg1 = (Dali::AlphaFunction *)jarg1;
19396   {
19397     try {
19398       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
19399     } CALL_CATCH_EXCEPTION(0);
19400   }
19401
19402   jresult = (int)result;
19403   return jresult;
19404 }
19405
19406
19407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
19408   int jresult ;
19409   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
19410   Dali::AlphaFunction::Mode result;
19411
19412   arg1 = (Dali::AlphaFunction *)jarg1;
19413   {
19414     try {
19415       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
19416     } CALL_CATCH_EXCEPTION(0);
19417   }
19418
19419   jresult = (int)result;
19420   return jresult;
19421 }
19422
19423
19424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
19425   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
19426
19427   arg1 = (Dali::AlphaFunction *)jarg1;
19428   {
19429     try {
19430       delete arg1;
19431     } CALL_CATCH_EXCEPTION();
19432   }
19433
19434 }
19435
19436
19437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
19438   void * jresult ;
19439   Dali::KeyFrames result;
19440
19441   {
19442     try {
19443       result = Dali::KeyFrames::New();
19444     } CALL_CATCH_EXCEPTION(0);
19445   }
19446
19447   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
19448   return jresult;
19449 }
19450
19451
19452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
19453   void * jresult ;
19454   Dali::BaseHandle arg1 ;
19455   Dali::BaseHandle *argp1 ;
19456   Dali::KeyFrames result;
19457
19458   argp1 = (Dali::BaseHandle *)jarg1;
19459   if (!argp1) {
19460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19461     return 0;
19462   }
19463   arg1 = *argp1;
19464   {
19465     try {
19466       result = Dali::KeyFrames::DownCast(arg1);
19467     } CALL_CATCH_EXCEPTION(0);
19468   }
19469
19470   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
19471   return jresult;
19472 }
19473
19474
19475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
19476   void * jresult ;
19477   Dali::KeyFrames *result = 0 ;
19478
19479   {
19480     try {
19481       result = (Dali::KeyFrames *)new Dali::KeyFrames();
19482     } CALL_CATCH_EXCEPTION(0);
19483   }
19484
19485   jresult = (void *)result;
19486   return jresult;
19487 }
19488
19489
19490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
19491   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
19492
19493   arg1 = (Dali::KeyFrames *)jarg1;
19494   {
19495     try {
19496       delete arg1;
19497     } CALL_CATCH_EXCEPTION();
19498   }
19499
19500 }
19501
19502
19503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
19504   void * jresult ;
19505   Dali::KeyFrames *arg1 = 0 ;
19506   Dali::KeyFrames *result = 0 ;
19507
19508   arg1 = (Dali::KeyFrames *)jarg1;
19509   if (!arg1) {
19510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
19511     return 0;
19512   }
19513   {
19514     try {
19515       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
19516     } CALL_CATCH_EXCEPTION(0);
19517   }
19518
19519   jresult = (void *)result;
19520   return jresult;
19521 }
19522
19523
19524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
19525   void * jresult ;
19526   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
19527   Dali::KeyFrames *arg2 = 0 ;
19528   Dali::KeyFrames *result = 0 ;
19529
19530   arg1 = (Dali::KeyFrames *)jarg1;
19531   arg2 = (Dali::KeyFrames *)jarg2;
19532   if (!arg2) {
19533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
19534     return 0;
19535   }
19536   {
19537     try {
19538       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
19539     } CALL_CATCH_EXCEPTION(0);
19540   }
19541
19542   jresult = (void *)result;
19543   return jresult;
19544 }
19545
19546
19547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
19548   int jresult ;
19549   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
19550   Dali::Property::Type result;
19551
19552   arg1 = (Dali::KeyFrames *)jarg1;
19553   {
19554     try {
19555       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
19556     } CALL_CATCH_EXCEPTION(0);
19557   }
19558
19559   jresult = (int)result;
19560   return jresult;
19561 }
19562
19563
19564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
19565   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
19566   float arg2 ;
19567   Dali::Property::Value arg3 ;
19568   Dali::Property::Value *argp3 ;
19569
19570   arg1 = (Dali::KeyFrames *)jarg1;
19571   arg2 = (float)jarg2;
19572   argp3 = (Dali::Property::Value *)jarg3;
19573   if (!argp3) {
19574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
19575     return ;
19576   }
19577   arg3 = *argp3;
19578   {
19579     try {
19580       (arg1)->Add(arg2,arg3);
19581     } CALL_CATCH_EXCEPTION();
19582   }
19583
19584 }
19585
19586
19587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
19588   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
19589   float arg2 ;
19590   Dali::Property::Value arg3 ;
19591   Dali::AlphaFunction arg4 ;
19592   Dali::Property::Value *argp3 ;
19593   Dali::AlphaFunction *argp4 ;
19594
19595   arg1 = (Dali::KeyFrames *)jarg1;
19596   arg2 = (float)jarg2;
19597   argp3 = (Dali::Property::Value *)jarg3;
19598   if (!argp3) {
19599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
19600     return ;
19601   }
19602   arg3 = *argp3;
19603   argp4 = (Dali::AlphaFunction *)jarg4;
19604   if (!argp4) {
19605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
19606     return ;
19607   }
19608   arg4 = *argp4;
19609   {
19610     try {
19611       (arg1)->Add(arg2,arg3,arg4);
19612     } CALL_CATCH_EXCEPTION();
19613   }
19614
19615 }
19616
19617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyFrames_GetKeyFrameCount(void* keyFrames)
19618 {
19619   unsigned int jresult;
19620   {
19621     try {
19622       jresult = Dali::DevelKeyFrames::GetKeyFrameCount(*((Dali::KeyFrames*)keyFrames));
19623     } CALL_CATCH_EXCEPTION(0);
19624   }
19625   return jresult;
19626 }
19627
19628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_GetKeyFrame(void* keyFrames, unsigned int index, float* time, void* value)
19629 {
19630   if (!value) {
19631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
19632     return ;
19633   }
19634   try {
19635     Dali::DevelKeyFrames::GetKeyFrame(*((Dali::KeyFrames*)keyFrames), (size_t)index, *time, *((Property::Value*)value));
19636   } CALL_CATCH_EXCEPTION();
19637 }
19638
19639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_SetKeyFrameValue(void* keyFrames, unsigned int index, void* value)
19640 {
19641   if (!value) {
19642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
19643     return ;
19644   }
19645   try {
19646     Dali::DevelKeyFrames::SetKeyFrameValue(*((Dali::KeyFrames*)keyFrames), (size_t)index, *((const Property::Value*)value));
19647   } CALL_CATCH_EXCEPTION();
19648 }
19649
19650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
19651   int jresult ;
19652   int result;
19653
19654   result = (int)Dali::Path::Property::POINTS;
19655   jresult = (int)result;
19656   return jresult;
19657 }
19658
19659
19660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
19661   int jresult ;
19662   int result;
19663
19664   result = (int)Dali::Path::Property::CONTROL_POINTS;
19665   jresult = (int)result;
19666   return jresult;
19667 }
19668
19669
19670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
19671   void * jresult ;
19672   Dali::Path::Property *result = 0 ;
19673
19674   {
19675     try {
19676       result = (Dali::Path::Property *)new Dali::Path::Property();
19677     } CALL_CATCH_EXCEPTION(0);
19678   }
19679
19680   jresult = (void *)result;
19681   return jresult;
19682 }
19683
19684
19685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
19686   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
19687
19688   arg1 = (Dali::Path::Property *)jarg1;
19689   {
19690     try {
19691       delete arg1;
19692     } CALL_CATCH_EXCEPTION();
19693   }
19694
19695 }
19696
19697
19698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
19699   void * jresult ;
19700   Dali::Path result;
19701
19702   {
19703     try {
19704       result = Dali::Path::New();
19705     } CALL_CATCH_EXCEPTION(0);
19706   }
19707
19708   jresult = new Dali::Path((const Dali::Path &)result);
19709   return jresult;
19710 }
19711
19712
19713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
19714   void * jresult ;
19715   Dali::BaseHandle arg1 ;
19716   Dali::BaseHandle *argp1 ;
19717   Dali::Path result;
19718
19719   argp1 = (Dali::BaseHandle *)jarg1;
19720   if (!argp1) {
19721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19722     return 0;
19723   }
19724   arg1 = *argp1;
19725   {
19726     try {
19727       result = Dali::Path::DownCast(arg1);
19728     } CALL_CATCH_EXCEPTION(0);
19729   }
19730
19731   jresult = new Dali::Path((const Dali::Path &)result);
19732   return jresult;
19733 }
19734
19735
19736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
19737   void * jresult ;
19738   Dali::Path *result = 0 ;
19739
19740   {
19741     try {
19742       result = (Dali::Path *)new Dali::Path();
19743     } CALL_CATCH_EXCEPTION(0);
19744   }
19745
19746   jresult = (void *)result;
19747   return jresult;
19748 }
19749
19750
19751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
19752   Dali::Path *arg1 = (Dali::Path *) 0 ;
19753
19754   arg1 = (Dali::Path *)jarg1;
19755   {
19756     try {
19757       delete arg1;
19758     } CALL_CATCH_EXCEPTION();
19759   }
19760
19761 }
19762
19763
19764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
19765   void * jresult ;
19766   Dali::Path *arg1 = 0 ;
19767   Dali::Path *result = 0 ;
19768
19769   arg1 = (Dali::Path *)jarg1;
19770   if (!arg1) {
19771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
19772     return 0;
19773   }
19774   {
19775     try {
19776       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
19777     } CALL_CATCH_EXCEPTION(0);
19778   }
19779
19780   jresult = (void *)result;
19781   return jresult;
19782 }
19783
19784
19785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
19786   void * jresult ;
19787   Dali::Path *arg1 = (Dali::Path *) 0 ;
19788   Dali::Path *arg2 = 0 ;
19789   Dali::Path *result = 0 ;
19790
19791   arg1 = (Dali::Path *)jarg1;
19792   arg2 = (Dali::Path *)jarg2;
19793   if (!arg2) {
19794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
19795     return 0;
19796   }
19797   {
19798     try {
19799       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
19800     } CALL_CATCH_EXCEPTION(0);
19801   }
19802
19803   jresult = (void *)result;
19804   return jresult;
19805 }
19806
19807
19808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
19809   Dali::Path *arg1 = (Dali::Path *) 0 ;
19810   Dali::Vector3 *arg2 = 0 ;
19811
19812   arg1 = (Dali::Path *)jarg1;
19813   arg2 = (Dali::Vector3 *)jarg2;
19814   if (!arg2) {
19815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
19816     return ;
19817   }
19818   {
19819     try {
19820       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
19821     } CALL_CATCH_EXCEPTION();
19822   }
19823
19824 }
19825
19826
19827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
19828   Dali::Path *arg1 = (Dali::Path *) 0 ;
19829   Dali::Vector3 *arg2 = 0 ;
19830
19831   arg1 = (Dali::Path *)jarg1;
19832   arg2 = (Dali::Vector3 *)jarg2;
19833   if (!arg2) {
19834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
19835     return ;
19836   }
19837   {
19838     try {
19839       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
19840     } CALL_CATCH_EXCEPTION();
19841   }
19842
19843 }
19844
19845
19846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
19847   Dali::Path *arg1 = (Dali::Path *) 0 ;
19848   float arg2 ;
19849
19850   arg1 = (Dali::Path *)jarg1;
19851   arg2 = (float)jarg2;
19852   {
19853     try {
19854       (arg1)->GenerateControlPoints(arg2);
19855     } CALL_CATCH_EXCEPTION();
19856   }
19857
19858 }
19859
19860
19861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
19862   Dali::Path *arg1 = (Dali::Path *) 0 ;
19863   float arg2 ;
19864   Dali::Vector3 *arg3 = 0 ;
19865   Dali::Vector3 *arg4 = 0 ;
19866
19867   arg1 = (Dali::Path *)jarg1;
19868   arg2 = (float)jarg2;
19869   arg3 = (Dali::Vector3 *)jarg3;
19870   if (!arg3) {
19871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
19872     return ;
19873   }
19874   arg4 = (Dali::Vector3 *)jarg4;
19875   if (!arg4) {
19876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
19877     return ;
19878   }
19879   {
19880     try {
19881       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
19882     } CALL_CATCH_EXCEPTION();
19883   }
19884
19885 }
19886
19887
19888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
19889   void * jresult ;
19890   Dali::Path *arg1 = (Dali::Path *) 0 ;
19891   size_t arg2 ;
19892   Dali::Vector3 *result = 0 ;
19893
19894   arg1 = (Dali::Path *)jarg1;
19895   arg2 = (size_t)jarg2;
19896   {
19897     try {
19898       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
19899     } CALL_CATCH_EXCEPTION(0);
19900   }
19901
19902   jresult = (void *)result;
19903   return jresult;
19904 }
19905
19906
19907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
19908   void * jresult ;
19909   Dali::Path *arg1 = (Dali::Path *) 0 ;
19910   size_t arg2 ;
19911   Dali::Vector3 *result = 0 ;
19912
19913   arg1 = (Dali::Path *)jarg1;
19914   arg2 = (size_t)jarg2;
19915   {
19916     try {
19917       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
19918     } CALL_CATCH_EXCEPTION(0);
19919   }
19920
19921   jresult = (void *)result;
19922   return jresult;
19923 }
19924
19925
19926 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
19927   unsigned long jresult ;
19928   Dali::Path *arg1 = (Dali::Path *) 0 ;
19929   size_t result;
19930
19931   arg1 = (Dali::Path *)jarg1;
19932   {
19933     try {
19934       result = ((Dali::Path const *)arg1)->GetPointCount();
19935     } CALL_CATCH_EXCEPTION(0);
19936   }
19937
19938   jresult = (unsigned long)result;
19939   return jresult;
19940 }
19941
19942
19943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
19944   void * jresult ;
19945   float arg1 ;
19946   Dali::TimePeriod *result = 0 ;
19947
19948   arg1 = (float)jarg1;
19949   {
19950     try {
19951       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
19952     } CALL_CATCH_EXCEPTION(0);
19953   }
19954
19955   jresult = (void *)result;
19956   return jresult;
19957 }
19958
19959
19960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
19961   void * jresult ;
19962   float arg1 ;
19963   float arg2 ;
19964   Dali::TimePeriod *result = 0 ;
19965
19966   arg1 = (float)jarg1;
19967   arg2 = (float)jarg2;
19968   {
19969     try {
19970       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
19971     } CALL_CATCH_EXCEPTION(0);
19972   }
19973
19974   jresult = (void *)result;
19975   return jresult;
19976 }
19977
19978
19979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
19980   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
19981
19982   arg1 = (Dali::TimePeriod *)jarg1;
19983   {
19984     try {
19985       delete arg1;
19986     } CALL_CATCH_EXCEPTION();
19987   }
19988
19989 }
19990
19991
19992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
19993   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
19994   float arg2 ;
19995
19996   arg1 = (Dali::TimePeriod *)jarg1;
19997   arg2 = (float)jarg2;
19998   if (arg1) (arg1)->delaySeconds = arg2;
19999 }
20000
20001
20002 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
20003   float jresult ;
20004   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
20005   float result;
20006
20007   arg1 = (Dali::TimePeriod *)jarg1;
20008   result = (float) ((arg1)->delaySeconds);
20009   jresult = result;
20010   return jresult;
20011 }
20012
20013
20014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
20015   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
20016   float arg2 ;
20017
20018   arg1 = (Dali::TimePeriod *)jarg1;
20019   arg2 = (float)jarg2;
20020   if (arg1) (arg1)->durationSeconds = arg2;
20021 }
20022
20023
20024 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
20025   float jresult ;
20026   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
20027   float result;
20028
20029   arg1 = (Dali::TimePeriod *)jarg1;
20030   result = (float) ((arg1)->durationSeconds);
20031   jresult = result;
20032   return jresult;
20033 }
20034
20035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
20036   int jresult ;
20037   int result;
20038
20039   result = (int)Dali::LinearConstrainer::Property::VALUE;
20040   jresult = (int)result;
20041   return jresult;
20042 }
20043
20044
20045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
20046   int jresult ;
20047   int result;
20048
20049   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
20050   jresult = (int)result;
20051   return jresult;
20052 }
20053
20054
20055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
20056   void * jresult ;
20057   Dali::LinearConstrainer::Property *result = 0 ;
20058
20059   {
20060     try {
20061       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
20062     } CALL_CATCH_EXCEPTION(0);
20063   }
20064
20065   jresult = (void *)result;
20066   return jresult;
20067 }
20068
20069
20070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
20071   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
20072
20073   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
20074   {
20075     try {
20076       delete arg1;
20077     } CALL_CATCH_EXCEPTION();
20078   }
20079
20080 }
20081
20082
20083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
20084   void * jresult ;
20085   Dali::LinearConstrainer result;
20086
20087   {
20088     try {
20089       result = Dali::LinearConstrainer::New();
20090     } CALL_CATCH_EXCEPTION(0);
20091   }
20092
20093   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
20094   return jresult;
20095 }
20096
20097
20098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
20099   void * jresult ;
20100   Dali::BaseHandle arg1 ;
20101   Dali::BaseHandle *argp1 ;
20102   Dali::LinearConstrainer result;
20103
20104   argp1 = (Dali::BaseHandle *)jarg1;
20105   if (!argp1) {
20106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20107     return 0;
20108   }
20109   arg1 = *argp1;
20110   {
20111     try {
20112       result = Dali::LinearConstrainer::DownCast(arg1);
20113     } CALL_CATCH_EXCEPTION(0);
20114   }
20115
20116   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
20117   return jresult;
20118 }
20119
20120
20121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
20122   void * jresult ;
20123   Dali::LinearConstrainer *result = 0 ;
20124
20125   {
20126     try {
20127       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
20128     } CALL_CATCH_EXCEPTION(0);
20129   }
20130
20131   jresult = (void *)result;
20132   return jresult;
20133 }
20134
20135
20136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
20137   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
20138
20139   arg1 = (Dali::LinearConstrainer *)jarg1;
20140   {
20141     try {
20142       delete arg1;
20143     } CALL_CATCH_EXCEPTION();
20144   }
20145
20146 }
20147
20148
20149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
20150   void * jresult ;
20151   Dali::LinearConstrainer *arg1 = 0 ;
20152   Dali::LinearConstrainer *result = 0 ;
20153
20154   arg1 = (Dali::LinearConstrainer *)jarg1;
20155   if (!arg1) {
20156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
20157     return 0;
20158   }
20159   {
20160     try {
20161       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
20162     } CALL_CATCH_EXCEPTION(0);
20163   }
20164
20165   jresult = (void *)result;
20166   return jresult;
20167 }
20168
20169
20170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
20171   void * jresult ;
20172   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
20173   Dali::LinearConstrainer *arg2 = 0 ;
20174   Dali::LinearConstrainer *result = 0 ;
20175
20176   arg1 = (Dali::LinearConstrainer *)jarg1;
20177   arg2 = (Dali::LinearConstrainer *)jarg2;
20178   if (!arg2) {
20179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
20180     return 0;
20181   }
20182   {
20183     try {
20184       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
20185     } CALL_CATCH_EXCEPTION(0);
20186   }
20187
20188   jresult = (void *)result;
20189   return jresult;
20190 }
20191
20192
20193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
20194   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
20195   SwigValueWrapper< Dali::Property > arg2 ;
20196   SwigValueWrapper< Dali::Property > arg3 ;
20197   Dali::Vector2 *arg4 = 0 ;
20198   Dali::Vector2 *arg5 = 0 ;
20199   Dali::Property *argp2 ;
20200   Dali::Property *argp3 ;
20201
20202   arg1 = (Dali::LinearConstrainer *)jarg1;
20203   argp2 = (Dali::Property *)jarg2;
20204   if (!argp2) {
20205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
20206     return ;
20207   }
20208   arg2 = *argp2;
20209   argp3 = (Dali::Property *)jarg3;
20210   if (!argp3) {
20211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
20212     return ;
20213   }
20214   arg3 = *argp3;
20215   arg4 = (Dali::Vector2 *)jarg4;
20216   if (!arg4) {
20217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
20218     return ;
20219   }
20220   arg5 = (Dali::Vector2 *)jarg5;
20221   if (!arg5) {
20222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
20223     return ;
20224   }
20225   {
20226     try {
20227       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
20228     } CALL_CATCH_EXCEPTION();
20229   }
20230
20231 }
20232
20233
20234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
20235   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
20236   SwigValueWrapper< Dali::Property > arg2 ;
20237   SwigValueWrapper< Dali::Property > arg3 ;
20238   Dali::Vector2 *arg4 = 0 ;
20239   Dali::Property *argp2 ;
20240   Dali::Property *argp3 ;
20241
20242   arg1 = (Dali::LinearConstrainer *)jarg1;
20243   argp2 = (Dali::Property *)jarg2;
20244   if (!argp2) {
20245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
20246     return ;
20247   }
20248   arg2 = *argp2;
20249   argp3 = (Dali::Property *)jarg3;
20250   if (!argp3) {
20251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
20252     return ;
20253   }
20254   arg3 = *argp3;
20255   arg4 = (Dali::Vector2 *)jarg4;
20256   if (!arg4) {
20257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
20258     return ;
20259   }
20260   {
20261     try {
20262       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
20263     } CALL_CATCH_EXCEPTION();
20264   }
20265
20266 }
20267
20268
20269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
20270   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
20271   Dali::Handle *arg2 = 0 ;
20272
20273   arg1 = (Dali::LinearConstrainer *)jarg1;
20274   arg2 = (Dali::Handle *)jarg2;
20275   if (!arg2) {
20276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
20277     return ;
20278   }
20279   {
20280     try {
20281       (arg1)->Remove(*arg2);
20282     } CALL_CATCH_EXCEPTION();
20283   }
20284
20285 }
20286
20287
20288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
20289   int jresult ;
20290   int result;
20291
20292   result = (int)Dali::PathConstrainer::Property::FORWARD;
20293   jresult = (int)result;
20294   return jresult;
20295 }
20296
20297
20298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
20299   int jresult ;
20300   int result;
20301
20302   result = (int)Dali::PathConstrainer::Property::POINTS;
20303   jresult = (int)result;
20304   return jresult;
20305 }
20306
20307
20308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
20309   int jresult ;
20310   int result;
20311
20312   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
20313   jresult = (int)result;
20314   return jresult;
20315 }
20316
20317
20318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
20319   void * jresult ;
20320   Dali::PathConstrainer::Property *result = 0 ;
20321
20322   {
20323     try {
20324       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
20325     } CALL_CATCH_EXCEPTION(0);
20326   }
20327
20328   jresult = (void *)result;
20329   return jresult;
20330 }
20331
20332
20333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
20334   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
20335
20336   arg1 = (Dali::PathConstrainer::Property *)jarg1;
20337   {
20338     try {
20339       delete arg1;
20340     } CALL_CATCH_EXCEPTION();
20341   }
20342
20343 }
20344
20345
20346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
20347   void * jresult ;
20348   Dali::PathConstrainer result;
20349
20350   {
20351     try {
20352       result = Dali::PathConstrainer::New();
20353     } CALL_CATCH_EXCEPTION(0);
20354   }
20355
20356   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
20357   return jresult;
20358 }
20359
20360
20361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
20362   void * jresult ;
20363   Dali::BaseHandle arg1 ;
20364   Dali::BaseHandle *argp1 ;
20365   Dali::PathConstrainer result;
20366
20367   argp1 = (Dali::BaseHandle *)jarg1;
20368   if (!argp1) {
20369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20370     return 0;
20371   }
20372   arg1 = *argp1;
20373   {
20374     try {
20375       result = Dali::PathConstrainer::DownCast(arg1);
20376     } CALL_CATCH_EXCEPTION(0);
20377   }
20378
20379   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
20380   return jresult;
20381 }
20382
20383
20384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
20385   void * jresult ;
20386   Dali::PathConstrainer *result = 0 ;
20387
20388   {
20389     try {
20390       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
20391     } CALL_CATCH_EXCEPTION(0);
20392   }
20393
20394   jresult = (void *)result;
20395   return jresult;
20396 }
20397
20398
20399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
20400   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
20401
20402   arg1 = (Dali::PathConstrainer *)jarg1;
20403   {
20404     try {
20405       delete arg1;
20406     } CALL_CATCH_EXCEPTION();
20407   }
20408
20409 }
20410
20411
20412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
20413   void * jresult ;
20414   Dali::PathConstrainer *arg1 = 0 ;
20415   Dali::PathConstrainer *result = 0 ;
20416
20417   arg1 = (Dali::PathConstrainer *)jarg1;
20418   if (!arg1) {
20419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
20420     return 0;
20421   }
20422   {
20423     try {
20424       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
20425     } CALL_CATCH_EXCEPTION(0);
20426   }
20427
20428   jresult = (void *)result;
20429   return jresult;
20430 }
20431
20432
20433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
20434   void * jresult ;
20435   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
20436   Dali::PathConstrainer *arg2 = 0 ;
20437   Dali::PathConstrainer *result = 0 ;
20438
20439   arg1 = (Dali::PathConstrainer *)jarg1;
20440   arg2 = (Dali::PathConstrainer *)jarg2;
20441   if (!arg2) {
20442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
20443     return 0;
20444   }
20445   {
20446     try {
20447       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
20448     } CALL_CATCH_EXCEPTION(0);
20449   }
20450
20451   jresult = (void *)result;
20452   return jresult;
20453 }
20454
20455
20456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
20457   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
20458   SwigValueWrapper< Dali::Property > arg2 ;
20459   SwigValueWrapper< Dali::Property > arg3 ;
20460   Dali::Vector2 *arg4 = 0 ;
20461   Dali::Vector2 *arg5 = 0 ;
20462   Dali::Property *argp2 ;
20463   Dali::Property *argp3 ;
20464
20465   arg1 = (Dali::PathConstrainer *)jarg1;
20466   argp2 = (Dali::Property *)jarg2;
20467   if (!argp2) {
20468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
20469     return ;
20470   }
20471   arg2 = *argp2;
20472   argp3 = (Dali::Property *)jarg3;
20473   if (!argp3) {
20474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
20475     return ;
20476   }
20477   arg3 = *argp3;
20478   arg4 = (Dali::Vector2 *)jarg4;
20479   if (!arg4) {
20480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
20481     return ;
20482   }
20483   arg5 = (Dali::Vector2 *)jarg5;
20484   if (!arg5) {
20485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
20486     return ;
20487   }
20488   {
20489     try {
20490       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
20491     } CALL_CATCH_EXCEPTION();
20492   }
20493
20494 }
20495
20496
20497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
20498   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
20499   SwigValueWrapper< Dali::Property > arg2 ;
20500   SwigValueWrapper< Dali::Property > arg3 ;
20501   Dali::Vector2 *arg4 = 0 ;
20502   Dali::Property *argp2 ;
20503   Dali::Property *argp3 ;
20504
20505   arg1 = (Dali::PathConstrainer *)jarg1;
20506   argp2 = (Dali::Property *)jarg2;
20507   if (!argp2) {
20508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
20509     return ;
20510   }
20511   arg2 = *argp2;
20512   argp3 = (Dali::Property *)jarg3;
20513   if (!argp3) {
20514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
20515     return ;
20516   }
20517   arg3 = *argp3;
20518   arg4 = (Dali::Vector2 *)jarg4;
20519   if (!arg4) {
20520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
20521     return ;
20522   }
20523   {
20524     try {
20525       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
20526     } CALL_CATCH_EXCEPTION();
20527   }
20528
20529 }
20530
20531
20532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
20533   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
20534   Dali::Handle *arg2 = 0 ;
20535
20536   arg1 = (Dali::PathConstrainer *)jarg1;
20537   arg2 = (Dali::Handle *)jarg2;
20538   if (!arg2) {
20539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
20540     return ;
20541   }
20542   {
20543     try {
20544       (arg1)->Remove(*arg2);
20545     } CALL_CATCH_EXCEPTION();
20546   }
20547
20548 }
20549
20550
20551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
20552   int jresult ;
20553   Dali::FittingMode::Type result;
20554
20555   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
20556   jresult = (int)result;
20557   return jresult;
20558 }
20559
20560
20561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
20562   int jresult ;
20563   Dali::SamplingMode::Type result;
20564
20565   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
20566   jresult = (int)result;
20567   return jresult;
20568 }
20569
20570
20571 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageInterface_CreateResource(void * jarg1) {
20572   bool jresult ;
20573   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
20574   bool result;
20575
20576   arg1 = (Dali::NativeImageInterface *)jarg1;
20577   {
20578     try {
20579       result = (bool)(arg1)->CreateResource();
20580     } CALL_CATCH_EXCEPTION(0);
20581   }
20582
20583   jresult = result;
20584   return jresult;
20585 }
20586
20587
20588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_DestroyResource(void * jarg1) {
20589   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
20590
20591   arg1 = (Dali::NativeImageInterface *)jarg1;
20592   {
20593     try {
20594       (arg1)->DestroyResource();
20595     } CALL_CATCH_EXCEPTION();
20596   }
20597
20598 }
20599
20600
20601 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
20602   unsigned int jresult ;
20603   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
20604   unsigned int result;
20605
20606   arg1 = (Dali::NativeImageInterface *)jarg1;
20607   {
20608     try {
20609       result = (unsigned int)(arg1)->TargetTexture();
20610     } CALL_CATCH_EXCEPTION(0);
20611   }
20612
20613   jresult = result;
20614   return jresult;
20615 }
20616
20617
20618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
20619   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
20620
20621   arg1 = (Dali::NativeImageInterface *)jarg1;
20622   {
20623     try {
20624       (arg1)->PrepareTexture();
20625     } CALL_CATCH_EXCEPTION();
20626   }
20627
20628 }
20629
20630
20631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
20632   unsigned int jresult ;
20633   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
20634   unsigned int result;
20635
20636   arg1 = (Dali::NativeImageInterface *)jarg1;
20637   {
20638     try {
20639       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
20640     } CALL_CATCH_EXCEPTION(0);
20641   }
20642
20643   jresult = result;
20644   return jresult;
20645 }
20646
20647
20648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
20649   unsigned int jresult ;
20650   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
20651   unsigned int result;
20652
20653   arg1 = (Dali::NativeImageInterface *)jarg1;
20654   {
20655     try {
20656       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
20657     } CALL_CATCH_EXCEPTION(0);
20658   }
20659
20660   jresult = result;
20661   return jresult;
20662 }
20663
20664
20665 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
20666   bool jresult ;
20667   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
20668   bool result;
20669
20670   arg1 = (Dali::NativeImageInterface *)jarg1;
20671   {
20672     try {
20673       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
20674     } CALL_CATCH_EXCEPTION(0);
20675   }
20676
20677   jresult = result;
20678   return jresult;
20679 }
20680
20681 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageInterface_GenerateUrl(void* nuiHandle)
20682 {
20683   Dali::Toolkit::ImageUrl result;
20684   Dali::NativeImageInterface* nativeImage = (Dali::NativeImageInterface*)nuiHandle;
20685   void *jresult;
20686
20687   {
20688     try {
20689       result = Dali::Toolkit::Image::GenerateUrl(nativeImage);
20690     }
20691     CALL_CATCH_EXCEPTION(0);
20692   }
20693
20694   jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl &)result);
20695   return jresult;
20696 }
20697
20698
20699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
20700   int jresult ;
20701   int result;
20702
20703   result = (int)Dali::CameraActor::Property::TYPE;
20704   jresult = (int)result;
20705   return jresult;
20706 }
20707
20708
20709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
20710   int jresult ;
20711   int result;
20712
20713   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
20714   jresult = (int)result;
20715   return jresult;
20716 }
20717
20718
20719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
20720   int jresult ;
20721   int result;
20722
20723   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
20724   jresult = (int)result;
20725   return jresult;
20726 }
20727
20728
20729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
20730   int jresult ;
20731   int result;
20732
20733   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
20734   jresult = (int)result;
20735   return jresult;
20736 }
20737
20738
20739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
20740   int jresult ;
20741   int result;
20742
20743   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
20744   jresult = (int)result;
20745   return jresult;
20746 }
20747
20748
20749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
20750   int jresult ;
20751   int result;
20752
20753   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
20754   jresult = (int)result;
20755   return jresult;
20756 }
20757
20758
20759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
20760   int jresult ;
20761   int result;
20762
20763   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
20764   jresult = (int)result;
20765   return jresult;
20766 }
20767
20768
20769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
20770   int jresult ;
20771   int result;
20772
20773   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
20774   jresult = (int)result;
20775   return jresult;
20776 }
20777
20778
20779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
20780   int jresult ;
20781   int result;
20782
20783   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
20784   jresult = (int)result;
20785   return jresult;
20786 }
20787
20788
20789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
20790   int jresult ;
20791   int result;
20792
20793   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
20794   jresult = (int)result;
20795   return jresult;
20796 }
20797
20798
20799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
20800   int jresult ;
20801   int result;
20802
20803   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
20804   jresult = (int)result;
20805   return jresult;
20806 }
20807
20808
20809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
20810   int jresult ;
20811   int result;
20812
20813   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
20814   jresult = (int)result;
20815   return jresult;
20816 }
20817
20818
20819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
20820   int jresult ;
20821   int result;
20822
20823   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
20824   jresult = (int)result;
20825   return jresult;
20826 }
20827
20828
20829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
20830   int jresult ;
20831   int result;
20832
20833   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
20834   jresult = (int)result;
20835   return jresult;
20836 }
20837
20838
20839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ORTHOGRAPHIC_SIZE_get() {
20840   int jresult ;
20841   int result;
20842
20843   result = (int)Dali::DevelCameraActor::Property::ORTHOGRAPHIC_SIZE;
20844   jresult = (int)result;
20845   return jresult;
20846 }
20847
20848
20849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_DIRECTION_get() {
20850   int jresult ;
20851   int result;
20852
20853   result = (int)Dali::DevelCameraActor::Property::PROJECTION_DIRECTION;
20854   jresult = (int)result;
20855   return jresult;
20856 }
20857
20858
20859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
20860   void * jresult ;
20861   Dali::CameraActor::Property *result = 0 ;
20862
20863   {
20864     try {
20865       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
20866     } CALL_CATCH_EXCEPTION(0);
20867   }
20868
20869   jresult = (void *)result;
20870   return jresult;
20871 }
20872
20873
20874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
20875   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
20876
20877   arg1 = (Dali::CameraActor::Property *)jarg1;
20878   {
20879     try {
20880       delete arg1;
20881     } CALL_CATCH_EXCEPTION();
20882   }
20883
20884 }
20885
20886
20887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
20888   void * jresult ;
20889   Dali::CameraActor *result = 0 ;
20890
20891   {
20892     try {
20893       result = (Dali::CameraActor *)new Dali::CameraActor();
20894     } CALL_CATCH_EXCEPTION(0);
20895   }
20896
20897   jresult = (void *)result;
20898   return jresult;
20899 }
20900
20901
20902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
20903   void * jresult ;
20904   Dali::CameraActor result;
20905
20906   {
20907     try {
20908       result = Dali::CameraActor::New();
20909     } CALL_CATCH_EXCEPTION(0);
20910   }
20911
20912   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
20913   return jresult;
20914 }
20915
20916
20917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
20918   void * jresult ;
20919   Dali::Size *arg1 = 0 ;
20920   Dali::CameraActor result;
20921
20922   arg1 = (Dali::Size *)jarg1;
20923   if (!arg1) {
20924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
20925     return 0;
20926   }
20927   {
20928     try {
20929       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
20930     } CALL_CATCH_EXCEPTION(0);
20931   }
20932
20933   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
20934   return jresult;
20935 }
20936
20937
20938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New3DCamera() {
20939   void * jresult ;
20940   Dali::CameraActor result;
20941
20942   {
20943     try {
20944       result = Dali::CameraActor::New3DCamera();
20945     } CALL_CATCH_EXCEPTION(0);
20946   }
20947
20948   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
20949   return jresult;
20950 }
20951
20952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
20953   void * jresult ;
20954   Dali::BaseHandle arg1 ;
20955   Dali::BaseHandle *argp1 ;
20956   Dali::CameraActor result;
20957
20958   argp1 = (Dali::BaseHandle *)jarg1;
20959   if (!argp1) {
20960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20961     return 0;
20962   }
20963   arg1 = *argp1;
20964   {
20965     try {
20966       result = Dali::CameraActor::DownCast(arg1);
20967     } CALL_CATCH_EXCEPTION(0);
20968   }
20969
20970   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
20971   return jresult;
20972 }
20973
20974
20975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
20976   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
20977
20978   arg1 = (Dali::CameraActor *)jarg1;
20979   {
20980     try {
20981       delete arg1;
20982     } CALL_CATCH_EXCEPTION();
20983   }
20984
20985 }
20986
20987
20988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
20989   void * jresult ;
20990   Dali::CameraActor *arg1 = 0 ;
20991   Dali::CameraActor *result = 0 ;
20992
20993   arg1 = (Dali::CameraActor *)jarg1;
20994   if (!arg1) {
20995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
20996     return 0;
20997   }
20998   {
20999     try {
21000       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
21001     } CALL_CATCH_EXCEPTION(0);
21002   }
21003
21004   jresult = (void *)result;
21005   return jresult;
21006 }
21007
21008
21009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
21010   void * jresult ;
21011   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21012   Dali::CameraActor *arg2 = 0 ;
21013   Dali::CameraActor *result = 0 ;
21014
21015   arg1 = (Dali::CameraActor *)jarg1;
21016   arg2 = (Dali::CameraActor *)jarg2;
21017   if (!arg2) {
21018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
21019     return 0;
21020   }
21021   {
21022     try {
21023       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
21024     } CALL_CATCH_EXCEPTION(0);
21025   }
21026
21027   jresult = (void *)result;
21028   return jresult;
21029 }
21030
21031
21032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
21033   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21034   Dali::Camera::Type arg2 ;
21035
21036   arg1 = (Dali::CameraActor *)jarg1;
21037   arg2 = (Dali::Camera::Type)jarg2;
21038   {
21039     try {
21040       (arg1)->SetType(arg2);
21041     } CALL_CATCH_EXCEPTION();
21042   }
21043
21044 }
21045
21046
21047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
21048   int jresult ;
21049   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21050   Dali::Camera::Type result;
21051
21052   arg1 = (Dali::CameraActor *)jarg1;
21053   {
21054     try {
21055       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
21056     } CALL_CATCH_EXCEPTION(0);
21057   }
21058
21059   jresult = (int)result;
21060   return jresult;
21061 }
21062
21063
21064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
21065   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21066   Dali::Camera::ProjectionMode arg2 ;
21067
21068   arg1 = (Dali::CameraActor *)jarg1;
21069   arg2 = (Dali::Camera::ProjectionMode)jarg2;
21070   {
21071     try {
21072       (arg1)->SetProjectionMode(arg2);
21073     } CALL_CATCH_EXCEPTION();
21074   }
21075
21076 }
21077
21078
21079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
21080   int jresult ;
21081   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21082   Dali::Camera::ProjectionMode result;
21083
21084   arg1 = (Dali::CameraActor *)jarg1;
21085   {
21086     try {
21087       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
21088     } CALL_CATCH_EXCEPTION(0);
21089   }
21090
21091   jresult = (int)result;
21092   return jresult;
21093 }
21094
21095
21096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
21097   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21098   float arg2 ;
21099
21100   arg1 = (Dali::CameraActor *)jarg1;
21101   arg2 = (float)jarg2;
21102   {
21103     try {
21104       (arg1)->SetFieldOfView(arg2);
21105     } CALL_CATCH_EXCEPTION();
21106   }
21107
21108 }
21109
21110
21111 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
21112   float jresult ;
21113   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21114   float result;
21115
21116   arg1 = (Dali::CameraActor *)jarg1;
21117   {
21118     try {
21119       result = (float)(arg1)->GetFieldOfView();
21120     } CALL_CATCH_EXCEPTION(0);
21121   }
21122
21123   jresult = result;
21124   return jresult;
21125 }
21126
21127
21128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
21129   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21130   float arg2 ;
21131
21132   arg1 = (Dali::CameraActor *)jarg1;
21133   arg2 = (float)jarg2;
21134   {
21135     try {
21136       (arg1)->SetAspectRatio(arg2);
21137     } CALL_CATCH_EXCEPTION();
21138   }
21139
21140 }
21141
21142
21143 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
21144   float jresult ;
21145   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21146   float result;
21147
21148   arg1 = (Dali::CameraActor *)jarg1;
21149   {
21150     try {
21151       result = (float)(arg1)->GetAspectRatio();
21152     } CALL_CATCH_EXCEPTION(0);
21153   }
21154
21155   jresult = result;
21156   return jresult;
21157 }
21158
21159
21160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
21161   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21162   float arg2 ;
21163
21164   arg1 = (Dali::CameraActor *)jarg1;
21165   arg2 = (float)jarg2;
21166   {
21167     try {
21168       (arg1)->SetNearClippingPlane(arg2);
21169     } CALL_CATCH_EXCEPTION();
21170   }
21171
21172 }
21173
21174
21175 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
21176   float jresult ;
21177   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21178   float result;
21179
21180   arg1 = (Dali::CameraActor *)jarg1;
21181   {
21182     try {
21183       result = (float)(arg1)->GetNearClippingPlane();
21184     } CALL_CATCH_EXCEPTION(0);
21185   }
21186
21187   jresult = result;
21188   return jresult;
21189 }
21190
21191
21192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
21193   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21194   float arg2 ;
21195
21196   arg1 = (Dali::CameraActor *)jarg1;
21197   arg2 = (float)jarg2;
21198   {
21199     try {
21200       (arg1)->SetFarClippingPlane(arg2);
21201     } CALL_CATCH_EXCEPTION();
21202   }
21203
21204 }
21205
21206
21207 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
21208   float jresult ;
21209   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21210   float result;
21211
21212   arg1 = (Dali::CameraActor *)jarg1;
21213   {
21214     try {
21215       result = (float)(arg1)->GetFarClippingPlane();
21216     } CALL_CATCH_EXCEPTION(0);
21217   }
21218
21219   jresult = result;
21220   return jresult;
21221 }
21222
21223
21224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
21225   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21226   Dali::Vector3 *arg2 = 0 ;
21227
21228   arg1 = (Dali::CameraActor *)jarg1;
21229   arg2 = (Dali::Vector3 *)jarg2;
21230   if (!arg2) {
21231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
21232     return ;
21233   }
21234   {
21235     try {
21236       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
21237     } CALL_CATCH_EXCEPTION();
21238   }
21239
21240 }
21241
21242
21243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
21244   void * jresult ;
21245   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21246   Dali::Vector3 result;
21247
21248   arg1 = (Dali::CameraActor *)jarg1;
21249   {
21250     try {
21251       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
21252     } CALL_CATCH_EXCEPTION(0);
21253   }
21254
21255   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
21256   return jresult;
21257 }
21258
21259
21260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, bool jarg2) {
21261   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21262   bool arg2 ;
21263
21264   arg1 = (Dali::CameraActor *)jarg1;
21265   arg2 = jarg2 ? true : false;
21266   {
21267     try {
21268       (arg1)->SetInvertYAxis(arg2);
21269     } CALL_CATCH_EXCEPTION();
21270   }
21271
21272 }
21273
21274
21275 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
21276   bool jresult ;
21277   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21278   bool result;
21279
21280   arg1 = (Dali::CameraActor *)jarg1;
21281   {
21282     try {
21283       result = (bool)(arg1)->GetInvertYAxis();
21284     } CALL_CATCH_EXCEPTION(0);
21285   }
21286
21287   jresult = result;
21288   return jresult;
21289 }
21290
21291
21292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
21293   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21294   Dali::Size *arg2 = 0 ;
21295
21296   arg1 = (Dali::CameraActor *)jarg1;
21297   arg2 = (Dali::Size *)jarg2;
21298   if (!arg2) {
21299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
21300     return ;
21301   }
21302   {
21303     try {
21304       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
21305     } CALL_CATCH_EXCEPTION();
21306   }
21307
21308 }
21309
21310
21311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
21312   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21313   Dali::Size *arg2 = 0 ;
21314
21315   arg1 = (Dali::CameraActor *)jarg1;
21316   arg2 = (Dali::Size *)jarg2;
21317   if (!arg2) {
21318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
21319     return ;
21320   }
21321   {
21322     try {
21323       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
21324     } CALL_CATCH_EXCEPTION();
21325   }
21326
21327 }
21328
21329
21330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
21331   void * jresult ;
21332   std::pair< std::string,Dali::Property::Value > *result = 0 ;
21333
21334   {
21335     try {
21336       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
21337     } CALL_CATCH_EXCEPTION(0);
21338   }
21339
21340   jresult = (void *)result;
21341   return jresult;
21342 }
21343
21344
21345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
21346   void * jresult ;
21347   std::string arg1 ;
21348   Dali::Property::Value arg2 ;
21349   Dali::Property::Value *argp2 ;
21350   std::pair< std::string,Dali::Property::Value > *result = 0 ;
21351
21352   if (!jarg1) {
21353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21354     return 0;
21355   }
21356   (&arg1)->assign(jarg1);
21357   argp2 = (Dali::Property::Value *)jarg2;
21358   if (!argp2) {
21359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
21360     return 0;
21361   }
21362   arg2 = *argp2;
21363   {
21364     try {
21365       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
21366     } CALL_CATCH_EXCEPTION(0);
21367   }
21368
21369   jresult = (void *)result;
21370   return jresult;
21371 }
21372
21373
21374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
21375   void * jresult ;
21376   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
21377   std::pair< std::string,Dali::Property::Value > *result = 0 ;
21378
21379   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
21380   if (!arg1) {
21381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
21382     return 0;
21383   }
21384   {
21385     try {
21386       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);
21387     } CALL_CATCH_EXCEPTION(0);
21388   }
21389
21390   jresult = (void *)result;
21391   return jresult;
21392 }
21393
21394
21395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
21396   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
21397   std::string *arg2 = 0 ;
21398
21399   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
21400   if (!jarg2) {
21401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21402     return ;
21403   }
21404   std::string arg2_str(jarg2);
21405   arg2 = &arg2_str;
21406   if (arg1) (arg1)->first = *arg2;
21407
21408   //argout typemap for const std::string&
21409
21410 }
21411
21412
21413 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
21414   char * jresult ;
21415   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
21416   std::string *result = 0 ;
21417
21418   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
21419   result = (std::string *) & ((arg1)->first);
21420   jresult = SWIG_csharp_string_callback(result->c_str());
21421   return jresult;
21422 }
21423
21424
21425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
21426   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
21427   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
21428
21429   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
21430   arg2 = (Dali::Property::Value *)jarg2;
21431   if (arg1) (arg1)->second = *arg2;
21432 }
21433
21434
21435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
21436   void * jresult ;
21437   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
21438   Dali::Property::Value *result = 0 ;
21439
21440   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
21441   result = (Dali::Property::Value *)& ((arg1)->second);
21442   jresult = (void *)result;
21443   return jresult;
21444 }
21445
21446
21447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
21448   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
21449
21450   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
21451   {
21452     try {
21453       delete arg1;
21454     } CALL_CATCH_EXCEPTION();
21455   }
21456
21457 }
21458
21459
21460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
21461   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21462
21463   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21464   {
21465     try {
21466       (arg1)->clear();
21467     } CALL_CATCH_EXCEPTION();
21468   }
21469
21470 }
21471
21472
21473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
21474   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21475   Dali::TouchPoint *arg2 = 0 ;
21476
21477   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21478   arg2 = (Dali::TouchPoint *)jarg2;
21479   if (!arg2) {
21480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
21481     return ;
21482   }
21483   {
21484     try {
21485       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
21486     } CALL_CATCH_EXCEPTION();
21487   }
21488
21489 }
21490
21491
21492 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
21493   unsigned long jresult ;
21494   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21495   std::vector< Dali::TouchPoint >::size_type result;
21496
21497   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21498   {
21499     try {
21500       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
21501     } CALL_CATCH_EXCEPTION(0);
21502   }
21503
21504   jresult = (unsigned long)result;
21505   return jresult;
21506 }
21507
21508
21509 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
21510   unsigned long jresult ;
21511   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21512   std::vector< Dali::TouchPoint >::size_type result;
21513
21514   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21515   {
21516     try {
21517       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
21518     } CALL_CATCH_EXCEPTION(0);
21519   }
21520
21521   jresult = (unsigned long)result;
21522   return jresult;
21523 }
21524
21525
21526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
21527   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21528   std::vector< Dali::TouchPoint >::size_type arg2 ;
21529
21530   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21531   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
21532   {
21533     try {
21534       (arg1)->reserve(arg2);
21535     } CALL_CATCH_EXCEPTION();
21536   }
21537
21538 }
21539
21540
21541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
21542   void * jresult ;
21543   std::vector< Dali::TouchPoint > *result = 0 ;
21544
21545   {
21546     try {
21547       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
21548     } CALL_CATCH_EXCEPTION(0);
21549   }
21550
21551   jresult = (void *)result;
21552   return jresult;
21553 }
21554
21555
21556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
21557   void * jresult ;
21558   std::vector< Dali::TouchPoint > *arg1 = 0 ;
21559   std::vector< Dali::TouchPoint > *result = 0 ;
21560
21561   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21562   if (!arg1) {
21563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
21564     return 0;
21565   }
21566   {
21567     try {
21568       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
21569     } CALL_CATCH_EXCEPTION(0);
21570   }
21571
21572   jresult = (void *)result;
21573   return jresult;
21574 }
21575
21576
21577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
21578   void * jresult ;
21579   int arg1 ;
21580   std::vector< Dali::TouchPoint > *result = 0 ;
21581
21582   arg1 = (int)jarg1;
21583   {
21584     try {
21585       try {
21586         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
21587       }
21588       catch(std::out_of_range &_e) {
21589         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21590         return 0;
21591       }
21592
21593     } CALL_CATCH_EXCEPTION(0);
21594   }
21595
21596   jresult = (void *)result;
21597   return jresult;
21598 }
21599
21600
21601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
21602   void * jresult ;
21603   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21604   int arg2 ;
21605   SwigValueWrapper< Dali::TouchPoint > result;
21606
21607   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21608   arg2 = (int)jarg2;
21609   {
21610     try {
21611       try {
21612         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
21613       }
21614       catch(std::out_of_range &_e) {
21615         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21616         return 0;
21617       }
21618
21619     } CALL_CATCH_EXCEPTION(0);
21620   }
21621
21622   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
21623   return jresult;
21624 }
21625
21626
21627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
21628   void * jresult ;
21629   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21630   int arg2 ;
21631   Dali::TouchPoint *result = 0 ;
21632
21633   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21634   arg2 = (int)jarg2;
21635   {
21636     try {
21637       try {
21638         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
21639       }
21640       catch(std::out_of_range &_e) {
21641         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21642         return 0;
21643       }
21644
21645     } CALL_CATCH_EXCEPTION(0);
21646   }
21647
21648   jresult = (void *)result;
21649   return jresult;
21650 }
21651
21652
21653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
21654   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21655   int arg2 ;
21656   Dali::TouchPoint *arg3 = 0 ;
21657
21658   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21659   arg2 = (int)jarg2;
21660   arg3 = (Dali::TouchPoint *)jarg3;
21661   if (!arg3) {
21662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
21663     return ;
21664   }
21665   {
21666     try {
21667       try {
21668         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
21669       }
21670       catch(std::out_of_range &_e) {
21671         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21672         return ;
21673       }
21674
21675     } CALL_CATCH_EXCEPTION();
21676   }
21677
21678 }
21679
21680
21681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
21682   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21683   std::vector< Dali::TouchPoint > *arg2 = 0 ;
21684
21685   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21686   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
21687   if (!arg2) {
21688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
21689     return ;
21690   }
21691   {
21692     try {
21693       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
21694     } CALL_CATCH_EXCEPTION();
21695   }
21696
21697 }
21698
21699
21700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
21701   void * jresult ;
21702   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21703   int arg2 ;
21704   int arg3 ;
21705   std::vector< Dali::TouchPoint > *result = 0 ;
21706
21707   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21708   arg2 = (int)jarg2;
21709   arg3 = (int)jarg3;
21710   {
21711     try {
21712       try {
21713         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
21714       }
21715       catch(std::out_of_range &_e) {
21716         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21717         return 0;
21718       }
21719       catch(std::invalid_argument &_e) {
21720         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
21721         return 0;
21722       }
21723
21724     } CALL_CATCH_EXCEPTION(0);
21725   }
21726
21727   jresult = (void *)result;
21728   return jresult;
21729 }
21730
21731
21732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
21733   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21734   int arg2 ;
21735   Dali::TouchPoint *arg3 = 0 ;
21736
21737   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21738   arg2 = (int)jarg2;
21739   arg3 = (Dali::TouchPoint *)jarg3;
21740   if (!arg3) {
21741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
21742     return ;
21743   }
21744   {
21745     try {
21746       try {
21747         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
21748       }
21749       catch(std::out_of_range &_e) {
21750         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21751         return ;
21752       }
21753
21754     } CALL_CATCH_EXCEPTION();
21755   }
21756
21757 }
21758
21759
21760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
21761   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21762   int arg2 ;
21763   std::vector< Dali::TouchPoint > *arg3 = 0 ;
21764
21765   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21766   arg2 = (int)jarg2;
21767   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
21768   if (!arg3) {
21769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
21770     return ;
21771   }
21772   {
21773     try {
21774       try {
21775         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
21776       }
21777       catch(std::out_of_range &_e) {
21778         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21779         return ;
21780       }
21781
21782     } CALL_CATCH_EXCEPTION();
21783   }
21784
21785 }
21786
21787
21788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
21789   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21790   int arg2 ;
21791
21792   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21793   arg2 = (int)jarg2;
21794   {
21795     try {
21796       try {
21797         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
21798       }
21799       catch(std::out_of_range &_e) {
21800         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21801         return ;
21802       }
21803
21804     } CALL_CATCH_EXCEPTION();
21805   }
21806
21807 }
21808
21809
21810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
21811   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21812   int arg2 ;
21813   int arg3 ;
21814
21815   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21816   arg2 = (int)jarg2;
21817   arg3 = (int)jarg3;
21818   {
21819     try {
21820       try {
21821         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
21822       }
21823       catch(std::out_of_range &_e) {
21824         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21825         return ;
21826       }
21827       catch(std::invalid_argument &_e) {
21828         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
21829         return ;
21830       }
21831
21832     } CALL_CATCH_EXCEPTION();
21833   }
21834
21835 }
21836
21837
21838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
21839   void * jresult ;
21840   Dali::TouchPoint *arg1 = 0 ;
21841   int arg2 ;
21842   std::vector< Dali::TouchPoint > *result = 0 ;
21843
21844   arg1 = (Dali::TouchPoint *)jarg1;
21845   if (!arg1) {
21846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
21847     return 0;
21848   }
21849   arg2 = (int)jarg2;
21850   {
21851     try {
21852       try {
21853         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
21854       }
21855       catch(std::out_of_range &_e) {
21856         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21857         return 0;
21858       }
21859
21860     } CALL_CATCH_EXCEPTION(0);
21861   }
21862
21863   jresult = (void *)result;
21864   return jresult;
21865 }
21866
21867
21868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
21869   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21870
21871   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21872   {
21873     try {
21874       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
21875     } CALL_CATCH_EXCEPTION();
21876   }
21877
21878 }
21879
21880
21881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
21882   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21883   int arg2 ;
21884   int arg3 ;
21885
21886   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21887   arg2 = (int)jarg2;
21888   arg3 = (int)jarg3;
21889   {
21890     try {
21891       try {
21892         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
21893       }
21894       catch(std::out_of_range &_e) {
21895         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21896         return ;
21897       }
21898       catch(std::invalid_argument &_e) {
21899         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
21900         return ;
21901       }
21902
21903     } CALL_CATCH_EXCEPTION();
21904   }
21905
21906 }
21907
21908
21909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
21910   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21911   int arg2 ;
21912   std::vector< Dali::TouchPoint > *arg3 = 0 ;
21913
21914   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21915   arg2 = (int)jarg2;
21916   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
21917   if (!arg3) {
21918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
21919     return ;
21920   }
21921   {
21922     try {
21923       try {
21924         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
21925       }
21926       catch(std::out_of_range &_e) {
21927         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21928         return ;
21929       }
21930
21931     } CALL_CATCH_EXCEPTION();
21932   }
21933
21934 }
21935
21936
21937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
21938   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21939
21940   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21941   {
21942     try {
21943       delete arg1;
21944     } CALL_CATCH_EXCEPTION();
21945   }
21946
21947 }
21948
21949
21950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
21951   void * jresult ;
21952   Dali::Rect< int > *result = 0 ;
21953
21954   {
21955     try {
21956       result = (Dali::Rect< int > *)new Dali::Rect< int >();
21957     } CALL_CATCH_EXCEPTION(0);
21958   }
21959
21960   jresult = (void *)result;
21961   return jresult;
21962 }
21963
21964
21965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
21966   void * jresult ;
21967   int arg1 ;
21968   int arg2 ;
21969   int arg3 ;
21970   int arg4 ;
21971   Dali::Rect< int > *result = 0 ;
21972
21973   arg1 = (int)jarg1;
21974   arg2 = (int)jarg2;
21975   arg3 = (int)jarg3;
21976   arg4 = (int)jarg4;
21977   {
21978     try {
21979       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
21980     } CALL_CATCH_EXCEPTION(0);
21981   }
21982
21983   jresult = (void *)result;
21984   return jresult;
21985 }
21986
21987
21988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
21989   void * jresult ;
21990   Dali::Rect< int > *arg1 = 0 ;
21991   Dali::Rect< int > *result = 0 ;
21992
21993   arg1 = (Dali::Rect< int > *)jarg1;
21994   if (!arg1) {
21995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
21996     return 0;
21997   }
21998   {
21999     try {
22000       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
22001     } CALL_CATCH_EXCEPTION(0);
22002   }
22003
22004   jresult = (void *)result;
22005   return jresult;
22006 }
22007
22008
22009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
22010   void * jresult ;
22011   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22012   Dali::Rect< int > *arg2 = 0 ;
22013   Dali::Rect< int > *result = 0 ;
22014
22015   arg1 = (Dali::Rect< int > *)jarg1;
22016   arg2 = (Dali::Rect< int > *)jarg2;
22017   if (!arg2) {
22018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
22019     return 0;
22020   }
22021   {
22022     try {
22023       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
22024     } CALL_CATCH_EXCEPTION(0);
22025   }
22026
22027   jresult = (void *)result;
22028   return jresult;
22029 }
22030
22031
22032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
22033   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22034   int arg2 ;
22035   int arg3 ;
22036   int arg4 ;
22037   int arg5 ;
22038
22039   arg1 = (Dali::Rect< int > *)jarg1;
22040   arg2 = (int)jarg2;
22041   arg3 = (int)jarg3;
22042   arg4 = (int)jarg4;
22043   arg5 = (int)jarg5;
22044   {
22045     try {
22046       (arg1)->Set(arg2,arg3,arg4,arg5);
22047     } CALL_CATCH_EXCEPTION();
22048   }
22049
22050 }
22051
22052
22053 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
22054   bool jresult ;
22055   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22056   bool result;
22057
22058   arg1 = (Dali::Rect< int > *)jarg1;
22059   {
22060     try {
22061       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
22062     } CALL_CATCH_EXCEPTION(0);
22063   }
22064
22065   jresult = result;
22066   return jresult;
22067 }
22068
22069
22070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
22071   int jresult ;
22072   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22073   int result;
22074
22075   arg1 = (Dali::Rect< int > *)jarg1;
22076   {
22077     try {
22078       result = (int)((Dali::Rect< int > const *)arg1)->Left();
22079     } CALL_CATCH_EXCEPTION(0);
22080   }
22081
22082   jresult = result;
22083   return jresult;
22084 }
22085
22086
22087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
22088   int jresult ;
22089   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22090   int result;
22091
22092   arg1 = (Dali::Rect< int > *)jarg1;
22093   {
22094     try {
22095       result = (int)((Dali::Rect< int > const *)arg1)->Right();
22096     } CALL_CATCH_EXCEPTION(0);
22097   }
22098
22099   jresult = result;
22100   return jresult;
22101 }
22102
22103
22104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
22105   int jresult ;
22106   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22107   int result;
22108
22109   arg1 = (Dali::Rect< int > *)jarg1;
22110   {
22111     try {
22112       result = (int)((Dali::Rect< int > const *)arg1)->Top();
22113     } CALL_CATCH_EXCEPTION(0);
22114   }
22115
22116   jresult = result;
22117   return jresult;
22118 }
22119
22120
22121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
22122   int jresult ;
22123   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22124   int result;
22125
22126   arg1 = (Dali::Rect< int > *)jarg1;
22127   {
22128     try {
22129       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
22130     } CALL_CATCH_EXCEPTION(0);
22131   }
22132
22133   jresult = result;
22134   return jresult;
22135 }
22136
22137
22138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
22139   int jresult ;
22140   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22141   int result;
22142
22143   arg1 = (Dali::Rect< int > *)jarg1;
22144   {
22145     try {
22146       result = (int)((Dali::Rect< int > const *)arg1)->Area();
22147     } CALL_CATCH_EXCEPTION(0);
22148   }
22149
22150   jresult = result;
22151   return jresult;
22152 }
22153
22154
22155 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
22156   bool jresult ;
22157   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22158   Dali::Rect< int > *arg2 = 0 ;
22159   bool result;
22160
22161   arg1 = (Dali::Rect< int > *)jarg1;
22162   arg2 = (Dali::Rect< int > *)jarg2;
22163   if (!arg2) {
22164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
22165     return 0;
22166   }
22167   {
22168     try {
22169       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
22170     } CALL_CATCH_EXCEPTION(0);
22171   }
22172
22173   jresult = result;
22174   return jresult;
22175 }
22176
22177
22178 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
22179   bool jresult ;
22180   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22181   Dali::Rect< int > *arg2 = 0 ;
22182   bool result;
22183
22184   arg1 = (Dali::Rect< int > *)jarg1;
22185   arg2 = (Dali::Rect< int > *)jarg2;
22186   if (!arg2) {
22187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
22188     return 0;
22189   }
22190   {
22191     try {
22192       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
22193     } CALL_CATCH_EXCEPTION(0);
22194   }
22195
22196   jresult = result;
22197   return jresult;
22198 }
22199
22200
22201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
22202   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22203   int arg2 ;
22204
22205   arg1 = (Dali::Rect< int > *)jarg1;
22206   arg2 = (int)jarg2;
22207   if (arg1) (arg1)->x = arg2;
22208 }
22209
22210
22211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
22212   int jresult ;
22213   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22214   int result;
22215
22216   arg1 = (Dali::Rect< int > *)jarg1;
22217   result = (int) ((arg1)->x);
22218   jresult = result;
22219   return jresult;
22220 }
22221
22222
22223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
22224   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22225   int arg2 ;
22226
22227   arg1 = (Dali::Rect< int > *)jarg1;
22228   arg2 = (int)jarg2;
22229   if (arg1) (arg1)->left = arg2;
22230 }
22231
22232
22233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
22234   int jresult ;
22235   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22236   int result;
22237
22238   arg1 = (Dali::Rect< int > *)jarg1;
22239   result = (int) ((arg1)->left);
22240   jresult = result;
22241   return jresult;
22242 }
22243
22244
22245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
22246   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22247   int arg2 ;
22248
22249   arg1 = (Dali::Rect< int > *)jarg1;
22250   arg2 = (int)jarg2;
22251   if (arg1) (arg1)->y = arg2;
22252 }
22253
22254
22255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
22256   int jresult ;
22257   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22258   int result;
22259
22260   arg1 = (Dali::Rect< int > *)jarg1;
22261   result = (int) ((arg1)->y);
22262   jresult = result;
22263   return jresult;
22264 }
22265
22266
22267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
22268   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22269   int arg2 ;
22270
22271   arg1 = (Dali::Rect< int > *)jarg1;
22272   arg2 = (int)jarg2;
22273   if (arg1) (arg1)->right = arg2;
22274 }
22275
22276
22277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
22278   int jresult ;
22279   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22280   int result;
22281
22282   arg1 = (Dali::Rect< int > *)jarg1;
22283   result = (int) ((arg1)->right);
22284   jresult = result;
22285   return jresult;
22286 }
22287
22288
22289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
22290   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22291   int arg2 ;
22292
22293   arg1 = (Dali::Rect< int > *)jarg1;
22294   arg2 = (int)jarg2;
22295   if (arg1) (arg1)->width = arg2;
22296 }
22297
22298
22299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
22300   int jresult ;
22301   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22302   int result;
22303
22304   arg1 = (Dali::Rect< int > *)jarg1;
22305   result = (int) ((arg1)->width);
22306   jresult = result;
22307   return jresult;
22308 }
22309
22310
22311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
22312   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22313   int arg2 ;
22314
22315   arg1 = (Dali::Rect< int > *)jarg1;
22316   arg2 = (int)jarg2;
22317   if (arg1) (arg1)->bottom = arg2;
22318 }
22319
22320
22321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
22322   int jresult ;
22323   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22324   int result;
22325
22326   arg1 = (Dali::Rect< int > *)jarg1;
22327   result = (int) ((arg1)->bottom);
22328   jresult = result;
22329   return jresult;
22330 }
22331
22332
22333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
22334   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22335   int arg2 ;
22336
22337   arg1 = (Dali::Rect< int > *)jarg1;
22338   arg2 = (int)jarg2;
22339   if (arg1) (arg1)->height = arg2;
22340 }
22341
22342
22343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
22344   int jresult ;
22345   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22346   int result;
22347
22348   arg1 = (Dali::Rect< int > *)jarg1;
22349   result = (int) ((arg1)->height);
22350   jresult = result;
22351   return jresult;
22352 }
22353
22354
22355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
22356   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22357   int arg2 ;
22358
22359   arg1 = (Dali::Rect< int > *)jarg1;
22360   arg2 = (int)jarg2;
22361   if (arg1) (arg1)->top = arg2;
22362 }
22363
22364
22365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
22366   int jresult ;
22367   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22368   int result;
22369
22370   arg1 = (Dali::Rect< int > *)jarg1;
22371   result = (int) ((arg1)->top);
22372   jresult = result;
22373   return jresult;
22374 }
22375
22376
22377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
22378   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22379
22380   arg1 = (Dali::Rect< int > *)jarg1;
22381   {
22382     try {
22383       delete arg1;
22384     } CALL_CATCH_EXCEPTION();
22385   }
22386
22387 }
22388
22389
22390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
22391   void * jresult ;
22392   Dali::Rect< float > *result = 0 ;
22393
22394   {
22395     try {
22396       result = (Dali::Rect< float > *)new Dali::Rect< float >();
22397     } CALL_CATCH_EXCEPTION(0);
22398   }
22399
22400   jresult = (void *)result;
22401   return jresult;
22402 }
22403
22404
22405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
22406   void * jresult ;
22407   float arg1 ;
22408   float arg2 ;
22409   float arg3 ;
22410   float arg4 ;
22411   Dali::Rect< float > *result = 0 ;
22412
22413   arg1 = (float)jarg1;
22414   arg2 = (float)jarg2;
22415   arg3 = (float)jarg4;
22416   arg4 = (float)jarg3;
22417   {
22418     try {
22419       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
22420     } CALL_CATCH_EXCEPTION(0);
22421   }
22422
22423   jresult = (void *)result;
22424   return jresult;
22425 }
22426
22427
22428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
22429   void * jresult ;
22430   Dali::Rect< float > *arg1 = 0 ;
22431   Dali::Rect< float > *result = 0 ;
22432
22433   arg1 = (Dali::Rect< float > *)jarg1;
22434   if (!arg1) {
22435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
22436     return 0;
22437   }
22438   {
22439     try {
22440       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
22441     } CALL_CATCH_EXCEPTION(0);
22442   }
22443
22444   jresult = (void *)result;
22445   return jresult;
22446 }
22447
22448
22449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
22450   void * jresult ;
22451   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22452   Dali::Rect< float > *arg2 = 0 ;
22453   Dali::Rect< float > *result = 0 ;
22454
22455   arg1 = (Dali::Rect< float > *)jarg1;
22456   arg2 = (Dali::Rect< float > *)jarg2;
22457   if (!arg2) {
22458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
22459     return 0;
22460   }
22461   {
22462     try {
22463       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
22464     } CALL_CATCH_EXCEPTION(0);
22465   }
22466
22467   jresult = (void *)result;
22468   return jresult;
22469 }
22470
22471
22472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
22473   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22474   float arg2 ;
22475   float arg3 ;
22476   float arg4 ;
22477   float arg5 ;
22478
22479   arg1 = (Dali::Rect< float > *)jarg1;
22480   arg2 = (float)jarg2;
22481   arg3 = (float)jarg3;
22482   arg4 = (float)jarg5;
22483   arg5 = (float)jarg4;
22484   {
22485     try {
22486       (arg1)->Set(arg2,arg3,arg4,arg5);
22487     } CALL_CATCH_EXCEPTION();
22488   }
22489
22490 }
22491
22492
22493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
22494   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22495   float arg2 ;
22496
22497   arg1 = (Dali::Rect< float > *)jarg1;
22498   arg2 = (float)jarg2;
22499   if (arg1) (arg1)->left = arg2;
22500 }
22501
22502
22503 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
22504   float jresult ;
22505   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22506   float result;
22507
22508   arg1 = (Dali::Rect< float > *)jarg1;
22509   result = (float) ((arg1)->left);
22510   jresult = result;
22511   return jresult;
22512 }
22513
22514
22515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
22516   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22517   float arg2 ;
22518
22519   arg1 = (Dali::Rect< float > *)jarg1;
22520   arg2 = (float)jarg2;
22521   if (arg1) (arg1)->left = arg2;
22522 }
22523
22524
22525 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
22526   float jresult ;
22527   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22528   float result;
22529
22530   arg1 = (Dali::Rect< float > *)jarg1;
22531   result = (float) ((arg1)->left);
22532   jresult = result;
22533   return jresult;
22534 }
22535
22536
22537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
22538   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22539   float arg2 ;
22540
22541   arg1 = (Dali::Rect< float > *)jarg1;
22542   arg2 = (float)jarg2;
22543   if (arg1) (arg1)->right = arg2;
22544 }
22545
22546
22547 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
22548   float jresult ;
22549   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22550   float result;
22551
22552   arg1 = (Dali::Rect< float > *)jarg1;
22553   result = (float) ((arg1)->right);
22554   jresult = result;
22555   return jresult;
22556 }
22557
22558
22559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
22560   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22561   float arg2 ;
22562
22563   arg1 = (Dali::Rect< float > *)jarg1;
22564   arg2 = (float)jarg2;
22565   if (arg1) (arg1)->right = arg2;
22566 }
22567
22568
22569 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
22570   float jresult ;
22571   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22572   float result;
22573
22574   arg1 = (Dali::Rect< float > *)jarg1;
22575   result = (float) ((arg1)->right);
22576   jresult = result;
22577   return jresult;
22578 }
22579
22580
22581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
22582   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22583   float arg2 ;
22584
22585   arg1 = (Dali::Rect< float > *)jarg1;
22586   arg2 = (float)jarg2;
22587   if (arg1) (arg1)->bottom = arg2;
22588 }
22589
22590
22591 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
22592   float jresult ;
22593   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22594   float result;
22595
22596   arg1 = (Dali::Rect< float > *)jarg1;
22597   result = (float) ((arg1)->bottom);
22598   jresult = result;
22599   return jresult;
22600 }
22601
22602
22603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
22604   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22605   float arg2 ;
22606
22607   arg1 = (Dali::Rect< float > *)jarg1;
22608   arg2 = (float)jarg2;
22609   if (arg1) (arg1)->top = arg2;
22610 }
22611
22612
22613 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
22614   float jresult ;
22615   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22616   float result;
22617
22618   arg1 = (Dali::Rect< float > *)jarg1;
22619   result = (float) ((arg1)->top);
22620   jresult = result;
22621   return jresult;
22622 }
22623
22624
22625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
22626   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22627
22628   arg1 = (Dali::Rect< float > *)jarg1;
22629   {
22630     try {
22631       delete arg1;
22632     } CALL_CATCH_EXCEPTION();
22633   }
22634
22635 }
22636
22637
22638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
22639   int jresult ;
22640   int result;
22641
22642   result = (int)Dali::Vector< int >::BaseType;
22643   jresult = (int)result;
22644   return jresult;
22645 }
22646
22647
22648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
22649   void * jresult ;
22650   Dali::Vector< int > *result = 0 ;
22651
22652   {
22653     try {
22654       result = (Dali::Vector< int > *)new Dali::Vector< int >();
22655     } CALL_CATCH_EXCEPTION(0);
22656   }
22657
22658   jresult = (void *)result;
22659   return jresult;
22660 }
22661
22662
22663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
22664   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22665
22666   arg1 = (Dali::Vector< int > *)jarg1;
22667   {
22668     try {
22669       delete arg1;
22670     } CALL_CATCH_EXCEPTION();
22671   }
22672
22673 }
22674
22675
22676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
22677   void * jresult ;
22678   Dali::Vector< int > *arg1 = 0 ;
22679   Dali::Vector< int > *result = 0 ;
22680
22681   arg1 = (Dali::Vector< int > *)jarg1;
22682   if (!arg1) {
22683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
22684     return 0;
22685   }
22686   {
22687     try {
22688       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
22689     } CALL_CATCH_EXCEPTION(0);
22690   }
22691
22692   jresult = (void *)result;
22693   return jresult;
22694 }
22695
22696
22697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
22698   void * jresult ;
22699   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22700   Dali::Vector< int > *arg2 = 0 ;
22701   Dali::Vector< int > *result = 0 ;
22702
22703   arg1 = (Dali::Vector< int > *)jarg1;
22704   arg2 = (Dali::Vector< int > *)jarg2;
22705   if (!arg2) {
22706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
22707     return 0;
22708   }
22709   {
22710     try {
22711       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
22712     } CALL_CATCH_EXCEPTION(0);
22713   }
22714
22715   jresult = (void *)result;
22716   return jresult;
22717 }
22718
22719
22720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
22721   void * jresult ;
22722   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22723   Dali::Vector< int >::Iterator result;
22724
22725   arg1 = (Dali::Vector< int > *)jarg1;
22726   {
22727     try {
22728       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
22729     } CALL_CATCH_EXCEPTION(0);
22730   }
22731
22732   jresult = (void *)result;
22733   return jresult;
22734 }
22735
22736
22737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
22738   void * jresult ;
22739   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22740   Dali::Vector< int >::Iterator result;
22741
22742   arg1 = (Dali::Vector< int > *)jarg1;
22743   {
22744     try {
22745       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
22746     } CALL_CATCH_EXCEPTION(0);
22747   }
22748
22749   jresult = (void *)result;
22750   return jresult;
22751 }
22752
22753
22754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
22755   void * jresult ;
22756   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22757   Dali::Vector< int >::SizeType arg2 ;
22758   Dali::Vector< int >::ItemType *result = 0 ;
22759
22760   arg1 = (Dali::Vector< int > *)jarg1;
22761   arg2 = (Dali::Vector< int >::SizeType)jarg2;
22762   {
22763     try {
22764       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
22765     } CALL_CATCH_EXCEPTION(0);
22766   }
22767
22768   jresult = (void *)result;
22769   return jresult;
22770 }
22771
22772
22773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
22774   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22775   Dali::Vector< int >::ItemType *arg2 = 0 ;
22776   Dali::Vector< int >::ItemType temp2 ;
22777
22778   arg1 = (Dali::Vector< int > *)jarg1;
22779   temp2 = (Dali::Vector< int >::ItemType)jarg2;
22780   arg2 = &temp2;
22781   {
22782     try {
22783       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
22784     } CALL_CATCH_EXCEPTION();
22785   }
22786
22787 }
22788
22789
22790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
22791   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22792   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
22793   Dali::Vector< int >::ItemType *arg3 = 0 ;
22794   Dali::Vector< int >::ItemType temp3 ;
22795
22796   arg1 = (Dali::Vector< int > *)jarg1;
22797   arg2 = (Dali::Vector< int >::Iterator)jarg2;
22798   temp3 = (Dali::Vector< int >::ItemType)jarg3;
22799   arg3 = &temp3;
22800   {
22801     try {
22802       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
22803     } CALL_CATCH_EXCEPTION();
22804   }
22805
22806 }
22807
22808
22809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
22810   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22811   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
22812   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
22813   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
22814
22815   arg1 = (Dali::Vector< int > *)jarg1;
22816   arg2 = (Dali::Vector< int >::Iterator)jarg2;
22817   arg3 = (Dali::Vector< int >::Iterator)jarg3;
22818   arg4 = (Dali::Vector< int >::Iterator)jarg4;
22819   {
22820     try {
22821       (arg1)->Insert(arg2,arg3,arg4);
22822     } CALL_CATCH_EXCEPTION();
22823   }
22824
22825 }
22826
22827
22828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
22829   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22830   Dali::Vector< int >::SizeType arg2 ;
22831
22832   arg1 = (Dali::Vector< int > *)jarg1;
22833   arg2 = (Dali::Vector< int >::SizeType)jarg2;
22834   {
22835     try {
22836       (arg1)->Reserve(arg2);
22837     } CALL_CATCH_EXCEPTION();
22838   }
22839
22840 }
22841
22842
22843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
22844   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22845   Dali::Vector< int >::SizeType arg2 ;
22846
22847   arg1 = (Dali::Vector< int > *)jarg1;
22848   arg2 = (Dali::Vector< int >::SizeType)jarg2;
22849   {
22850     try {
22851       (arg1)->Resize(arg2);
22852     } CALL_CATCH_EXCEPTION();
22853   }
22854
22855 }
22856
22857
22858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
22859   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22860   Dali::Vector< int >::SizeType arg2 ;
22861   Dali::Vector< int >::ItemType *arg3 = 0 ;
22862   Dali::Vector< int >::ItemType temp3 ;
22863
22864   arg1 = (Dali::Vector< int > *)jarg1;
22865   arg2 = (Dali::Vector< int >::SizeType)jarg2;
22866   temp3 = (Dali::Vector< int >::ItemType)jarg3;
22867   arg3 = &temp3;
22868   {
22869     try {
22870       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
22871     } CALL_CATCH_EXCEPTION();
22872   }
22873
22874 }
22875
22876
22877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
22878   void * jresult ;
22879   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22880   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
22881   Dali::Vector< int >::Iterator result;
22882
22883   arg1 = (Dali::Vector< int > *)jarg1;
22884   arg2 = (Dali::Vector< int >::Iterator)jarg2;
22885   {
22886     try {
22887       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
22888     } CALL_CATCH_EXCEPTION(0);
22889   }
22890
22891   jresult = (void *)result;
22892   return jresult;
22893 }
22894
22895
22896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
22897   void * jresult ;
22898   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22899   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
22900   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
22901   Dali::Vector< int >::Iterator result;
22902
22903   arg1 = (Dali::Vector< int > *)jarg1;
22904   arg2 = (Dali::Vector< int >::Iterator)jarg2;
22905   arg3 = (Dali::Vector< int >::Iterator)jarg3;
22906   {
22907     try {
22908       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
22909     } CALL_CATCH_EXCEPTION(0);
22910   }
22911
22912   jresult = (void *)result;
22913   return jresult;
22914 }
22915
22916
22917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
22918   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22919   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
22920
22921   arg1 = (Dali::Vector< int > *)jarg1;
22922   arg2 = (Dali::Vector< int >::Iterator)jarg2;
22923   {
22924     try {
22925       (arg1)->Remove(arg2);
22926     } CALL_CATCH_EXCEPTION();
22927   }
22928
22929 }
22930
22931
22932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
22933   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22934   Dali::Vector< int > *arg2 = 0 ;
22935
22936   arg1 = (Dali::Vector< int > *)jarg1;
22937   arg2 = (Dali::Vector< int > *)jarg2;
22938   if (!arg2) {
22939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
22940     return ;
22941   }
22942   {
22943     try {
22944       (arg1)->Swap(*arg2);
22945     } CALL_CATCH_EXCEPTION();
22946   }
22947
22948 }
22949
22950
22951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
22952   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22953
22954   arg1 = (Dali::Vector< int > *)jarg1;
22955   {
22956     try {
22957       (arg1)->Clear();
22958     } CALL_CATCH_EXCEPTION();
22959   }
22960
22961 }
22962
22963
22964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
22965   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22966
22967   arg1 = (Dali::Vector< int > *)jarg1;
22968   {
22969     try {
22970       (arg1)->Release();
22971     } CALL_CATCH_EXCEPTION();
22972   }
22973
22974 }
22975
22976
22977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
22978   int jresult ;
22979   int result;
22980
22981   result = (int)Dali::Vector< float >::BaseType;
22982   jresult = (int)result;
22983   return jresult;
22984 }
22985
22986
22987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
22988   void * jresult ;
22989   Dali::Vector< float > *result = 0 ;
22990
22991   {
22992     try {
22993       result = (Dali::Vector< float > *)new Dali::Vector< float >();
22994     } CALL_CATCH_EXCEPTION(0);
22995   }
22996
22997   jresult = (void *)result;
22998   return jresult;
22999 }
23000
23001
23002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
23003   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23004
23005   arg1 = (Dali::Vector< float > *)jarg1;
23006   {
23007     try {
23008       delete arg1;
23009     } CALL_CATCH_EXCEPTION();
23010   }
23011
23012 }
23013
23014
23015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
23016   void * jresult ;
23017   Dali::Vector< float > *arg1 = 0 ;
23018   Dali::Vector< float > *result = 0 ;
23019
23020   arg1 = (Dali::Vector< float > *)jarg1;
23021   if (!arg1) {
23022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
23023     return 0;
23024   }
23025   {
23026     try {
23027       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
23028     } CALL_CATCH_EXCEPTION(0);
23029   }
23030
23031   jresult = (void *)result;
23032   return jresult;
23033 }
23034
23035
23036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
23037   void * jresult ;
23038   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23039   Dali::Vector< float > *arg2 = 0 ;
23040   Dali::Vector< float > *result = 0 ;
23041
23042   arg1 = (Dali::Vector< float > *)jarg1;
23043   arg2 = (Dali::Vector< float > *)jarg2;
23044   if (!arg2) {
23045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
23046     return 0;
23047   }
23048   {
23049     try {
23050       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
23051     } CALL_CATCH_EXCEPTION(0);
23052   }
23053
23054   jresult = (void *)result;
23055   return jresult;
23056 }
23057
23058
23059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
23060   void * jresult ;
23061   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23062   Dali::Vector< float >::Iterator result;
23063
23064   arg1 = (Dali::Vector< float > *)jarg1;
23065   {
23066     try {
23067       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
23068     } CALL_CATCH_EXCEPTION(0);
23069   }
23070
23071   jresult = (void *)result;
23072   return jresult;
23073 }
23074
23075
23076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
23077   void * jresult ;
23078   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23079   Dali::Vector< float >::Iterator result;
23080
23081   arg1 = (Dali::Vector< float > *)jarg1;
23082   {
23083     try {
23084       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
23085     } CALL_CATCH_EXCEPTION(0);
23086   }
23087
23088   jresult = (void *)result;
23089   return jresult;
23090 }
23091
23092
23093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
23094   void * jresult ;
23095   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23096   Dali::Vector< float >::SizeType arg2 ;
23097   Dali::Vector< float >::ItemType *result = 0 ;
23098
23099   arg1 = (Dali::Vector< float > *)jarg1;
23100   arg2 = (Dali::Vector< float >::SizeType)jarg2;
23101   {
23102     try {
23103       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
23104     } CALL_CATCH_EXCEPTION(0);
23105   }
23106
23107   jresult = (void *)result;
23108   return jresult;
23109 }
23110
23111
23112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
23113   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23114   Dali::Vector< float >::ItemType *arg2 = 0 ;
23115   Dali::Vector< float >::ItemType temp2 ;
23116
23117   arg1 = (Dali::Vector< float > *)jarg1;
23118   temp2 = (Dali::Vector< float >::ItemType)jarg2;
23119   arg2 = &temp2;
23120   {
23121     try {
23122       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
23123     } CALL_CATCH_EXCEPTION();
23124   }
23125
23126 }
23127
23128
23129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
23130   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23131   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
23132   Dali::Vector< float >::ItemType *arg3 = 0 ;
23133   Dali::Vector< float >::ItemType temp3 ;
23134
23135   arg1 = (Dali::Vector< float > *)jarg1;
23136   arg2 = (Dali::Vector< float >::Iterator)jarg2;
23137   temp3 = (Dali::Vector< float >::ItemType)jarg3;
23138   arg3 = &temp3;
23139   {
23140     try {
23141       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
23142     } CALL_CATCH_EXCEPTION();
23143   }
23144
23145 }
23146
23147
23148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
23149   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23150   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
23151   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
23152   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
23153
23154   arg1 = (Dali::Vector< float > *)jarg1;
23155   arg2 = (Dali::Vector< float >::Iterator)jarg2;
23156   arg3 = (Dali::Vector< float >::Iterator)jarg3;
23157   arg4 = (Dali::Vector< float >::Iterator)jarg4;
23158   {
23159     try {
23160       (arg1)->Insert(arg2,arg3,arg4);
23161     } CALL_CATCH_EXCEPTION();
23162   }
23163
23164 }
23165
23166
23167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
23168   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23169   Dali::Vector< float >::SizeType arg2 ;
23170
23171   arg1 = (Dali::Vector< float > *)jarg1;
23172   arg2 = (Dali::Vector< float >::SizeType)jarg2;
23173   {
23174     try {
23175       (arg1)->Reserve(arg2);
23176     } CALL_CATCH_EXCEPTION();
23177   }
23178
23179 }
23180
23181 //// ========================= end of part 2 =============================
23182
23183 //// ========================== start part 3 ===============================
23184
23185
23186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
23187   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23188   Dali::Vector< float >::SizeType arg2 ;
23189
23190   arg1 = (Dali::Vector< float > *)jarg1;
23191   arg2 = (Dali::Vector< float >::SizeType)jarg2;
23192   {
23193     try {
23194       (arg1)->Resize(arg2);
23195     } CALL_CATCH_EXCEPTION();
23196   }
23197
23198 }
23199
23200
23201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
23202   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23203   Dali::Vector< float >::SizeType arg2 ;
23204   Dali::Vector< float >::ItemType *arg3 = 0 ;
23205   Dali::Vector< float >::ItemType temp3 ;
23206
23207   arg1 = (Dali::Vector< float > *)jarg1;
23208   arg2 = (Dali::Vector< float >::SizeType)jarg2;
23209   temp3 = (Dali::Vector< float >::ItemType)jarg3;
23210   arg3 = &temp3;
23211   {
23212     try {
23213       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
23214     } CALL_CATCH_EXCEPTION();
23215   }
23216
23217 }
23218
23219
23220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
23221   void * jresult ;
23222   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23223   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
23224   Dali::Vector< float >::Iterator result;
23225
23226   arg1 = (Dali::Vector< float > *)jarg1;
23227   arg2 = (Dali::Vector< float >::Iterator)jarg2;
23228   {
23229     try {
23230       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
23231     } CALL_CATCH_EXCEPTION(0);
23232   }
23233
23234   jresult = (void *)result;
23235   return jresult;
23236 }
23237
23238
23239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
23240   void * jresult ;
23241   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23242   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
23243   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
23244   Dali::Vector< float >::Iterator result;
23245
23246   arg1 = (Dali::Vector< float > *)jarg1;
23247   arg2 = (Dali::Vector< float >::Iterator)jarg2;
23248   arg3 = (Dali::Vector< float >::Iterator)jarg3;
23249   {
23250     try {
23251       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
23252     } CALL_CATCH_EXCEPTION(0);
23253   }
23254
23255   jresult = (void *)result;
23256   return jresult;
23257 }
23258
23259
23260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
23261   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23262   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
23263
23264   arg1 = (Dali::Vector< float > *)jarg1;
23265   arg2 = (Dali::Vector< float >::Iterator)jarg2;
23266   {
23267     try {
23268       (arg1)->Remove(arg2);
23269     } CALL_CATCH_EXCEPTION();
23270   }
23271
23272 }
23273
23274
23275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
23276   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23277   Dali::Vector< float > *arg2 = 0 ;
23278
23279   arg1 = (Dali::Vector< float > *)jarg1;
23280   arg2 = (Dali::Vector< float > *)jarg2;
23281   if (!arg2) {
23282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
23283     return ;
23284   }
23285   {
23286     try {
23287       (arg1)->Swap(*arg2);
23288     } CALL_CATCH_EXCEPTION();
23289   }
23290
23291 }
23292
23293
23294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
23295   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23296
23297   arg1 = (Dali::Vector< float > *)jarg1;
23298   {
23299     try {
23300       (arg1)->Clear();
23301     } CALL_CATCH_EXCEPTION();
23302   }
23303
23304 }
23305
23306
23307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
23308   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23309
23310   arg1 = (Dali::Vector< float > *)jarg1;
23311   {
23312     try {
23313       (arg1)->Release();
23314     } CALL_CATCH_EXCEPTION();
23315   }
23316
23317 }
23318
23319
23320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
23321   int jresult ;
23322   int result;
23323
23324   result = (int)Dali::Vector< unsigned char >::BaseType;
23325   jresult = (int)result;
23326   return jresult;
23327 }
23328
23329
23330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
23331   void * jresult ;
23332   Dali::Vector< unsigned char > *result = 0 ;
23333
23334   {
23335     try {
23336       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
23337     } CALL_CATCH_EXCEPTION(0);
23338   }
23339
23340   jresult = (void *)result;
23341   return jresult;
23342 }
23343
23344
23345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
23346   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23347
23348   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23349   {
23350     try {
23351       delete arg1;
23352     } CALL_CATCH_EXCEPTION();
23353   }
23354
23355 }
23356
23357
23358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
23359   void * jresult ;
23360   Dali::Vector< unsigned char > *arg1 = 0 ;
23361   Dali::Vector< unsigned char > *result = 0 ;
23362
23363   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23364   if (!arg1) {
23365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
23366     return 0;
23367   }
23368   {
23369     try {
23370       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
23371     } CALL_CATCH_EXCEPTION(0);
23372   }
23373
23374   jresult = (void *)result;
23375   return jresult;
23376 }
23377
23378
23379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
23380   void * jresult ;
23381   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23382   Dali::Vector< unsigned char > *arg2 = 0 ;
23383   Dali::Vector< unsigned char > *result = 0 ;
23384
23385   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23386   arg2 = (Dali::Vector< unsigned char > *)jarg2;
23387   if (!arg2) {
23388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
23389     return 0;
23390   }
23391   {
23392     try {
23393       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
23394     } CALL_CATCH_EXCEPTION(0);
23395   }
23396
23397   jresult = (void *)result;
23398   return jresult;
23399 }
23400
23401
23402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
23403   void * jresult ;
23404   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23405   Dali::Vector< unsigned char >::Iterator result;
23406
23407   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23408   {
23409     try {
23410       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
23411     } CALL_CATCH_EXCEPTION(0);
23412   }
23413
23414   jresult = (void *)result;
23415   return jresult;
23416 }
23417
23418
23419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
23420   void * jresult ;
23421   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23422   Dali::Vector< unsigned char >::Iterator result;
23423
23424   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23425   {
23426     try {
23427       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
23428     } CALL_CATCH_EXCEPTION(0);
23429   }
23430
23431   jresult = (void *)result;
23432   return jresult;
23433 }
23434
23435
23436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
23437   void * jresult ;
23438   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23439   Dali::Vector< unsigned char >::SizeType arg2 ;
23440   Dali::Vector< unsigned char >::ItemType *result = 0 ;
23441
23442   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23443   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
23444   {
23445     try {
23446       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
23447     } CALL_CATCH_EXCEPTION(0);
23448   }
23449
23450   jresult = (void *)result;
23451   return jresult;
23452 }
23453
23454
23455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
23456   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23457   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
23458   Dali::Vector< unsigned char >::ItemType temp2 ;
23459
23460   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23461   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
23462   arg2 = &temp2;
23463   {
23464     try {
23465       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
23466     } CALL_CATCH_EXCEPTION();
23467   }
23468
23469 }
23470
23471
23472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
23473   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23474   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
23475   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
23476   Dali::Vector< unsigned char >::ItemType temp3 ;
23477
23478   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23479   arg2 = jarg2;
23480   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
23481   arg3 = &temp3;
23482   {
23483     try {
23484       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
23485     } CALL_CATCH_EXCEPTION();
23486   }
23487
23488
23489
23490 }
23491
23492
23493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
23494   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23495   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
23496   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
23497   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
23498
23499   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23500   arg2 = jarg2;
23501   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
23502   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
23503   {
23504     try {
23505       (arg1)->Insert(arg2,arg3,arg4);
23506     } CALL_CATCH_EXCEPTION();
23507   }
23508
23509
23510
23511 }
23512
23513
23514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
23515   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23516   Dali::Vector< unsigned char >::SizeType arg2 ;
23517
23518   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23519   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
23520   {
23521     try {
23522       (arg1)->Reserve(arg2);
23523     } CALL_CATCH_EXCEPTION();
23524   }
23525
23526 }
23527
23528
23529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
23530   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23531   Dali::Vector< unsigned char >::SizeType arg2 ;
23532
23533   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23534   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
23535   {
23536     try {
23537       (arg1)->Resize(arg2);
23538     } CALL_CATCH_EXCEPTION();
23539   }
23540
23541 }
23542
23543
23544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
23545   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23546   Dali::Vector< unsigned char >::SizeType arg2 ;
23547   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
23548   Dali::Vector< unsigned char >::ItemType temp3 ;
23549
23550   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23551   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
23552   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
23553   arg3 = &temp3;
23554   {
23555     try {
23556       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
23557     } CALL_CATCH_EXCEPTION();
23558   }
23559
23560 }
23561
23562
23563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
23564   void * jresult ;
23565   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23566   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
23567   Dali::Vector< unsigned char >::Iterator result;
23568
23569   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23570   arg2 = jarg2;
23571   {
23572     try {
23573       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
23574     } CALL_CATCH_EXCEPTION(0);
23575   }
23576
23577   jresult = (void *)result;
23578
23579
23580   return jresult;
23581 }
23582
23583
23584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
23585   void * jresult ;
23586   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23587   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
23588   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
23589   Dali::Vector< unsigned char >::Iterator result;
23590
23591   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23592   arg2 = jarg2;
23593   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
23594   {
23595     try {
23596       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
23597     } CALL_CATCH_EXCEPTION(0);
23598   }
23599
23600   jresult = (void *)result;
23601
23602
23603   return jresult;
23604 }
23605
23606
23607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
23608   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23609   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
23610
23611   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23612   arg2 = jarg2;
23613   {
23614     try {
23615       (arg1)->Remove(arg2);
23616     } CALL_CATCH_EXCEPTION();
23617   }
23618
23619
23620
23621 }
23622
23623
23624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
23625   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23626   Dali::Vector< unsigned char > *arg2 = 0 ;
23627
23628   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23629   arg2 = (Dali::Vector< unsigned char > *)jarg2;
23630   if (!arg2) {
23631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
23632     return ;
23633   }
23634   {
23635     try {
23636       (arg1)->Swap(*arg2);
23637     } CALL_CATCH_EXCEPTION();
23638   }
23639
23640 }
23641
23642
23643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
23644   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23645
23646   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23647   {
23648     try {
23649       (arg1)->Clear();
23650     } CALL_CATCH_EXCEPTION();
23651   }
23652
23653 }
23654
23655
23656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
23657   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23658
23659   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23660   {
23661     try {
23662       (arg1)->Release();
23663     } CALL_CATCH_EXCEPTION();
23664   }
23665
23666 }
23667
23668
23669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
23670   int jresult ;
23671   int result;
23672
23673   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
23674   jresult = (int)result;
23675   return jresult;
23676 }
23677
23678
23679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
23680   void * jresult ;
23681   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
23682
23683   {
23684     try {
23685       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
23686     } CALL_CATCH_EXCEPTION(0);
23687   }
23688
23689   jresult = (void *)result;
23690   return jresult;
23691 }
23692
23693
23694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
23695   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23696
23697   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23698   {
23699     try {
23700       delete arg1;
23701     } CALL_CATCH_EXCEPTION();
23702   }
23703
23704 }
23705
23706
23707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
23708   void * jresult ;
23709   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
23710   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
23711
23712   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23713   if (!arg1) {
23714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
23715     return 0;
23716   }
23717   {
23718     try {
23719       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
23720     } CALL_CATCH_EXCEPTION(0);
23721   }
23722
23723   jresult = (void *)result;
23724   return jresult;
23725 }
23726
23727
23728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
23729   void * jresult ;
23730   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23731   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
23732   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
23733
23734   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23735   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
23736   if (!arg2) {
23737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
23738     return 0;
23739   }
23740   {
23741     try {
23742       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
23743     } CALL_CATCH_EXCEPTION(0);
23744   }
23745
23746   jresult = (void *)result;
23747   return jresult;
23748 }
23749
23750
23751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
23752   void * jresult ;
23753   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23754   Dali::Vector< Dali::Uint16Pair >::Iterator result;
23755
23756   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23757   {
23758     try {
23759       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
23760     } CALL_CATCH_EXCEPTION(0);
23761   }
23762
23763   jresult = (void *)result;
23764   return jresult;
23765 }
23766
23767
23768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
23769   void * jresult ;
23770   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23771   Dali::Vector< Dali::Uint16Pair >::Iterator result;
23772
23773   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23774   {
23775     try {
23776       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
23777     } CALL_CATCH_EXCEPTION(0);
23778   }
23779
23780   jresult = (void *)result;
23781   return jresult;
23782 }
23783
23784
23785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
23786   void * jresult ;
23787   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23788   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
23789   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
23790
23791   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23792   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
23793   {
23794     try {
23795       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
23796     } CALL_CATCH_EXCEPTION(0);
23797   }
23798
23799   jresult = (void *)result;
23800   return jresult;
23801 }
23802
23803
23804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
23805   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23806   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
23807
23808   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23809   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
23810   if (!arg2) {
23811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
23812     return ;
23813   }
23814   {
23815     try {
23816       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
23817     } CALL_CATCH_EXCEPTION();
23818   }
23819
23820 }
23821
23822
23823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
23824   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23825   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
23826   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
23827
23828   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23829   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
23830   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
23831   if (!arg3) {
23832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
23833     return ;
23834   }
23835   {
23836     try {
23837       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
23838     } CALL_CATCH_EXCEPTION();
23839   }
23840
23841 }
23842
23843
23844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
23845   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23846   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
23847   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
23848   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
23849
23850   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23851   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
23852   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
23853   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
23854   {
23855     try {
23856       (arg1)->Insert(arg2,arg3,arg4);
23857     } CALL_CATCH_EXCEPTION();
23858   }
23859
23860 }
23861
23862
23863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
23864   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23865   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
23866
23867   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23868   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
23869   {
23870     try {
23871       (arg1)->Reserve(arg2);
23872     } CALL_CATCH_EXCEPTION();
23873   }
23874
23875 }
23876
23877
23878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
23879   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23880   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
23881
23882   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23883   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
23884   {
23885     try {
23886       (arg1)->Resize(arg2);
23887     } CALL_CATCH_EXCEPTION();
23888   }
23889
23890 }
23891
23892
23893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
23894   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23895   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
23896   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
23897
23898   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23899   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
23900   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
23901   if (!arg3) {
23902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
23903     return ;
23904   }
23905   {
23906     try {
23907       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
23908     } CALL_CATCH_EXCEPTION();
23909   }
23910
23911 }
23912
23913
23914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
23915   void * jresult ;
23916   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23917   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
23918   Dali::Vector< Dali::Uint16Pair >::Iterator result;
23919
23920   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23921   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
23922   {
23923     try {
23924       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
23925     } CALL_CATCH_EXCEPTION(0);
23926   }
23927
23928   jresult = (void *)result;
23929   return jresult;
23930 }
23931
23932
23933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
23934   void * jresult ;
23935   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23936   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
23937   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
23938   Dali::Vector< Dali::Uint16Pair >::Iterator result;
23939
23940   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23941   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
23942   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
23943   {
23944     try {
23945       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
23946     } CALL_CATCH_EXCEPTION(0);
23947   }
23948
23949   jresult = (void *)result;
23950   return jresult;
23951 }
23952
23953
23954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
23955   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23956   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
23957
23958   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23959   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
23960   {
23961     try {
23962       (arg1)->Remove(arg2);
23963     } CALL_CATCH_EXCEPTION();
23964   }
23965
23966 }
23967
23968
23969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
23970   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23971   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
23972
23973   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23974   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
23975   if (!arg2) {
23976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
23977     return ;
23978   }
23979   {
23980     try {
23981       (arg1)->Swap(*arg2);
23982     } CALL_CATCH_EXCEPTION();
23983   }
23984
23985 }
23986
23987
23988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
23989   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23990
23991   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23992   {
23993     try {
23994       (arg1)->Clear();
23995     } CALL_CATCH_EXCEPTION();
23996   }
23997
23998 }
23999
24000
24001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
24002   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
24003
24004   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
24005   {
24006     try {
24007       (arg1)->Release();
24008     } CALL_CATCH_EXCEPTION();
24009   }
24010
24011 }
24012
24013
24014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
24015   void * jresult ;
24016   Dali::Signal< void () > *result = 0 ;
24017
24018   {
24019     try {
24020       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
24021     } CALL_CATCH_EXCEPTION(0);
24022   }
24023
24024   jresult = (void *)result;
24025   return jresult;
24026 }
24027
24028
24029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
24030   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
24031
24032   arg1 = (Dali::Signal< void () > *)jarg1;
24033   {
24034     try {
24035       delete arg1;
24036     } CALL_CATCH_EXCEPTION();
24037   }
24038
24039 }
24040
24041
24042 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
24043   bool jresult ;
24044   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
24045   bool result;
24046
24047   arg1 = (Dali::Signal< void () > *)jarg1;
24048   {
24049     try {
24050       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
24051     } CALL_CATCH_EXCEPTION(0);
24052   }
24053
24054   jresult = result;
24055   return jresult;
24056 }
24057
24058
24059 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
24060   unsigned long jresult ;
24061   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
24062   std::size_t result;
24063
24064   arg1 = (Dali::Signal< void () > *)jarg1;
24065   {
24066     try {
24067       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
24068     } CALL_CATCH_EXCEPTION(0);
24069   }
24070
24071   jresult = (unsigned long)result;
24072   return jresult;
24073 }
24074
24075
24076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
24077   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
24078   void (*arg2)() = (void (*)()) 0 ;
24079
24080   arg1 = (Dali::Signal< void () > *)jarg1;
24081   arg2 = (void (*)())jarg2;
24082   {
24083     try {
24084       (arg1)->Connect(arg2);
24085     } CALL_CATCH_EXCEPTION();
24086   }
24087
24088 }
24089
24090
24091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
24092   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
24093   void (*arg2)() = (void (*)()) 0 ;
24094
24095   arg1 = (Dali::Signal< void () > *)jarg1;
24096   arg2 = (void (*)())jarg2;
24097   {
24098     try {
24099       (arg1)->Disconnect(arg2);
24100     } CALL_CATCH_EXCEPTION();
24101   }
24102
24103 }
24104
24105
24106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
24107   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
24108   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
24109   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
24110
24111   arg1 = (Dali::Signal< void () > *)jarg1;
24112   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
24113   arg3 = (Dali::FunctorDelegate *)jarg3;
24114   {
24115     try {
24116       (arg1)->Connect(arg2,arg3);
24117     } CALL_CATCH_EXCEPTION();
24118   }
24119
24120 }
24121
24122
24123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
24124   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
24125
24126   arg1 = (Dali::Signal< void () > *)jarg1;
24127   {
24128     try {
24129       (arg1)->Emit();
24130     } CALL_CATCH_EXCEPTION();
24131   }
24132
24133 }
24134
24135
24136 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
24137   bool jresult ;
24138   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
24139   bool result;
24140
24141   arg1 = (Dali::Signal< void (float) > *)jarg1;
24142   {
24143     try {
24144       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
24145     } CALL_CATCH_EXCEPTION(0);
24146   }
24147
24148   jresult = result;
24149   return jresult;
24150 }
24151
24152
24153 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
24154   unsigned long jresult ;
24155   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
24156   std::size_t result;
24157
24158   arg1 = (Dali::Signal< void (float) > *)jarg1;
24159   {
24160     try {
24161       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
24162     } CALL_CATCH_EXCEPTION(0);
24163   }
24164
24165   jresult = (unsigned long)result;
24166   return jresult;
24167 }
24168
24169
24170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
24171   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
24172   void (*arg2)(float) = (void (*)(float)) 0 ;
24173
24174   arg1 = (Dali::Signal< void (float) > *)jarg1;
24175   arg2 = (void (*)(float))jarg2;
24176   {
24177     try {
24178       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
24179     } CALL_CATCH_EXCEPTION();
24180   }
24181
24182 }
24183
24184
24185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
24186   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
24187   void (*arg2)(float) = (void (*)(float)) 0 ;
24188
24189   arg1 = (Dali::Signal< void (float) > *)jarg1;
24190   arg2 = (void (*)(float))jarg2;
24191   {
24192     try {
24193       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
24194     } CALL_CATCH_EXCEPTION();
24195   }
24196
24197 }
24198
24199
24200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
24201   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
24202   float arg2 ;
24203
24204   arg1 = (Dali::Signal< void (float) > *)jarg1;
24205   arg2 = (float)jarg2;
24206   {
24207     try {
24208       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
24209     } CALL_CATCH_EXCEPTION();
24210   }
24211
24212 }
24213
24214
24215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
24216   void * jresult ;
24217   Dali::Signal< void (float) > *result = 0 ;
24218
24219   {
24220     try {
24221       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
24222     } CALL_CATCH_EXCEPTION(0);
24223   }
24224
24225   jresult = (void *)result;
24226   return jresult;
24227 }
24228
24229
24230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
24231   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
24232
24233   arg1 = (Dali::Signal< void (float) > *)jarg1;
24234   {
24235     try {
24236       delete arg1;
24237     } CALL_CATCH_EXCEPTION();
24238   }
24239
24240 }
24241
24242
24243 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
24244   bool jresult ;
24245   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
24246   bool result;
24247
24248   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
24249   {
24250     try {
24251       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
24252     } CALL_CATCH_EXCEPTION(0);
24253   }
24254
24255   jresult = result;
24256   return jresult;
24257 }
24258
24259
24260 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
24261   unsigned long jresult ;
24262   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
24263   std::size_t result;
24264
24265   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
24266   {
24267     try {
24268       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
24269     } CALL_CATCH_EXCEPTION(0);
24270   }
24271
24272   jresult = (unsigned long)result;
24273   return jresult;
24274 }
24275
24276
24277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
24278   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
24279   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
24280
24281   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
24282   arg2 = (void (*)(Dali::BaseHandle))jarg2;
24283   {
24284     try {
24285       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
24286     } CALL_CATCH_EXCEPTION();
24287   }
24288
24289 }
24290
24291
24292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
24293   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
24294   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
24295
24296   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
24297   arg2 = (void (*)(Dali::BaseHandle))jarg2;
24298   {
24299     try {
24300       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
24301     } CALL_CATCH_EXCEPTION();
24302   }
24303
24304 }
24305
24306
24307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
24308   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
24309   Dali::BaseHandle arg2 ;
24310   Dali::BaseHandle *argp2 ;
24311
24312   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
24313   argp2 = (Dali::BaseHandle *)jarg2;
24314   if (!argp2) {
24315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24316     return ;
24317   }
24318   arg2 = *argp2;
24319   {
24320     try {
24321       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
24322     } CALL_CATCH_EXCEPTION();
24323   }
24324
24325 }
24326
24327
24328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
24329   void * jresult ;
24330   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
24331
24332   {
24333     try {
24334       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
24335     } CALL_CATCH_EXCEPTION(0);
24336   }
24337
24338   jresult = (void *)result;
24339   return jresult;
24340 }
24341
24342
24343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
24344   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
24345
24346   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
24347   {
24348     try {
24349       delete arg1;
24350     } CALL_CATCH_EXCEPTION();
24351   }
24352
24353 }
24354
24355
24356 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
24357   bool jresult ;
24358   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
24359   bool result;
24360
24361   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
24362   {
24363     try {
24364       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
24365     } CALL_CATCH_EXCEPTION(0);
24366   }
24367
24368   jresult = result;
24369   return jresult;
24370 }
24371
24372
24373 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
24374   unsigned long jresult ;
24375   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
24376   std::size_t result;
24377
24378   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
24379   {
24380     try {
24381       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
24382     } CALL_CATCH_EXCEPTION(0);
24383   }
24384
24385   jresult = (unsigned long)result;
24386   return jresult;
24387 }
24388
24389
24390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
24391   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
24392   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
24393
24394   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
24395   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
24396   {
24397     try {
24398       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
24399     } CALL_CATCH_EXCEPTION();
24400   }
24401
24402 }
24403
24404
24405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
24406   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
24407   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
24408
24409   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
24410   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
24411   {
24412     try {
24413       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
24414     } CALL_CATCH_EXCEPTION();
24415   }
24416
24417 }
24418
24419
24420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
24421   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
24422   Dali::PropertyNotification *arg2 = 0 ;
24423
24424   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
24425   arg2 = (Dali::PropertyNotification *)jarg2;
24426   if (!arg2) {
24427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
24428     return ;
24429   }
24430   {
24431     try {
24432       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
24433     } CALL_CATCH_EXCEPTION();
24434   }
24435
24436 }
24437
24438
24439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
24440   void * jresult ;
24441   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
24442
24443   {
24444     try {
24445       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
24446     } CALL_CATCH_EXCEPTION(0);
24447   }
24448
24449   jresult = (void *)result;
24450   return jresult;
24451 }
24452
24453
24454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
24455   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
24456
24457   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
24458   {
24459     try {
24460       delete arg1;
24461     } CALL_CATCH_EXCEPTION();
24462   }
24463
24464 }
24465
24466
24467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
24468   void * jresult ;
24469   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
24470
24471   {
24472     try {
24473       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
24474     } CALL_CATCH_EXCEPTION(0);
24475   }
24476
24477   jresult = (void *)result;
24478   return jresult;
24479 }
24480
24481
24482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
24483   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
24484
24485   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
24486   {
24487     try {
24488       delete arg1;
24489     } CALL_CATCH_EXCEPTION();
24490   }
24491
24492 }
24493
24494
24495 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
24496   bool jresult ;
24497   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
24498   bool result;
24499
24500   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
24501   {
24502     try {
24503       result = (bool)Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *)arg1);
24504     } CALL_CATCH_EXCEPTION(0);
24505   }
24506
24507   jresult = result;
24508   return jresult;
24509 }
24510
24511
24512 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
24513   unsigned long jresult ;
24514   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
24515   std::size_t result;
24516
24517   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
24518   {
24519     try {
24520       result = Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *)arg1);
24521     } CALL_CATCH_EXCEPTION(0);
24522   }
24523
24524   jresult = (unsigned long)result;
24525   return jresult;
24526 }
24527
24528
24529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
24530   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
24531   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
24532
24533   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
24534   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
24535   {
24536     try {
24537       Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
24538     } CALL_CATCH_EXCEPTION();
24539   }
24540
24541 }
24542
24543
24544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
24545   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
24546   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
24547
24548   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
24549   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
24550   {
24551     try {
24552       Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
24553     } CALL_CATCH_EXCEPTION();
24554   }
24555
24556 }
24557
24558
24559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
24560   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
24561   Dali::Actor arg2 ;
24562   Dali::LongPressGesture *arg3 = 0 ;
24563   Dali::Actor *argp2 ;
24564
24565   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
24566   argp2 = (Dali::Actor *)jarg2;
24567   if (!argp2) {
24568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24569     return ;
24570   }
24571   arg2 = *argp2;
24572   arg3 = (Dali::LongPressGesture *)jarg3;
24573   if (!arg3) {
24574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
24575     return ;
24576   }
24577   {
24578     try {
24579       Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
24580     } CALL_CATCH_EXCEPTION();
24581   }
24582
24583 }
24584
24585
24586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
24587   void * jresult ;
24588   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
24589
24590   {
24591     try {
24592       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
24593     } CALL_CATCH_EXCEPTION(0);
24594   }
24595
24596   jresult = (void *)result;
24597   return jresult;
24598 }
24599
24600
24601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
24602   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
24603
24604   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
24605   {
24606     try {
24607       delete arg1;
24608     } CALL_CATCH_EXCEPTION();
24609   }
24610
24611 }
24612
24613
24614 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
24615   bool jresult ;
24616   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
24617   bool result;
24618
24619   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
24620   {
24621     try {
24622       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
24623     } CALL_CATCH_EXCEPTION(0);
24624   }
24625
24626   jresult = result;
24627   return jresult;
24628 }
24629
24630
24631 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
24632   unsigned long jresult ;
24633   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
24634   std::size_t result;
24635
24636   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
24637   {
24638     try {
24639       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
24640     } CALL_CATCH_EXCEPTION(0);
24641   }
24642
24643   jresult = (unsigned long)result;
24644   return jresult;
24645 }
24646
24647
24648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
24649   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
24650   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
24651
24652   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
24653   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
24654   {
24655     try {
24656       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
24657     } CALL_CATCH_EXCEPTION();
24658   }
24659
24660 }
24661
24662
24663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
24664   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
24665   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
24666
24667   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
24668   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
24669   {
24670     try {
24671       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
24672     } CALL_CATCH_EXCEPTION();
24673   }
24674
24675 }
24676
24677
24678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
24679   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
24680   Dali::KeyEvent *arg2 = 0 ;
24681
24682   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
24683   arg2 = (Dali::KeyEvent *)jarg2;
24684   if (!arg2) {
24685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
24686     return ;
24687   }
24688   {
24689     try {
24690       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
24691     } CALL_CATCH_EXCEPTION();
24692   }
24693
24694 }
24695
24696
24697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
24698   void * jresult ;
24699   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
24700
24701   {
24702     try {
24703       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
24704     } CALL_CATCH_EXCEPTION(0);
24705   }
24706
24707   jresult = (void *)result;
24708   return jresult;
24709 }
24710
24711
24712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
24713   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
24714
24715   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
24716   {
24717     try {
24718       delete arg1;
24719     } CALL_CATCH_EXCEPTION();
24720   }
24721
24722 }
24723
24724 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
24725   bool jresult ;
24726   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
24727   bool result;
24728
24729   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
24730   {
24731     try {
24732       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
24733     } CALL_CATCH_EXCEPTION(0);
24734   }
24735
24736   jresult = result;
24737   return jresult;
24738 }
24739
24740
24741 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
24742   unsigned long jresult ;
24743   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
24744   std::size_t result;
24745
24746   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
24747   {
24748     try {
24749       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
24750     } CALL_CATCH_EXCEPTION(0);
24751   }
24752
24753   jresult = (unsigned long)result;
24754   return jresult;
24755 }
24756
24757
24758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
24759   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
24760   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
24761
24762   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
24763   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
24764   {
24765     try {
24766       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
24767     } CALL_CATCH_EXCEPTION();
24768   }
24769
24770 }
24771
24772
24773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
24774   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
24775   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
24776
24777   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
24778   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
24779   {
24780     try {
24781       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
24782     } CALL_CATCH_EXCEPTION();
24783   }
24784
24785 }
24786
24787
24788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
24789   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
24790   Dali::WheelEvent *arg2 = 0 ;
24791
24792   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
24793   arg2 = (Dali::WheelEvent *)jarg2;
24794   if (!arg2) {
24795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
24796     return ;
24797   }
24798   {
24799     try {
24800       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
24801     } CALL_CATCH_EXCEPTION();
24802   }
24803
24804 }
24805
24806
24807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
24808   void * jresult ;
24809   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
24810
24811   {
24812     try {
24813       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
24814     } CALL_CATCH_EXCEPTION(0);
24815   }
24816
24817   jresult = (void *)result;
24818   return jresult;
24819 }
24820
24821
24822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
24823   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
24824
24825   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
24826   {
24827     try {
24828       delete arg1;
24829     } CALL_CATCH_EXCEPTION();
24830   }
24831
24832 }
24833
24834
24835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
24836   void * jresult ;
24837   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
24838
24839   {
24840     try {
24841       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
24842     } CALL_CATCH_EXCEPTION(0);
24843   }
24844
24845   jresult = (void *)result;
24846   return jresult;
24847 }
24848
24849
24850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
24851   void * jresult ;
24852   Dali::Radian arg1 ;
24853   Dali::Radian arg2 ;
24854   Dali::Radian *argp1 ;
24855   Dali::Radian *argp2 ;
24856   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
24857
24858   argp1 = (Dali::Radian *)jarg1;
24859   if (!argp1) {
24860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
24861     return 0;
24862   }
24863   arg1 = *argp1;
24864   argp2 = (Dali::Radian *)jarg2;
24865   if (!argp2) {
24866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
24867     return 0;
24868   }
24869   arg2 = *argp2;
24870   {
24871     try {
24872       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
24873     } CALL_CATCH_EXCEPTION(0);
24874   }
24875
24876   jresult = (void *)result;
24877   return jresult;
24878 }
24879
24880
24881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
24882   void * jresult ;
24883   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
24884   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
24885
24886   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
24887   if (!arg1) {
24888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
24889     return 0;
24890   }
24891   {
24892     try {
24893       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
24894     } CALL_CATCH_EXCEPTION(0);
24895   }
24896
24897   jresult = (void *)result;
24898   return jresult;
24899 }
24900
24901
24902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
24903   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
24904   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
24905
24906   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
24907   arg2 = (Dali::Radian *)jarg2;
24908   if (arg1) (arg1)->first = *arg2;
24909 }
24910
24911
24912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
24913   void * jresult ;
24914   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
24915   Dali::Radian *result = 0 ;
24916
24917   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
24918   result = (Dali::Radian *)& ((arg1)->first);
24919   jresult = (void *)result;
24920   return jresult;
24921 }
24922
24923
24924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
24925   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
24926   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
24927
24928   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
24929   arg2 = (Dali::Radian *)jarg2;
24930   if (arg1) (arg1)->second = *arg2;
24931 }
24932
24933
24934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
24935   void * jresult ;
24936   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
24937   Dali::Radian *result = 0 ;
24938
24939   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
24940   result = (Dali::Radian *)& ((arg1)->second);
24941   jresult = (void *)result;
24942   return jresult;
24943 }
24944
24945
24946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
24947   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
24948
24949   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
24950   {
24951     try {
24952       delete arg1;
24953     } CALL_CATCH_EXCEPTION();
24954   }
24955
24956 }
24957
24958
24959 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
24960   bool jresult ;
24961   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
24962   bool result;
24963
24964   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
24965   {
24966     try {
24967       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);
24968     } CALL_CATCH_EXCEPTION(0);
24969   }
24970
24971   jresult = result;
24972   return jresult;
24973 }
24974
24975
24976 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
24977   unsigned long jresult ;
24978   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
24979   std::size_t result;
24980
24981   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
24982   {
24983     try {
24984       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);
24985     } CALL_CATCH_EXCEPTION(0);
24986   }
24987
24988   jresult = (unsigned long)result;
24989   return jresult;
24990 }
24991
24992
24993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
24994   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
24995   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
24996
24997   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
24998   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
24999   {
25000     try {
25001       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
25002     } CALL_CATCH_EXCEPTION();
25003   }
25004
25005 }
25006
25007
25008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
25009   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
25010   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
25011
25012   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
25013   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
25014   {
25015     try {
25016       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
25017     } CALL_CATCH_EXCEPTION();
25018   }
25019
25020 }
25021
25022
25023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
25024   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
25025   Dali::Actor arg2 ;
25026   Dali::PanGesture *arg3 = 0 ;
25027   Dali::Actor *argp2 ;
25028
25029   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
25030   argp2 = (Dali::Actor *)jarg2;
25031   if (!argp2) {
25032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25033     return ;
25034   }
25035   arg2 = *argp2;
25036   arg3 = (Dali::PanGesture *)jarg3;
25037   if (!arg3) {
25038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
25039     return ;
25040   }
25041   {
25042     try {
25043       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
25044     } CALL_CATCH_EXCEPTION();
25045   }
25046
25047 }
25048
25049
25050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
25051   void * jresult ;
25052   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
25053
25054   {
25055     try {
25056       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
25057     } CALL_CATCH_EXCEPTION(0);
25058   }
25059
25060   jresult = (void *)result;
25061   return jresult;
25062 }
25063
25064
25065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
25066   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
25067
25068   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
25069   {
25070     try {
25071       delete arg1;
25072     } CALL_CATCH_EXCEPTION();
25073   }
25074
25075 }
25076
25077
25078 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
25079   bool jresult ;
25080   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
25081   bool result;
25082
25083   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
25084   {
25085     try {
25086       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);
25087     } CALL_CATCH_EXCEPTION(0);
25088   }
25089
25090   jresult = result;
25091   return jresult;
25092 }
25093
25094
25095 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
25096   unsigned long jresult ;
25097   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
25098   std::size_t result;
25099
25100   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
25101   {
25102     try {
25103       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);
25104     } CALL_CATCH_EXCEPTION(0);
25105   }
25106
25107   jresult = (unsigned long)result;
25108   return jresult;
25109 }
25110
25111
25112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
25113   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
25114   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
25115
25116   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
25117   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
25118   {
25119     try {
25120       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
25121     } CALL_CATCH_EXCEPTION();
25122   }
25123
25124 }
25125
25126
25127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
25128   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
25129   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
25130
25131   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
25132   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
25133   {
25134     try {
25135       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
25136     } CALL_CATCH_EXCEPTION();
25137   }
25138
25139 }
25140
25141
25142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
25143   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
25144   Dali::Actor arg2 ;
25145   Dali::PinchGesture *arg3 = 0 ;
25146   Dali::Actor *argp2 ;
25147
25148   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
25149   argp2 = (Dali::Actor *)jarg2;
25150   if (!argp2) {
25151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25152     return ;
25153   }
25154   arg2 = *argp2;
25155   arg3 = (Dali::PinchGesture *)jarg3;
25156   if (!arg3) {
25157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
25158     return ;
25159   }
25160   {
25161     try {
25162       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
25163     } CALL_CATCH_EXCEPTION();
25164   }
25165
25166 }
25167
25168
25169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
25170   void * jresult ;
25171   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
25172
25173   {
25174     try {
25175       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
25176     } CALL_CATCH_EXCEPTION(0);
25177   }
25178
25179   jresult = (void *)result;
25180   return jresult;
25181 }
25182
25183
25184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
25185   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
25186
25187   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
25188   {
25189     try {
25190       delete arg1;
25191     } CALL_CATCH_EXCEPTION();
25192   }
25193
25194 }
25195
25196
25197 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
25198   bool jresult ;
25199   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
25200   bool result;
25201
25202   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
25203   {
25204     try {
25205       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);
25206     } CALL_CATCH_EXCEPTION(0);
25207   }
25208
25209   jresult = result;
25210   return jresult;
25211 }
25212
25213
25214 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
25215   unsigned long jresult ;
25216   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
25217   std::size_t result;
25218
25219   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
25220   {
25221     try {
25222       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);
25223     } CALL_CATCH_EXCEPTION(0);
25224   }
25225
25226   jresult = (unsigned long)result;
25227   return jresult;
25228 }
25229
25230
25231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
25232   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
25233   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
25234
25235   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
25236   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
25237   {
25238     try {
25239       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
25240     } CALL_CATCH_EXCEPTION();
25241   }
25242
25243 }
25244
25245
25246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
25247   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
25248   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
25249
25250   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
25251   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
25252   {
25253     try {
25254       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
25255     } CALL_CATCH_EXCEPTION();
25256   }
25257
25258 }
25259
25260
25261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
25262   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
25263   Dali::Actor arg2 ;
25264   Dali::TapGesture *arg3 = 0 ;
25265   Dali::Actor *argp2 ;
25266
25267   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
25268   argp2 = (Dali::Actor *)jarg2;
25269   if (!argp2) {
25270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25271     return ;
25272   }
25273   arg2 = *argp2;
25274   arg3 = (Dali::TapGesture *)jarg3;
25275   if (!arg3) {
25276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
25277     return ;
25278   }
25279   {
25280     try {
25281       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
25282     } CALL_CATCH_EXCEPTION();
25283   }
25284
25285 }
25286
25287
25288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
25289   void * jresult ;
25290   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
25291
25292   {
25293     try {
25294       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
25295     } CALL_CATCH_EXCEPTION(0);
25296   }
25297
25298   jresult = (void *)result;
25299   return jresult;
25300 }
25301
25302
25303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
25304   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
25305
25306   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
25307   {
25308     try {
25309       delete arg1;
25310     } CALL_CATCH_EXCEPTION();
25311   }
25312
25313 }
25314
25315 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
25316   unsigned long jresult ;
25317   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
25318   std::size_t result = 0;
25319
25320   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
25321   {
25322     try {
25323       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);
25324     }CALL_CATCH_EXCEPTION(0);
25325   }
25326   jresult = (unsigned long)result;
25327   return jresult;
25328 }
25329
25330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
25331   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
25332   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
25333
25334   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
25335   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
25336   {
25337     try {
25338       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
25339     } CALL_CATCH_EXCEPTION();
25340   }
25341 }
25342
25343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
25344   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
25345   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
25346
25347   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
25348   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
25349   {
25350     try {
25351       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
25352     } CALL_CATCH_EXCEPTION();
25353   }
25354 }
25355
25356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
25357   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
25358   Dali::Actor arg2 ;
25359   //bool arg3 ;
25360   Dali::LayoutDirection::Type arg4 ;
25361   Dali::Actor *argp2 ;
25362
25363   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
25364   argp2 = (Dali::Actor *)jarg2;
25365   if (!argp2) {
25366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25367     return ;
25368   }
25369   arg2 = *argp2;
25370   //arg3 = jarg3 ? true : false;
25371   arg4 = (Dali::LayoutDirection::Type)jarg4;
25372   {
25373     try {
25374       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
25375     } CALL_CATCH_EXCEPTION();
25376   }
25377 }
25378
25379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
25380   void * jresult ;
25381   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
25382
25383   {
25384     try {
25385       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
25386     } CALL_CATCH_EXCEPTION(0);
25387   }
25388   jresult = (void *)result;
25389   return jresult;
25390 }
25391
25392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
25393   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
25394
25395   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
25396   {
25397     try {
25398       delete arg1;
25399     } CALL_CATCH_EXCEPTION();
25400   }
25401 }
25402
25403
25404 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) {
25405   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
25406   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
25407   if (director) {
25408     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);
25409   }
25410 }
25411
25412
25413 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) {
25414   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
25415   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
25416   if (director) {
25417     director->swig_connect_director(callback0, callback1, callback2);
25418   }
25419 }
25420
25421
25422 //// ========================= end of part 3 =============================
25423
25424 //// ========================== start part 4 =============================
25425
25426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback0_t callback0) {
25427   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg;
25428   SwigDirector_FrameCallbackInterface *director = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
25429   if (director) {
25430     director->swig_connect_director(callback0);
25431   }
25432 }
25433
25434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect_with_return(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback1_t callback1) {
25435   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg;
25436   SwigDirector_FrameCallbackInterface *director = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
25437   if (director) {
25438     director->swig_connect_director_with_return(callback1);
25439   }
25440 }
25441
25442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameCallbackInterface() {
25443   void * jresult ;
25444   Dali::FrameCallbackInterface *result = 0 ;
25445
25446   {
25447     try {
25448       result =(Dali::FrameCallbackInterface *) new SwigDirector_FrameCallbackInterface();
25449     } CALL_CATCH_EXCEPTION(0);
25450   }
25451
25452   jresult = (void *)result;
25453   return jresult;
25454 }
25455
25456
25457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_AddFrameCallback(void * jarg1, void* jarg2, void* jarg3) {
25458   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
25459   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
25460
25461   Dali::Stage *arg1 = (Dali::Stage *) 0;
25462   Dali::Actor *arg3 = 0;
25463
25464   arg1 = (Dali::Stage *)jarg1;
25465   arg3 = (Dali::Actor *)jarg3;
25466
25467   DevelStage::AddFrameCallback( *arg1, *arg2, *arg3 );
25468   return;
25469 }
25470
25471
25472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_RemoveFrameCallback(void * jarg1, void* jarg2) {
25473
25474   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
25475   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
25476
25477   Dali::Stage *arg1 = (Dali::Stage *) 0;
25478
25479   arg1 = (Dali::Stage *)jarg1;
25480
25481   DevelStage::RemoveFrameCallback( *arg1, *arg2 );
25482   return;
25483 }
25484
25485
25486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
25487   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
25488   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
25489   if (director) {
25490     director->swig_connect_director(callback0);
25491   }
25492 }
25493
25494
25495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
25496   void * jresult ;
25497   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
25498
25499   {
25500     try {
25501       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
25502     } CALL_CATCH_EXCEPTION(0);
25503   }
25504
25505   jresult = (void *)result;
25506   return jresult;
25507 }
25508
25509
25510 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) {
25511   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
25512   if (director) {
25513     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
25514   }
25515 }
25516
25517
25518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
25519   void * jresult ;
25520   SwigDirector_WidgetImpl* result;
25521   {
25522     try {
25523       result = new SwigDirector_WidgetImpl();
25524     } CALL_CATCH_EXCEPTION(0);
25525   }
25526   jresult = result;
25527   return jresult;
25528 }
25529
25530
25531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
25532   void * jresult ;
25533   Dali::Widget *arg1 = 0 ;
25534   SwigDirector_WidgetImpl *result = 0 ;
25535
25536   arg1 = (Dali::Widget *)jarg1;
25537   if (!arg1) {
25538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
25539     return 0;
25540   }
25541   {
25542     try {
25543       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
25544     } CALL_CATCH_EXCEPTION(0);
25545   }
25546   jresult = (void*) result;
25547   return jresult;
25548 }
25549
25550
25551
25552 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
25553     return (Dali::SignalObserver *)jarg1;
25554 }
25555
25556 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
25557     return (Dali::ConnectionTrackerInterface *)jarg1;
25558 }
25559
25560 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
25561     return (Dali::BaseHandle *)jarg1;
25562 }
25563
25564 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
25565     return (Dali::BaseHandle *)jarg1;
25566 }
25567
25568 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
25569     return (Dali::BaseHandle *)jarg1;
25570 }
25571
25572 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
25573     return (Dali::BaseHandle *)jarg1;
25574 }
25575
25576 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
25577     return (Dali::BaseHandle *)jarg1;
25578 }
25579
25580 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
25581     return (Dali::BaseHandle *)jarg1;
25582 }
25583
25584 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
25585     return (Dali::BaseHandle *)jarg1;
25586 }
25587
25588 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
25589     return (Dali::BaseHandle *)jarg1;
25590 }
25591
25592 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
25593     return (Dali::BaseHandle *)jarg1;
25594 }
25595
25596 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
25597     return (Dali::BaseHandle *)jarg1;
25598 }
25599
25600 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VertexBuffer_SWIGUpcast(Dali::VertexBuffer *jarg1) {
25601     return (Dali::BaseHandle *)jarg1;
25602 }
25603
25604 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
25605     return (Dali::BaseHandle *)jarg1;
25606 }
25607
25608 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
25609     return (Dali::Handle *)jarg1;
25610 }
25611
25612 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
25613     return (Dali::Handle *)jarg1;
25614 }
25615
25616 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
25617     return (Dali::BaseHandle *)jarg1;
25618 }
25619
25620 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
25621     return (Dali::BaseHandle *)jarg1;
25622 }
25623
25624 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
25625     return (Dali::Handle *)jarg1;
25626 }
25627
25628 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchEvent *jarg1) {
25629     return (Dali::BaseHandle *)jarg1;
25630 }
25631
25632 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Hover_SWIGUpcast(Dali::HoverEvent *jarg1) {
25633     return (Dali::BaseHandle *)jarg1;
25634 }
25635
25636 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Wheel_SWIGUpcast(Dali::WheelEvent *jarg1) {
25637     return (Dali::BaseHandle *)jarg1;
25638 }
25639
25640 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Key_SWIGUpcast(Dali::KeyEvent *jarg1) {
25641     return (Dali::BaseHandle *)jarg1;
25642 }
25643
25644 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Gesture_SWIGUpcast(Dali::Gesture *jarg1) {
25645     return (Dali::BaseHandle *)jarg1;
25646 }
25647
25648 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
25649     return (Dali::Handle *)jarg1;
25650 }
25651
25652 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
25653     return (Dali::GestureDetector *)jarg1;
25654 }
25655
25656 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
25657     return (Dali::Gesture *)jarg1;
25658 }
25659
25660
25661 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
25662     return (Dali::RefObject *)jarg1;
25663 }
25664
25665 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
25666     return (Dali::Actor *)jarg1;
25667 }
25668
25669 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
25670     return (Dali::GestureDetector *)jarg1;
25671 }
25672
25673 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
25674     return (Dali::Gesture *)jarg1;
25675 }
25676
25677 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
25678     return (Dali::GestureDetector *)jarg1;
25679 }
25680
25681 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
25682     return (Dali::Gesture *)jarg1;
25683 }
25684
25685 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
25686     return (Dali::GestureDetector *)jarg1;
25687 }
25688
25689 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
25690     return (Dali::Gesture *)jarg1;
25691 }
25692
25693 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
25694     return (Dali::BaseHandle *)jarg1;
25695 }
25696
25697 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
25698     return (Dali::Handle *)jarg1;
25699 }
25700
25701 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
25702     return (Dali::Handle *)jarg1;
25703 }
25704
25705 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
25706     return (Dali::Handle *)jarg1;
25707 }
25708
25709 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
25710     return (Dali::RefObject *)jarg1;
25711 }
25712
25713 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
25714     return (Dali::Actor *)jarg1;
25715 }
25716
25717 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
25718     return (Dali::BaseHandle *)jarg1;
25719 }
25720
25721
25722 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
25723   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
25724   char * jresult = SWIG_csharp_string_callback((const char *)result);
25725   return jresult;
25726 }
25727
25728 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
25729   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
25730   return result;
25731 }
25732
25733
25734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
25735   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25736
25737   arg1 = (std::vector< unsigned int > *)jarg1;
25738   {
25739     try {
25740       (arg1)->clear();
25741     } CALL_CATCH_EXCEPTION();
25742   }
25743
25744 }
25745
25746
25747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
25748   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25749   unsigned int *arg2 = 0 ;
25750   unsigned int temp2 ;
25751
25752   arg1 = (std::vector< unsigned int > *)jarg1;
25753   temp2 = (unsigned int)jarg2;
25754   arg2 = &temp2;
25755   {
25756     try {
25757       (arg1)->push_back((unsigned int const &)*arg2);
25758     } CALL_CATCH_EXCEPTION();
25759   }
25760
25761 }
25762
25763
25764 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
25765   unsigned long jresult ;
25766   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25767   std::vector< unsigned int >::size_type result;
25768
25769   arg1 = (std::vector< unsigned int > *)jarg1;
25770   {
25771     try {
25772       result = ((std::vector< unsigned int > const *)arg1)->size();
25773     } CALL_CATCH_EXCEPTION(0);
25774   }
25775
25776   jresult = (unsigned long)result;
25777   return jresult;
25778 }
25779
25780
25781 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
25782   unsigned long jresult ;
25783   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25784   std::vector< unsigned int >::size_type result;
25785
25786   arg1 = (std::vector< unsigned int > *)jarg1;
25787   {
25788     try {
25789       result = ((std::vector< unsigned int > const *)arg1)->capacity();
25790     } CALL_CATCH_EXCEPTION(0);
25791   }
25792
25793   jresult = (unsigned long)result;
25794   return jresult;
25795 }
25796
25797
25798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
25799   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25800   std::vector< unsigned int >::size_type arg2 ;
25801
25802   arg1 = (std::vector< unsigned int > *)jarg1;
25803   arg2 = (std::vector< unsigned int >::size_type)jarg2;
25804   {
25805     try {
25806       (arg1)->reserve(arg2);
25807     } CALL_CATCH_EXCEPTION();
25808   }
25809
25810 }
25811
25812
25813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
25814   void * jresult ;
25815   std::vector< unsigned int > *result = 0 ;
25816
25817   {
25818     try {
25819       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
25820     } CALL_CATCH_EXCEPTION(0);
25821   }
25822
25823   jresult = (void *)result;
25824   return jresult;
25825 }
25826
25827
25828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
25829   void * jresult ;
25830   std::vector< unsigned int > *arg1 = 0 ;
25831   std::vector< unsigned int > *result = 0 ;
25832
25833   arg1 = (std::vector< unsigned int > *)jarg1;
25834   if (!arg1) {
25835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
25836     return 0;
25837   }
25838   {
25839     try {
25840       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
25841     } CALL_CATCH_EXCEPTION(0);
25842   }
25843
25844   jresult = (void *)result;
25845   return jresult;
25846 }
25847
25848
25849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
25850   void * jresult ;
25851   int arg1 ;
25852   std::vector< unsigned int > *result = 0 ;
25853
25854   arg1 = (int)jarg1;
25855   {
25856     try {
25857       try {
25858         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
25859       }
25860       catch(std::out_of_range &_e) {
25861         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
25862         return 0;
25863       }
25864
25865     } CALL_CATCH_EXCEPTION(0);
25866   }
25867
25868   jresult = (void *)result;
25869   return jresult;
25870 }
25871
25872
25873 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
25874   unsigned int jresult ;
25875   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25876   int arg2 ;
25877   unsigned int result;
25878
25879   arg1 = (std::vector< unsigned int > *)jarg1;
25880   arg2 = (int)jarg2;
25881   {
25882     try {
25883       try {
25884         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
25885       }
25886       catch(std::out_of_range &_e) {
25887         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
25888         return 0;
25889       }
25890
25891     } CALL_CATCH_EXCEPTION(0);
25892   }
25893
25894   jresult = result;
25895   return jresult;
25896 }
25897
25898
25899 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
25900   unsigned int jresult ;
25901   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25902   int arg2 ;
25903   unsigned int *result = 0 ;
25904
25905   arg1 = (std::vector< unsigned int > *)jarg1;
25906   arg2 = (int)jarg2;
25907   {
25908     try {
25909       try {
25910         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
25911       }
25912       catch(std::out_of_range &_e) {
25913         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
25914         return 0;
25915       }
25916
25917     } CALL_CATCH_EXCEPTION(0);
25918   }
25919
25920   jresult = *result;
25921   return jresult;
25922 }
25923
25924
25925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
25926   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25927   int arg2 ;
25928   unsigned int *arg3 = 0 ;
25929   unsigned int temp3 ;
25930
25931   arg1 = (std::vector< unsigned int > *)jarg1;
25932   arg2 = (int)jarg2;
25933   temp3 = (unsigned int)jarg3;
25934   arg3 = &temp3;
25935   {
25936     try {
25937       try {
25938         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
25939       }
25940       catch(std::out_of_range &_e) {
25941         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
25942         return ;
25943       }
25944
25945     } CALL_CATCH_EXCEPTION();
25946   }
25947
25948 }
25949
25950
25951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
25952   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25953   std::vector< unsigned int > *arg2 = 0 ;
25954
25955   arg1 = (std::vector< unsigned int > *)jarg1;
25956   arg2 = (std::vector< unsigned int > *)jarg2;
25957   if (!arg2) {
25958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
25959     return ;
25960   }
25961   {
25962     try {
25963       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
25964     } CALL_CATCH_EXCEPTION();
25965   }
25966
25967 }
25968
25969
25970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
25971   void * jresult ;
25972   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25973   int arg2 ;
25974   int arg3 ;
25975   std::vector< unsigned int > *result = 0 ;
25976
25977   arg1 = (std::vector< unsigned int > *)jarg1;
25978   arg2 = (int)jarg2;
25979   arg3 = (int)jarg3;
25980   {
25981     try {
25982       try {
25983         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
25984       }
25985       catch(std::out_of_range &_e) {
25986         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
25987         return 0;
25988       }
25989       catch(std::invalid_argument &_e) {
25990         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
25991         return 0;
25992       }
25993
25994     } CALL_CATCH_EXCEPTION(0);
25995   }
25996
25997   jresult = (void *)result;
25998   return jresult;
25999 }
26000
26001
26002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
26003   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
26004   int arg2 ;
26005   unsigned int *arg3 = 0 ;
26006   unsigned int temp3 ;
26007
26008   arg1 = (std::vector< unsigned int > *)jarg1;
26009   arg2 = (int)jarg2;
26010   temp3 = (unsigned int)jarg3;
26011   arg3 = &temp3;
26012   {
26013     try {
26014       try {
26015         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
26016       }
26017       catch(std::out_of_range &_e) {
26018         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26019         return ;
26020       }
26021
26022     } CALL_CATCH_EXCEPTION();
26023   }
26024
26025 }
26026
26027
26028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
26029   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
26030   int arg2 ;
26031   std::vector< unsigned int > *arg3 = 0 ;
26032
26033   arg1 = (std::vector< unsigned int > *)jarg1;
26034   arg2 = (int)jarg2;
26035   arg3 = (std::vector< unsigned int > *)jarg3;
26036   if (!arg3) {
26037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
26038     return ;
26039   }
26040   {
26041     try {
26042       try {
26043         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
26044       }
26045       catch(std::out_of_range &_e) {
26046         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26047         return ;
26048       }
26049
26050     } CALL_CATCH_EXCEPTION();
26051   }
26052
26053 }
26054
26055
26056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
26057   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
26058   int arg2 ;
26059
26060   arg1 = (std::vector< unsigned int > *)jarg1;
26061   arg2 = (int)jarg2;
26062   {
26063     try {
26064       try {
26065         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
26066       }
26067       catch(std::out_of_range &_e) {
26068         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26069         return ;
26070       }
26071
26072     } CALL_CATCH_EXCEPTION();
26073   }
26074
26075 }
26076
26077
26078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
26079   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
26080   int arg2 ;
26081   int arg3 ;
26082
26083   arg1 = (std::vector< unsigned int > *)jarg1;
26084   arg2 = (int)jarg2;
26085   arg3 = (int)jarg3;
26086   {
26087     try {
26088       try {
26089         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
26090       }
26091       catch(std::out_of_range &_e) {
26092         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26093         return ;
26094       }
26095       catch(std::invalid_argument &_e) {
26096         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
26097         return ;
26098       }
26099
26100     } CALL_CATCH_EXCEPTION();
26101   }
26102
26103 }
26104
26105
26106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
26107   void * jresult ;
26108   unsigned int *arg1 = 0 ;
26109   int arg2 ;
26110   unsigned int temp1 ;
26111   std::vector< unsigned int > *result = 0 ;
26112
26113   temp1 = (unsigned int)jarg1;
26114   arg1 = &temp1;
26115   arg2 = (int)jarg2;
26116   {
26117     try {
26118       try {
26119         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
26120       }
26121       catch(std::out_of_range &_e) {
26122         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26123         return 0;
26124       }
26125
26126     } CALL_CATCH_EXCEPTION(0);
26127   }
26128
26129   jresult = (void *)result;
26130   return jresult;
26131 }
26132
26133
26134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
26135   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
26136
26137   arg1 = (std::vector< unsigned int > *)jarg1;
26138   {
26139     try {
26140       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
26141     } CALL_CATCH_EXCEPTION();
26142   }
26143
26144 }
26145
26146
26147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
26148   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
26149   int arg2 ;
26150   int arg3 ;
26151
26152   arg1 = (std::vector< unsigned int > *)jarg1;
26153   arg2 = (int)jarg2;
26154   arg3 = (int)jarg3;
26155   {
26156     try {
26157       try {
26158         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
26159       }
26160       catch(std::out_of_range &_e) {
26161         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26162         return ;
26163       }
26164       catch(std::invalid_argument &_e) {
26165         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
26166         return ;
26167       }
26168
26169     } CALL_CATCH_EXCEPTION();
26170   }
26171
26172 }
26173
26174
26175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
26176   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
26177   int arg2 ;
26178   std::vector< unsigned int > *arg3 = 0 ;
26179
26180   arg1 = (std::vector< unsigned int > *)jarg1;
26181   arg2 = (int)jarg2;
26182   arg3 = (std::vector< unsigned int > *)jarg3;
26183   if (!arg3) {
26184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
26185     return ;
26186   }
26187   {
26188     try {
26189       try {
26190         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
26191       }
26192       catch(std::out_of_range &_e) {
26193         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26194         return ;
26195       }
26196
26197     } CALL_CATCH_EXCEPTION();
26198   }
26199
26200 }
26201
26202
26203 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
26204   bool jresult ;
26205   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
26206   unsigned int *arg2 = 0 ;
26207   unsigned int temp2 ;
26208   bool result;
26209
26210   arg1 = (std::vector< unsigned int > *)jarg1;
26211   temp2 = (unsigned int)jarg2;
26212   arg2 = &temp2;
26213   {
26214     try {
26215       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
26216     } CALL_CATCH_EXCEPTION(0);
26217   }
26218
26219   jresult = result;
26220   return jresult;
26221 }
26222
26223
26224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
26225   int jresult ;
26226   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
26227   unsigned int *arg2 = 0 ;
26228   unsigned int temp2 ;
26229   int result;
26230
26231   arg1 = (std::vector< unsigned int > *)jarg1;
26232   temp2 = (unsigned int)jarg2;
26233   arg2 = &temp2;
26234   {
26235     try {
26236       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
26237     } CALL_CATCH_EXCEPTION(0);
26238   }
26239
26240   jresult = result;
26241   return jresult;
26242 }
26243
26244
26245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
26246   int jresult ;
26247   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
26248   unsigned int *arg2 = 0 ;
26249   unsigned int temp2 ;
26250   int result;
26251
26252   arg1 = (std::vector< unsigned int > *)jarg1;
26253   temp2 = (unsigned int)jarg2;
26254   arg2 = &temp2;
26255   {
26256     try {
26257       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
26258     } CALL_CATCH_EXCEPTION(0);
26259   }
26260
26261   jresult = result;
26262   return jresult;
26263 }
26264
26265
26266 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
26267   bool jresult ;
26268   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
26269   unsigned int *arg2 = 0 ;
26270   unsigned int temp2 ;
26271   bool result;
26272
26273   arg1 = (std::vector< unsigned int > *)jarg1;
26274   temp2 = (unsigned int)jarg2;
26275   arg2 = &temp2;
26276   {
26277     try {
26278       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
26279     } CALL_CATCH_EXCEPTION(0);
26280   }
26281
26282   jresult = result;
26283   return jresult;
26284 }
26285
26286
26287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
26288   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
26289
26290   arg1 = (std::vector< unsigned int > *)jarg1;
26291   {
26292     try {
26293       delete arg1;
26294     } CALL_CATCH_EXCEPTION();
26295   }
26296
26297 }
26298
26299
26300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
26301   void * jresult ;
26302   std::pair< unsigned int,Dali::Actor > *result = 0 ;
26303
26304   {
26305     try {
26306       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
26307     } CALL_CATCH_EXCEPTION(0);
26308   }
26309
26310   jresult = (void *)result;
26311   return jresult;
26312 }
26313
26314
26315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
26316   void * jresult ;
26317   unsigned int arg1 ;
26318   Dali::Actor arg2 ;
26319   Dali::Actor *argp2 ;
26320   std::pair< unsigned int,Dali::Actor > *result = 0 ;
26321
26322   arg1 = (unsigned int)jarg1;
26323   argp2 = (Dali::Actor *)jarg2;
26324   if (!argp2) {
26325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26326     return 0;
26327   }
26328   arg2 = *argp2;
26329   {
26330     try {
26331       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
26332     } CALL_CATCH_EXCEPTION(0);
26333   }
26334
26335   jresult = (void *)result;
26336   return jresult;
26337 }
26338
26339
26340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
26341   void * jresult ;
26342   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
26343   std::pair< unsigned int,Dali::Actor > *result = 0 ;
26344
26345   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
26346   if (!arg1) {
26347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
26348     return 0;
26349   }
26350   {
26351     try {
26352       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
26353     } CALL_CATCH_EXCEPTION(0);
26354   }
26355
26356   jresult = (void *)result;
26357   return jresult;
26358 }
26359
26360
26361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
26362   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
26363   unsigned int arg2 ;
26364
26365   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
26366   arg2 = (unsigned int)jarg2;
26367   if (arg1) (arg1)->first = arg2;
26368 }
26369
26370
26371 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
26372   unsigned int jresult ;
26373   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
26374   unsigned int result;
26375
26376   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
26377   result = (unsigned int) ((arg1)->first);
26378   jresult = result;
26379   return jresult;
26380 }
26381
26382
26383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
26384   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
26385   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
26386
26387   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
26388   arg2 = (Dali::Actor *)jarg2;
26389   if (arg1) (arg1)->second = *arg2;
26390 }
26391
26392
26393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
26394   void * jresult ;
26395   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
26396   Dali::Actor *result = 0 ;
26397
26398   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
26399   result = (Dali::Actor *)& ((arg1)->second);
26400   jresult = (void *)result;
26401   return jresult;
26402 }
26403
26404
26405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
26406   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
26407
26408   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
26409   {
26410     try {
26411       delete arg1;
26412     } CALL_CATCH_EXCEPTION();
26413   }
26414
26415 }
26416
26417
26418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
26419   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26420
26421   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26422   {
26423     try {
26424       (arg1)->clear();
26425     } CALL_CATCH_EXCEPTION();
26426   }
26427
26428 }
26429
26430
26431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
26432   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26433   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
26434
26435   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26436   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
26437   if (!arg2) {
26438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
26439     return ;
26440   }
26441   {
26442     try {
26443       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
26444     } CALL_CATCH_EXCEPTION();
26445   }
26446
26447 }
26448
26449
26450 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
26451   unsigned long jresult ;
26452   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26453   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
26454
26455   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26456   {
26457     try {
26458       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
26459     } CALL_CATCH_EXCEPTION(0);
26460   }
26461
26462   jresult = (unsigned long)result;
26463   return jresult;
26464 }
26465
26466
26467 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
26468   unsigned long jresult ;
26469   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26470   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
26471
26472   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26473   {
26474     try {
26475       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
26476     } CALL_CATCH_EXCEPTION(0);
26477   }
26478
26479   jresult = (unsigned long)result;
26480   return jresult;
26481 }
26482
26483
26484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
26485   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26486   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
26487
26488   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26489   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
26490   {
26491     try {
26492       (arg1)->reserve(arg2);
26493     } CALL_CATCH_EXCEPTION();
26494   }
26495
26496 }
26497
26498
26499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
26500   void * jresult ;
26501   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
26502
26503   {
26504     try {
26505       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
26506     } CALL_CATCH_EXCEPTION(0);
26507   }
26508
26509   jresult = (void *)result;
26510   return jresult;
26511 }
26512
26513
26514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
26515   void * jresult ;
26516   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
26517   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
26518
26519   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26520   if (!arg1) {
26521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
26522     return 0;
26523   }
26524   {
26525     try {
26526       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);
26527     } CALL_CATCH_EXCEPTION(0);
26528   }
26529
26530   jresult = (void *)result;
26531   return jresult;
26532 }
26533
26534
26535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
26536   void * jresult ;
26537   int arg1 ;
26538   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
26539
26540   arg1 = (int)jarg1;
26541   {
26542     try {
26543       try {
26544         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);
26545       }
26546       catch(std::out_of_range &_e) {
26547         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26548         return 0;
26549       }
26550
26551     } CALL_CATCH_EXCEPTION(0);
26552   }
26553
26554   jresult = (void *)result;
26555   return jresult;
26556 }
26557
26558
26559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
26560   void * jresult ;
26561   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26562   int arg2 ;
26563   std::pair< unsigned int,Dali::Actor > result;
26564
26565   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26566   arg2 = (int)jarg2;
26567   {
26568     try {
26569       try {
26570         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
26571       }
26572       catch(std::out_of_range &_e) {
26573         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26574         return 0;
26575       }
26576
26577     } CALL_CATCH_EXCEPTION(0);
26578   }
26579
26580   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
26581   return jresult;
26582 }
26583
26584
26585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
26586   void * jresult ;
26587   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26588   int arg2 ;
26589   std::pair< unsigned int,Dali::Actor > *result = 0 ;
26590
26591   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26592   arg2 = (int)jarg2;
26593   {
26594     try {
26595       try {
26596         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
26597       }
26598       catch(std::out_of_range &_e) {
26599         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26600         return 0;
26601       }
26602
26603     } CALL_CATCH_EXCEPTION(0);
26604   }
26605
26606   jresult = (void *)result;
26607   return jresult;
26608 }
26609
26610
26611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
26612   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26613   int arg2 ;
26614   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
26615
26616   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26617   arg2 = (int)jarg2;
26618   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
26619   if (!arg3) {
26620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
26621     return ;
26622   }
26623   {
26624     try {
26625       try {
26626         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);
26627       }
26628       catch(std::out_of_range &_e) {
26629         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26630         return ;
26631       }
26632
26633     } CALL_CATCH_EXCEPTION();
26634   }
26635
26636 }
26637
26638
26639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
26640   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26641   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
26642
26643   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26644   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
26645   if (!arg2) {
26646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
26647     return ;
26648   }
26649   {
26650     try {
26651       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);
26652     } CALL_CATCH_EXCEPTION();
26653   }
26654
26655 }
26656
26657
26658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
26659   void * jresult ;
26660   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26661   int arg2 ;
26662   int arg3 ;
26663   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
26664
26665   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26666   arg2 = (int)jarg2;
26667   arg3 = (int)jarg3;
26668   {
26669     try {
26670       try {
26671         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);
26672       }
26673       catch(std::out_of_range &_e) {
26674         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26675         return 0;
26676       }
26677       catch(std::invalid_argument &_e) {
26678         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
26679         return 0;
26680       }
26681
26682     } CALL_CATCH_EXCEPTION(0);
26683   }
26684
26685   jresult = (void *)result;
26686   return jresult;
26687 }
26688
26689
26690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
26691   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26692   int arg2 ;
26693   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
26694
26695   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26696   arg2 = (int)jarg2;
26697   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
26698   if (!arg3) {
26699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
26700     return ;
26701   }
26702   {
26703     try {
26704       try {
26705         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);
26706       }
26707       catch(std::out_of_range &_e) {
26708         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26709         return ;
26710       }
26711
26712     } CALL_CATCH_EXCEPTION();
26713   }
26714
26715 }
26716
26717
26718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
26719   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26720   int arg2 ;
26721   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
26722
26723   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26724   arg2 = (int)jarg2;
26725   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
26726   if (!arg3) {
26727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
26728     return ;
26729   }
26730   {
26731     try {
26732       try {
26733         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);
26734       }
26735       catch(std::out_of_range &_e) {
26736         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26737         return ;
26738       }
26739
26740     } CALL_CATCH_EXCEPTION();
26741   }
26742
26743 }
26744
26745
26746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
26747   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26748   int arg2 ;
26749
26750   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26751   arg2 = (int)jarg2;
26752   {
26753     try {
26754       try {
26755         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
26756       }
26757       catch(std::out_of_range &_e) {
26758         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26759         return ;
26760       }
26761
26762     } CALL_CATCH_EXCEPTION();
26763   }
26764
26765 }
26766
26767
26768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
26769   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26770   int arg2 ;
26771   int arg3 ;
26772
26773   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26774   arg2 = (int)jarg2;
26775   arg3 = (int)jarg3;
26776   {
26777     try {
26778       try {
26779         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
26780       }
26781       catch(std::out_of_range &_e) {
26782         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26783         return ;
26784       }
26785       catch(std::invalid_argument &_e) {
26786         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
26787         return ;
26788       }
26789
26790     } CALL_CATCH_EXCEPTION();
26791   }
26792
26793 }
26794
26795
26796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
26797   void * jresult ;
26798   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
26799   int arg2 ;
26800   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
26801
26802   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
26803   if (!arg1) {
26804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
26805     return 0;
26806   }
26807   arg2 = (int)jarg2;
26808   {
26809     try {
26810       try {
26811         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);
26812       }
26813       catch(std::out_of_range &_e) {
26814         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26815         return 0;
26816       }
26817
26818     } CALL_CATCH_EXCEPTION(0);
26819   }
26820
26821   jresult = (void *)result;
26822   return jresult;
26823 }
26824
26825
26826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
26827   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26828
26829   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26830   {
26831     try {
26832       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
26833     } CALL_CATCH_EXCEPTION();
26834   }
26835
26836 }
26837
26838
26839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
26840   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26841   int arg2 ;
26842   int arg3 ;
26843
26844   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26845   arg2 = (int)jarg2;
26846   arg3 = (int)jarg3;
26847   {
26848     try {
26849       try {
26850         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
26851       }
26852       catch(std::out_of_range &_e) {
26853         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26854         return ;
26855       }
26856       catch(std::invalid_argument &_e) {
26857         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
26858         return ;
26859       }
26860
26861     } CALL_CATCH_EXCEPTION();
26862   }
26863
26864 }
26865
26866
26867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
26868   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26869   int arg2 ;
26870   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
26871
26872   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26873   arg2 = (int)jarg2;
26874   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
26875   if (!arg3) {
26876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
26877     return ;
26878   }
26879   {
26880     try {
26881       try {
26882         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);
26883       }
26884       catch(std::out_of_range &_e) {
26885         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26886         return ;
26887       }
26888
26889     } CALL_CATCH_EXCEPTION();
26890   }
26891
26892 }
26893
26894
26895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
26896   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26897
26898   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26899   {
26900     try {
26901       delete arg1;
26902     } CALL_CATCH_EXCEPTION();
26903   }
26904
26905 }
26906
26907
26908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
26909   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
26910
26911   arg1 = (std::vector< Dali::Actor > *)jarg1;
26912   {
26913     try {
26914       (arg1)->clear();
26915     } CALL_CATCH_EXCEPTION();
26916   }
26917
26918 }
26919
26920
26921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
26922   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
26923   Dali::Actor *arg2 = 0 ;
26924
26925   arg1 = (std::vector< Dali::Actor > *)jarg1;
26926   arg2 = (Dali::Actor *)jarg2;
26927   if (!arg2) {
26928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
26929     return ;
26930   }
26931   {
26932     try {
26933       (arg1)->push_back((Dali::Actor const &)*arg2);
26934     } CALL_CATCH_EXCEPTION();
26935   }
26936
26937 }
26938
26939
26940 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
26941   unsigned long jresult ;
26942   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
26943   std::vector< Dali::Actor >::size_type result;
26944
26945   arg1 = (std::vector< Dali::Actor > *)jarg1;
26946   {
26947     try {
26948       result = ((std::vector< Dali::Actor > const *)arg1)->size();
26949     } CALL_CATCH_EXCEPTION(0);
26950   }
26951
26952   jresult = (unsigned long)result;
26953   return jresult;
26954 }
26955
26956
26957 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
26958   unsigned long jresult ;
26959   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
26960   std::vector< Dali::Actor >::size_type result;
26961
26962   arg1 = (std::vector< Dali::Actor > *)jarg1;
26963   {
26964     try {
26965       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
26966     } CALL_CATCH_EXCEPTION(0);
26967   }
26968
26969   jresult = (unsigned long)result;
26970   return jresult;
26971 }
26972
26973
26974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
26975   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
26976   std::vector< Dali::Actor >::size_type arg2 ;
26977
26978   arg1 = (std::vector< Dali::Actor > *)jarg1;
26979   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
26980   {
26981     try {
26982       (arg1)->reserve(arg2);
26983     } CALL_CATCH_EXCEPTION();
26984   }
26985
26986 }
26987
26988
26989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
26990   void * jresult ;
26991   std::vector< Dali::Actor > *result = 0 ;
26992
26993   {
26994     try {
26995       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
26996     } CALL_CATCH_EXCEPTION(0);
26997   }
26998
26999   jresult = (void *)result;
27000   return jresult;
27001 }
27002
27003
27004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
27005   void * jresult ;
27006   std::vector< Dali::Actor > *arg1 = 0 ;
27007   std::vector< Dali::Actor > *result = 0 ;
27008
27009   arg1 = (std::vector< Dali::Actor > *)jarg1;
27010   if (!arg1) {
27011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
27012     return 0;
27013   }
27014   {
27015     try {
27016       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
27017     } CALL_CATCH_EXCEPTION(0);
27018   }
27019
27020   jresult = (void *)result;
27021   return jresult;
27022 }
27023
27024
27025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
27026   void * jresult ;
27027   int arg1 ;
27028   std::vector< Dali::Actor > *result = 0 ;
27029
27030   arg1 = (int)jarg1;
27031   {
27032     try {
27033       try {
27034         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
27035       }
27036       catch(std::out_of_range &_e) {
27037         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
27038         return 0;
27039       }
27040
27041     } CALL_CATCH_EXCEPTION(0);
27042   }
27043
27044   jresult = (void *)result;
27045   return jresult;
27046 }
27047
27048
27049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
27050   void * jresult ;
27051   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
27052   int arg2 ;
27053   Dali::Actor result;
27054
27055   arg1 = (std::vector< Dali::Actor > *)jarg1;
27056   arg2 = (int)jarg2;
27057   {
27058     try {
27059       try {
27060         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
27061       }
27062       catch(std::out_of_range &_e) {
27063         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
27064         return 0;
27065       }
27066
27067     } CALL_CATCH_EXCEPTION(0);
27068   }
27069
27070   jresult = new Dali::Actor((const Dali::Actor &)result);
27071   return jresult;
27072 }
27073
27074
27075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
27076   void * jresult ;
27077   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
27078   int arg2 ;
27079   Dali::Actor *result = 0 ;
27080
27081   arg1 = (std::vector< Dali::Actor > *)jarg1;
27082   arg2 = (int)jarg2;
27083   {
27084     try {
27085       try {
27086         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
27087       }
27088       catch(std::out_of_range &_e) {
27089         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
27090         return 0;
27091       }
27092
27093     } CALL_CATCH_EXCEPTION(0);
27094   }
27095
27096   jresult = (void *)result;
27097   return jresult;
27098 }
27099
27100
27101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
27102   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
27103   int arg2 ;
27104   Dali::Actor *arg3 = 0 ;
27105
27106   arg1 = (std::vector< Dali::Actor > *)jarg1;
27107   arg2 = (int)jarg2;
27108   arg3 = (Dali::Actor *)jarg3;
27109   if (!arg3) {
27110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
27111     return ;
27112   }
27113   {
27114     try {
27115       try {
27116         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
27117       }
27118       catch(std::out_of_range &_e) {
27119         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
27120         return ;
27121       }
27122
27123     } CALL_CATCH_EXCEPTION();
27124   }
27125
27126 }
27127
27128
27129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
27130   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
27131   std::vector< Dali::Actor > *arg2 = 0 ;
27132
27133   arg1 = (std::vector< Dali::Actor > *)jarg1;
27134   arg2 = (std::vector< Dali::Actor > *)jarg2;
27135   if (!arg2) {
27136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
27137     return ;
27138   }
27139   {
27140     try {
27141       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
27142     } CALL_CATCH_EXCEPTION();
27143   }
27144
27145 }
27146
27147
27148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
27149   void * jresult ;
27150   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
27151   int arg2 ;
27152   int arg3 ;
27153   std::vector< Dali::Actor > *result = 0 ;
27154
27155   arg1 = (std::vector< Dali::Actor > *)jarg1;
27156   arg2 = (int)jarg2;
27157   arg3 = (int)jarg3;
27158   {
27159     try {
27160       try {
27161         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
27162       }
27163       catch(std::out_of_range &_e) {
27164         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
27165         return 0;
27166       }
27167       catch(std::invalid_argument &_e) {
27168         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
27169         return 0;
27170       }
27171
27172     } CALL_CATCH_EXCEPTION(0);
27173   }
27174
27175   jresult = (void *)result;
27176   return jresult;
27177 }
27178
27179
27180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
27181   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
27182   int arg2 ;
27183   Dali::Actor *arg3 = 0 ;
27184
27185   arg1 = (std::vector< Dali::Actor > *)jarg1;
27186   arg2 = (int)jarg2;
27187   arg3 = (Dali::Actor *)jarg3;
27188   if (!arg3) {
27189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
27190     return ;
27191   }
27192   {
27193     try {
27194       try {
27195         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
27196       }
27197       catch(std::out_of_range &_e) {
27198         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
27199         return ;
27200       }
27201
27202     } CALL_CATCH_EXCEPTION();
27203   }
27204
27205 }
27206
27207
27208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
27209   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
27210   int arg2 ;
27211   std::vector< Dali::Actor > *arg3 = 0 ;
27212
27213   arg1 = (std::vector< Dali::Actor > *)jarg1;
27214   arg2 = (int)jarg2;
27215   arg3 = (std::vector< Dali::Actor > *)jarg3;
27216   if (!arg3) {
27217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
27218     return ;
27219   }
27220   {
27221     try {
27222       try {
27223         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
27224       }
27225       catch(std::out_of_range &_e) {
27226         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
27227         return ;
27228       }
27229
27230     } CALL_CATCH_EXCEPTION();
27231   }
27232
27233 }
27234
27235
27236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
27237   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
27238   int arg2 ;
27239
27240   arg1 = (std::vector< Dali::Actor > *)jarg1;
27241   arg2 = (int)jarg2;
27242   {
27243     try {
27244       try {
27245         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
27246       }
27247       catch(std::out_of_range &_e) {
27248         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
27249         return ;
27250       }
27251
27252     } CALL_CATCH_EXCEPTION();
27253   }
27254
27255 }
27256
27257
27258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
27259   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
27260   int arg2 ;
27261   int arg3 ;
27262
27263   arg1 = (std::vector< Dali::Actor > *)jarg1;
27264   arg2 = (int)jarg2;
27265   arg3 = (int)jarg3;
27266   {
27267     try {
27268       try {
27269         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
27270       }
27271       catch(std::out_of_range &_e) {
27272         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
27273         return ;
27274       }
27275       catch(std::invalid_argument &_e) {
27276         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
27277         return ;
27278       }
27279
27280     } CALL_CATCH_EXCEPTION();
27281   }
27282
27283 }
27284
27285
27286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
27287   void * jresult ;
27288   Dali::Actor *arg1 = 0 ;
27289   int arg2 ;
27290   std::vector< Dali::Actor > *result = 0 ;
27291
27292   arg1 = (Dali::Actor *)jarg1;
27293   if (!arg1) {
27294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
27295     return 0;
27296   }
27297   arg2 = (int)jarg2;
27298   {
27299     try {
27300       try {
27301         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
27302       }
27303       catch(std::out_of_range &_e) {
27304         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
27305         return 0;
27306       }
27307
27308     } CALL_CATCH_EXCEPTION(0);
27309   }
27310
27311   jresult = (void *)result;
27312   return jresult;
27313 }
27314
27315
27316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
27317   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
27318
27319   arg1 = (std::vector< Dali::Actor > *)jarg1;
27320   {
27321     try {
27322       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
27323     } CALL_CATCH_EXCEPTION();
27324   }
27325
27326 }
27327
27328
27329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
27330   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
27331   int arg2 ;
27332   int arg3 ;
27333
27334   arg1 = (std::vector< Dali::Actor > *)jarg1;
27335   arg2 = (int)jarg2;
27336   arg3 = (int)jarg3;
27337   {
27338     try {
27339       try {
27340         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
27341       }
27342       catch(std::out_of_range &_e) {
27343         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
27344         return ;
27345       }
27346       catch(std::invalid_argument &_e) {
27347         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
27348         return ;
27349       }
27350
27351     } CALL_CATCH_EXCEPTION();
27352   }
27353
27354 }
27355
27356
27357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
27358   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
27359   int arg2 ;
27360   std::vector< Dali::Actor > *arg3 = 0 ;
27361
27362   arg1 = (std::vector< Dali::Actor > *)jarg1;
27363   arg2 = (int)jarg2;
27364   arg3 = (std::vector< Dali::Actor > *)jarg3;
27365   if (!arg3) {
27366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
27367     return ;
27368   }
27369   {
27370     try {
27371       try {
27372         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
27373       }
27374       catch(std::out_of_range &_e) {
27375         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
27376         return ;
27377       }
27378
27379     } CALL_CATCH_EXCEPTION();
27380   }
27381
27382 }
27383
27384
27385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
27386   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
27387
27388   arg1 = (std::vector< Dali::Actor > *)jarg1;
27389   {
27390     try {
27391       delete arg1;
27392     } CALL_CATCH_EXCEPTION();
27393   }
27394
27395 }
27396
27397
27398 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
27399   bool jresult ;
27400   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
27401   bool result;
27402
27403   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
27404   {
27405     try {
27406       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
27407     } CALL_CATCH_EXCEPTION(0);
27408   }
27409
27410   jresult = result;
27411   return jresult;
27412 }
27413
27414
27415 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
27416   unsigned long jresult ;
27417   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
27418   std::size_t result;
27419
27420   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
27421   {
27422     try {
27423       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
27424     } CALL_CATCH_EXCEPTION(0);
27425   }
27426
27427   jresult = (unsigned long)result;
27428   return jresult;
27429 }
27430
27431
27432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
27433   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
27434   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
27435
27436   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
27437   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
27438   {
27439     try {
27440       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
27441     } CALL_CATCH_EXCEPTION();
27442   }
27443
27444 }
27445
27446
27447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
27448   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
27449   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
27450
27451   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
27452   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
27453   {
27454     try {
27455       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
27456     } CALL_CATCH_EXCEPTION();
27457   }
27458
27459 }
27460
27461
27462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
27463   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
27464   Dali::Actor arg2 ;
27465   Dali::Actor arg3 ;
27466   Dali::Actor *argp2 ;
27467   Dali::Actor *argp3 ;
27468
27469   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
27470   argp2 = (Dali::Actor *)jarg2;
27471   if (!argp2) {
27472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
27473     return ;
27474   }
27475   arg2 = *argp2;
27476   argp3 = (Dali::Actor *)jarg3;
27477   if (!argp3) {
27478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
27479     return ;
27480   }
27481   arg3 = *argp3;
27482   {
27483     try {
27484       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
27485     } CALL_CATCH_EXCEPTION();
27486   }
27487
27488 }
27489
27490
27491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
27492   void * jresult ;
27493   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
27494
27495   {
27496     try {
27497       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
27498     } CALL_CATCH_EXCEPTION(0);
27499   }
27500
27501   jresult = (void *)result;
27502   return jresult;
27503 }
27504
27505
27506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
27507   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
27508
27509   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
27510   {
27511     try {
27512       delete arg1;
27513     } CALL_CATCH_EXCEPTION();
27514   }
27515
27516 }
27517
27518
27519 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
27520   bool jresult ;
27521   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
27522   bool result;
27523
27524   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
27525   {
27526     try {
27527       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
27528     } CALL_CATCH_EXCEPTION(0);
27529   }
27530
27531   jresult = result;
27532   return jresult;
27533 }
27534
27535
27536 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
27537   unsigned long jresult ;
27538   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
27539   std::size_t result;
27540
27541   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
27542   {
27543     try {
27544       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
27545     } CALL_CATCH_EXCEPTION(0);
27546   }
27547
27548   jresult = (unsigned long)result;
27549   return jresult;
27550 }
27551
27552
27553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
27554   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
27555   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
27556
27557   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
27558   arg2 = (void (*)(Dali::Actor,bool))jarg2;
27559   {
27560     try {
27561       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
27562     } CALL_CATCH_EXCEPTION();
27563   }
27564
27565 }
27566
27567
27568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
27569   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
27570   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
27571
27572   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
27573   arg2 = (void (*)(Dali::Actor,bool))jarg2;
27574   {
27575     try {
27576       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
27577     } CALL_CATCH_EXCEPTION();
27578   }
27579
27580 }
27581
27582
27583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, bool jarg3) {
27584   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
27585   Dali::Actor arg2 ;
27586   bool arg3 ;
27587   Dali::Actor *argp2 ;
27588
27589   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
27590   argp2 = (Dali::Actor *)jarg2;
27591   if (!argp2) {
27592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
27593     return ;
27594   }
27595   arg2 = *argp2;
27596   arg3 = jarg3 ? true : false;
27597   {
27598     try {
27599       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
27600     } CALL_CATCH_EXCEPTION();
27601   }
27602
27603 }
27604
27605
27606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
27607   void * jresult ;
27608   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
27609
27610   {
27611     try {
27612       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
27613     } CALL_CATCH_EXCEPTION(0);
27614   }
27615
27616   jresult = (void *)result;
27617   return jresult;
27618 }
27619
27620
27621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
27622   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
27623
27624   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
27625   {
27626     try {
27627       delete arg1;
27628     } CALL_CATCH_EXCEPTION();
27629   }
27630
27631 }
27632
27633
27634 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_GenerateUrl(void* handle)
27635 {
27636   Dali::Toolkit::ImageUrl result;
27637   NativeImageSource* nativeImageSource = (NativeImageSource*)handle;
27638   void *jresult;
27639
27640   if (!nativeImageSource)
27641   {
27642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0);
27643     return 0;
27644   }
27645   {
27646     try
27647     {
27648       result = Dali::Toolkit::Image::GenerateUrl(nativeImageSource);
27649     }
27650     catch (std::out_of_range& e)
27651     {
27652       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
27653       return 0;
27654     }
27655     catch (std::exception& e)
27656     {
27657       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
27658       return 0;
27659     }
27660     catch (Dali::DaliException e)
27661     {
27662       SWIG_CSharpException(SWIG_UnknownError, e.condition);
27663       return 0;
27664     }
27665     catch (...)
27666     {
27667       SWIG_CSharpException(SWIG_UnknownError, "unknown error");
27668       return 0;
27669     }
27670   }
27671
27672   jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl &)result);
27673   return jresult;
27674 }
27675
27676
27677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageUrl(void* jarg1)
27678 {
27679   Dali::Toolkit::ImageUrl* imageUrl = (Dali::Toolkit::ImageUrl*) 0;
27680
27681   imageUrl = (Dali::Toolkit::ImageUrl*)jarg1;
27682   {
27683     try
27684     {
27685       delete imageUrl;
27686     }
27687     catch (std::out_of_range& e)
27688     {
27689       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
27690       return;
27691     }
27692     catch (std::exception& e)
27693     {
27694       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
27695       return;
27696     }
27697     catch (Dali::DaliException e)
27698     {
27699       SWIG_CSharpException(SWIG_UnknownError, e.condition);
27700       return;
27701     }
27702     catch (...)
27703     {
27704       SWIG_CSharpException(SWIG_UnknownError, "unknown error");
27705       return;
27706     }
27707   }
27708 }
27709
27710 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImageUrl_Get(void* jarg1)
27711 {
27712   char *jresult;
27713   Dali::Toolkit::ImageUrl* imageUrl = (Dali::Toolkit::ImageUrl*) 0;
27714   std::string result;
27715
27716   imageUrl = (Dali::Toolkit::ImageUrl*)jarg1;
27717   {
27718     try
27719     {
27720       result = imageUrl->GetUrl();
27721     }
27722     catch (std::out_of_range& e)
27723     {
27724       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
27725       return 0;
27726     }
27727     catch (std::exception& e)
27728     {
27729       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
27730       return 0;
27731     }
27732     catch (Dali::DaliException e)
27733     {
27734       SWIG_CSharpException(SWIG_UnknownError, e.condition);
27735       return 0;
27736     }
27737     catch (...)
27738     {
27739       SWIG_CSharpException(SWIG_UnknownError, "unknown error");
27740       return 0;
27741     }
27742   }
27743
27744   jresult = SWIG_csharp_string_callback((&result)->c_str());
27745   return jresult;
27746 }
27747
27748
27749 // TODO : SwigDirector_ViewImpl
27750
27751
27752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnection(void * jarg1, int jarg2) {
27753   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27754   int arg2 ;
27755   SwigDirector_ViewImpl *darg = 0;
27756
27757   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27758   arg2 = (int)jarg2;
27759   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27760   if(!darg) {
27761     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27762     return;
27763   }
27764   {
27765     try {
27766       if(darg) {
27767         (darg)->OnSceneConnection(arg2);
27768       }
27769     } CALL_CATCH_EXCEPTION();
27770   }
27771
27772 }
27773
27774
27775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
27776   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27777   int arg2 ;
27778   SwigDirector_ViewImpl *darg = 0;
27779
27780   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27781   arg2 = (int)jarg2;
27782   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27783   if(!darg) {
27784     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27785     return;
27786   }
27787   {
27788     try {
27789       if(darg) {
27790         (darg)->OnSceneConnectionSwigPublic(arg2);
27791       }
27792     } CALL_CATCH_EXCEPTION();
27793   }
27794
27795 }
27796
27797
27798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnection(void * jarg1) {
27799   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27800   SwigDirector_ViewImpl *darg = 0;
27801
27802   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27803   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27804   if(!darg) {
27805     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27806     return;
27807   }
27808   {
27809     try {
27810       if(darg) {
27811         (darg)->OnSceneDisconnection();
27812       }
27813     } CALL_CATCH_EXCEPTION();
27814   }
27815
27816 }
27817
27818
27819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnectionSwigExplicitViewImpl(void * jarg1) {
27820   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27821   SwigDirector_ViewImpl *darg = 0;
27822
27823   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27824   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27825   if(!darg) {
27826     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27827     return;
27828   }
27829   {
27830     try {
27831       if(darg) {
27832         (darg)->OnSceneDisconnectionSwigPublic();
27833       }
27834     } CALL_CATCH_EXCEPTION();
27835   }
27836
27837 }
27838
27839
27840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
27841   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27842   Dali::Actor *arg2 = 0 ;
27843   SwigDirector_ViewImpl *darg = 0;
27844
27845   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27846   arg2 = (Dali::Actor *)jarg2;
27847   if (!arg2) {
27848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
27849     return ;
27850   }
27851   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27852   if(!darg) {
27853     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27854     return;
27855   }
27856   {
27857     try {
27858       if(darg) {
27859         (darg)->OnChildAdd(*arg2);
27860       }
27861     } CALL_CATCH_EXCEPTION();
27862   }
27863
27864 }
27865
27866
27867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
27868   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27869   Dali::Actor *arg2 = 0 ;
27870   SwigDirector_ViewImpl *darg = 0;
27871
27872   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27873   arg2 = (Dali::Actor *)jarg2;
27874   if (!arg2) {
27875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
27876     return ;
27877   }
27878   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27879   if(!darg) {
27880     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27881     return;
27882   }
27883   {
27884     try {
27885       if(darg) {
27886           (darg)->OnChildAddSwigPublic(*arg2);
27887       }
27888     } CALL_CATCH_EXCEPTION();
27889   }
27890
27891 }
27892
27893
27894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
27895   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27896   Dali::Actor *arg2 = 0 ;
27897   SwigDirector_ViewImpl *darg = 0;
27898
27899   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27900   arg2 = (Dali::Actor *)jarg2;
27901   if (!arg2) {
27902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
27903     return ;
27904   }
27905   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27906   if(!darg) {
27907     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27908     return;
27909   }
27910   {
27911     try {
27912       if(darg) {
27913         (darg)->OnChildRemove(*arg2);
27914       }
27915     } CALL_CATCH_EXCEPTION();
27916   }
27917
27918 }
27919
27920
27921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
27922   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27923   Dali::Actor *arg2 = 0 ;
27924   SwigDirector_ViewImpl *darg = 0;
27925
27926   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27927   arg2 = (Dali::Actor *)jarg2;
27928   if (!arg2) {
27929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
27930     return ;
27931   }
27932   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27933   if(!darg) {
27934     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27935     return;
27936   }
27937   {
27938     try {
27939       if(darg) {
27940         (darg)->OnChildRemoveSwigPublic(*arg2);
27941       }
27942     } CALL_CATCH_EXCEPTION();
27943   }
27944
27945 }
27946
27947
27948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
27949   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27950   Dali::Property::Index arg2 ;
27951   Dali::Property::Value arg3 ;
27952   Dali::Property::Value *argp3 ;
27953   SwigDirector_ViewImpl *darg = 0;
27954
27955   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27956   arg2 = (Dali::Property::Index)jarg2;
27957   argp3 = (Dali::Property::Value *)jarg3;
27958   if (!argp3) {
27959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
27960     return ;
27961   }
27962   arg3 = *argp3;
27963   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27964   if (!darg) {
27965     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27966     return;
27967   }
27968   {
27969     try {
27970       (darg)->OnPropertySet(arg2,arg3);
27971     } CALL_CATCH_EXCEPTION();
27972   }
27973
27974 }
27975
27976
27977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
27978   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27979   Dali::Vector3 *arg2 = 0 ;
27980   SwigDirector_ViewImpl *darg = 0;
27981
27982   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27983   arg2 = (Dali::Vector3 *)jarg2;
27984   if (!arg2) {
27985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
27986     return ;
27987   }
27988   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27989   if (!darg) {
27990     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27991     return;
27992   }
27993   {
27994     try {
27995       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
27996     } CALL_CATCH_EXCEPTION();
27997   }
27998
27999 }
28000
28001
28002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
28003   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28004   Dali::Vector3 *arg2 = 0 ;
28005   SwigDirector_ViewImpl *darg = 0;
28006
28007   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28008   arg2 = (Dali::Vector3 *)jarg2;
28009   if (!arg2) {
28010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
28011     return ;
28012   }
28013   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28014   if (!darg) {
28015     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28016     return;
28017   }
28018   {
28019     try {
28020       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
28021     } CALL_CATCH_EXCEPTION();
28022   }
28023
28024 }
28025
28026
28027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
28028   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28029   Dali::Animation *arg2 = 0 ;
28030   Dali::Vector3 *arg3 = 0 ;
28031   SwigDirector_ViewImpl *darg = 0;
28032
28033   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28034   arg2 = (Dali::Animation *)jarg2;
28035   if (!arg2) {
28036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
28037     return ;
28038   }
28039   arg3 = (Dali::Vector3 *)jarg3;
28040   if (!arg3) {
28041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
28042     return ;
28043   }
28044   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28045   if (!darg) {
28046     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28047     return;
28048   }
28049   {
28050     try {
28051       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
28052     } CALL_CATCH_EXCEPTION();
28053   }
28054
28055 }
28056
28057
28058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
28059   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28060   Dali::Animation *arg2 = 0 ;
28061   Dali::Vector3 *arg3 = 0 ;
28062   SwigDirector_ViewImpl *darg = 0;
28063
28064   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28065   arg2 = (Dali::Animation *)jarg2;
28066   if (!arg2) {
28067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
28068     return ;
28069   }
28070   arg3 = (Dali::Vector3 *)jarg3;
28071   if (!arg3) {
28072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
28073     return ;
28074   }
28075   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28076   if (!darg) {
28077     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28078     return;
28079   }
28080   {
28081     try {
28082       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
28083     } CALL_CATCH_EXCEPTION();
28084   }
28085 }
28086
28087 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
28088   bool jresult ;
28089   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28090   Dali::KeyEvent *arg2 = 0 ;
28091   SwigDirector_ViewImpl *darg = 0;
28092   bool result;
28093
28094   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28095   arg2 = (Dali::KeyEvent *)jarg2;
28096   if (!arg2) {
28097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28098     return 0;
28099   }
28100   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28101   if (!darg) {
28102     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28103     return 0;
28104   }
28105   {
28106     try {
28107       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
28108     } CALL_CATCH_EXCEPTION(0);
28109   }
28110
28111   jresult = result;
28112   return jresult;
28113 }
28114
28115
28116 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
28117   bool jresult ;
28118   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28119   Dali::KeyEvent *arg2 = 0 ;
28120   SwigDirector_ViewImpl *darg = 0;
28121   bool result;
28122
28123   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28124   arg2 = (Dali::KeyEvent *)jarg2;
28125   if (!arg2) {
28126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28127     return 0;
28128   }
28129   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28130   if (!darg) {
28131     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28132     return 0;
28133   }
28134   {
28135     try {
28136       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
28137     } CALL_CATCH_EXCEPTION(0);
28138   }
28139
28140   jresult = result;
28141   return jresult;
28142 }
28143
28144
28145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
28146   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28147   Dali::Vector2 *arg2 = 0 ;
28148   Dali::RelayoutContainer *arg3 = 0 ;
28149   SwigDirector_ViewImpl *darg = 0;
28150
28151   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28152   arg2 = (Dali::Vector2 *)jarg2;
28153   if (!arg2) {
28154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
28155     return ;
28156   }
28157   arg3 = (Dali::RelayoutContainer *)jarg3;
28158   if (!arg3) {
28159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
28160     return ;
28161   }
28162   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28163   if (!darg) {
28164     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28165     return;
28166   }
28167   {
28168     try {
28169       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
28170     } CALL_CATCH_EXCEPTION();
28171   }
28172
28173 }
28174
28175
28176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
28177   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28178   Dali::Vector2 *arg2 = 0 ;
28179   Dali::RelayoutContainer *arg3 = 0 ;
28180   SwigDirector_ViewImpl *darg = 0;
28181
28182   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28183   arg2 = (Dali::Vector2 *)jarg2;
28184   if (!arg2) {
28185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
28186     return ;
28187   }
28188   arg3 = (Dali::RelayoutContainer *)jarg3;
28189   if (!arg3) {
28190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
28191     return ;
28192   }
28193   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28194   if (!darg) {
28195     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28196     return;
28197   }
28198   {
28199     try {
28200       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
28201     } CALL_CATCH_EXCEPTION();
28202   }
28203
28204 }
28205
28206
28207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
28208   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28209   Dali::ResizePolicy::Type arg2 ;
28210   Dali::Dimension::Type arg3 ;
28211   SwigDirector_ViewImpl *darg = 0;
28212
28213   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28214   arg2 = (Dali::ResizePolicy::Type)jarg2;
28215   arg3 = (Dali::Dimension::Type)jarg3;
28216   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28217   if (!darg) {
28218     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28219     return;
28220   }
28221   {
28222     try {
28223       (darg)->OnSetResizePolicy(arg2,arg3);
28224     } CALL_CATCH_EXCEPTION();
28225   }
28226
28227 }
28228
28229
28230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
28231   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28232   Dali::ResizePolicy::Type arg2 ;
28233   Dali::Dimension::Type arg3 ;
28234   SwigDirector_ViewImpl *darg = 0;
28235
28236   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28237   arg2 = (Dali::ResizePolicy::Type)jarg2;
28238   arg3 = (Dali::Dimension::Type)jarg3;
28239   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28240   if (!darg) {
28241     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28242     return;
28243   }
28244   {
28245     try {
28246       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
28247     } CALL_CATCH_EXCEPTION();
28248   }
28249
28250 }
28251
28252
28253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
28254   void * jresult ;
28255   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28256   SwigDirector_ViewImpl *darg = 0;
28257   Dali::Vector3 result;
28258
28259   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28260   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28261   if (!darg) {
28262     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28263     return 0;
28264   }
28265   {
28266     try {
28267       result = (darg)->GetNaturalSize();
28268     } CALL_CATCH_EXCEPTION(0);
28269   }
28270
28271   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
28272   return jresult;
28273 }
28274
28275
28276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
28277   void * jresult ;
28278   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28279   SwigDirector_ViewImpl *darg = 0;
28280   Dali::Vector3 result;
28281
28282   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28283   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28284   if (!darg) {
28285     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28286     return 0;
28287   }
28288   {
28289     try {
28290       result = (darg)->GetNaturalSizeSwigPublic();
28291     } CALL_CATCH_EXCEPTION(0);
28292   }
28293
28294   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
28295   return jresult;
28296 }
28297
28298
28299 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
28300   float jresult ;
28301   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28302   Dali::Actor *arg2 = 0 ;
28303   Dali::Dimension::Type arg3 ;
28304   SwigDirector_ViewImpl *darg = 0;
28305   float result;
28306
28307   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28308   arg2 = (Dali::Actor *)jarg2;
28309   if (!arg2) {
28310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
28311     return 0;
28312   }
28313   arg3 = (Dali::Dimension::Type)jarg3;
28314   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28315   if (!darg) {
28316     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28317     return 0;
28318   }
28319   {
28320     try {
28321       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
28322     } CALL_CATCH_EXCEPTION(0);
28323   }
28324
28325   jresult = result;
28326   return jresult;
28327 }
28328
28329
28330 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
28331   float jresult ;
28332   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28333   Dali::Actor *arg2 = 0 ;
28334   Dali::Dimension::Type arg3 ;
28335   SwigDirector_ViewImpl *darg = 0;
28336   float result;
28337
28338   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28339   arg2 = (Dali::Actor *)jarg2;
28340   if (!arg2) {
28341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
28342     return 0;
28343   }
28344   arg3 = (Dali::Dimension::Type)jarg3;
28345   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28346   if (!darg) {
28347     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28348     return 0;
28349   }
28350   {
28351     try {
28352       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
28353     } CALL_CATCH_EXCEPTION(0);
28354   }
28355
28356   jresult = result;
28357   return jresult;
28358 }
28359
28360
28361 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
28362   float jresult ;
28363   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28364   float arg2 ;
28365   SwigDirector_ViewImpl *darg = 0;
28366   float result;
28367
28368   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28369   arg2 = (float)jarg2;
28370   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28371   if (!darg) {
28372     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28373     return 0;
28374   }
28375   {
28376     try {
28377       result = (float)(darg)->GetHeightForWidth(arg2);
28378     } CALL_CATCH_EXCEPTION(0);
28379   }
28380
28381   jresult = result;
28382   return jresult;
28383 }
28384
28385
28386 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
28387   float jresult ;
28388   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28389   float arg2 ;
28390   SwigDirector_ViewImpl *darg = 0;
28391   float result;
28392
28393   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28394   arg2 = (float)jarg2;
28395   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28396   if (!darg) {
28397     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28398     return 0;
28399   }
28400   {
28401     try {
28402       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
28403     } CALL_CATCH_EXCEPTION(0);
28404   }
28405
28406   jresult = result;
28407   return jresult;
28408 }
28409
28410
28411 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
28412   float jresult ;
28413   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28414   float arg2 ;
28415   SwigDirector_ViewImpl *darg = 0;
28416   float result;
28417
28418   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28419   arg2 = (float)jarg2;
28420   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28421   if (!darg) {
28422     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28423     return 0;
28424   }
28425   {
28426     try {
28427       result = (float)(darg)->GetWidthForHeight(arg2);
28428     } CALL_CATCH_EXCEPTION(0);
28429   }
28430
28431   jresult = result;
28432   return jresult;
28433 }
28434
28435
28436 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
28437   float jresult ;
28438   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28439   float arg2 ;
28440   SwigDirector_ViewImpl *darg = 0;
28441   float result;
28442
28443   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28444   arg2 = (float)jarg2;
28445   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28446   if (!darg) {
28447     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28448     return 0;
28449   }
28450   {
28451     try {
28452       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
28453     } CALL_CATCH_EXCEPTION(0);
28454   }
28455
28456   jresult = result;
28457   return jresult;
28458 }
28459
28460
28461 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
28462   bool jresult ;
28463   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28464   Dali::Dimension::Type arg2 ;
28465   SwigDirector_ViewImpl *darg = 0;
28466   bool result;
28467
28468   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28469   arg2 = (Dali::Dimension::Type)jarg2;
28470   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28471   if (!darg) {
28472     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28473     return 0;
28474   }
28475   {
28476     try {
28477       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
28478     } CALL_CATCH_EXCEPTION(0);
28479   }
28480
28481   jresult = result;
28482   return jresult;
28483 }
28484
28485
28486 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
28487   bool jresult ;
28488   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28489   Dali::Dimension::Type arg2 ;
28490   SwigDirector_ViewImpl *darg = 0;
28491   bool result;
28492
28493   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28494   arg2 = (Dali::Dimension::Type)jarg2;
28495   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28496   if (!darg) {
28497     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28498     return 0;
28499   }
28500   {
28501     try {
28502       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
28503     } CALL_CATCH_EXCEPTION(0);
28504   }
28505
28506   jresult = result;
28507   return jresult;
28508 }
28509
28510
28511 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
28512   bool jresult ;
28513   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28514   SwigDirector_ViewImpl *darg = 0;
28515   bool result;
28516
28517   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28518   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28519   if (!darg) {
28520     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28521     return 0;
28522   }
28523   {
28524     try {
28525       result = (bool)(darg)->RelayoutDependentOnChildren();
28526     } CALL_CATCH_EXCEPTION(0);
28527   }
28528
28529   jresult = result;
28530   return jresult;
28531 }
28532
28533
28534 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
28535   bool jresult ;
28536   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28537   SwigDirector_ViewImpl *darg = 0;
28538   bool result;
28539
28540   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28541   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28542   if (!darg) {
28543     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28544     return 0;
28545   }
28546   {
28547     try {
28548       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
28549     } CALL_CATCH_EXCEPTION(0);
28550   }
28551
28552   jresult = result;
28553   return jresult;
28554 }
28555
28556
28557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
28558   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28559   Dali::Dimension::Type arg2 ;
28560   SwigDirector_ViewImpl *darg = 0;
28561
28562   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28563   arg2 = (Dali::Dimension::Type)jarg2;
28564   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28565   if (!darg) {
28566     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28567     return;
28568   }
28569   {
28570     try {
28571       (darg)->OnCalculateRelayoutSize(arg2);
28572     } CALL_CATCH_EXCEPTION();
28573   }
28574
28575 }
28576
28577
28578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
28579   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28580   Dali::Dimension::Type arg2 ;
28581   SwigDirector_ViewImpl *darg = 0;
28582
28583   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28584   arg2 = (Dali::Dimension::Type)jarg2;
28585   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28586   if (!darg) {
28587     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28588     return;
28589   }
28590   {
28591     try {
28592       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
28593     } CALL_CATCH_EXCEPTION();
28594   }
28595
28596 }
28597
28598
28599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
28600   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28601   float arg2 ;
28602   Dali::Dimension::Type arg3 ;
28603   SwigDirector_ViewImpl *darg = 0;
28604
28605   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28606   arg2 = (float)jarg2;
28607   arg3 = (Dali::Dimension::Type)jarg3;
28608   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28609   if (!darg) {
28610     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28611     return;
28612   }
28613   {
28614     try {
28615       (darg)->OnLayoutNegotiated(arg2,arg3);
28616     } CALL_CATCH_EXCEPTION();
28617   }
28618
28619 }
28620
28621
28622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
28623   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28624   float arg2 ;
28625   Dali::Dimension::Type arg3 ;
28626   SwigDirector_ViewImpl *darg = 0;
28627
28628   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28629   arg2 = (float)jarg2;
28630   arg3 = (Dali::Dimension::Type)jarg3;
28631   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28632   if (!darg) {
28633     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28634     return;
28635   }
28636   {
28637     try {
28638       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
28639     } CALL_CATCH_EXCEPTION();
28640   }
28641
28642 }
28643
28644
28645 // TODO : SwigDirector_ItemFactory
28646
28647
28648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
28649   void * jresult ;
28650   Dali::Toolkit::ItemFactory *result = 0 ;
28651
28652   {
28653     try {
28654       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
28655     } CALL_CATCH_EXCEPTION(0);
28656   }
28657
28658   jresult = (void *)result;
28659   return jresult;
28660 }
28661
28662 #ifdef __cplusplus
28663 }
28664 #endif